Independent forward-deployed engineer

Better AI starts inside the work.

Through Iroh Agents, I work alongside the people doing the job, find out where the time actually goes, and build the fix. Sometimes that’s AI. Often it’s something simpler. Either way, it isn’t done until your team can run it without me.

Forward-deployed means I work where the work happens: on site with your team whenever I can, remotely when that suits you better.

Example · a first-week workflow map

Customer requests, as they actually happen

  1. A request lands in the inbox
  2. Someone looks up the account
  3. They check the pricing rulesMargin note: do the rules only live in one person’s head?
  4. Crossed out: They re-type it into a trackerMargin note: typed twice. why?
  5. A manager approves the replyMargin note: keep this. it’s the real control
  6. The reply goes outMargin note: and then what? that’s the action behind the ask
An illustration, not a client’s map. Real ones are messier.

What I believe about this work

Find the action behind the ask.

When someone asks me for a dashboard, my first question is what they’ll do differently once they can see it. If nobody can say, a dashboard won’t help. If the answer is “call the customers who are about to cancel,” then we’re really building a call list, and that’s a smaller, better project.

Choose the simplest effective solution.

I don’t start with AI and look for somewhere to put it. If a shared-inbox rule or a cleaned-up spreadsheet solves the problem, that’s what I’ll recommend, and I’ll say so early, before anything gets built. When AI is the right tool, I use it carefully and check that it’s actually helping.

Make it work beyond the demo.

Demos are easy. The real test is a Tuesday three months later, when the input looks different and the person who set it up is out. I build for that day: someone who owns it, a way to switch it off, and a short note on fixing the usual problems.

How an engagement runs

Six stages, each ending in a decision we make together. If we learn something that changes the picture, we go back a step. That’s the process doing its job.

Not every engagement needs all six. Some end, usefully, after the first two with a recommendation you can act on.

Understand → Choose → Prove → Integrate → Launch & learn → Hand over

  1. Understand

    Find the problem worth solving.

    I spend time with the people doing the job and follow real tasks from start to finish, including the awkward ones. That shows me what the work is for, where the time goes, and what happens once it’s done.

    You get
    A workflow map
    We move on when
    We agree on the real problem, the outcome we want, and the baseline we’ll use to judge progress.
    What’s involved

    What I do

    • Follow a recent task from its trigger to the decision and next action it leads to.
    • Map the handoffs, the terms people use, and the authoritative records the team relies on.
    • Note current effort, delays, exceptions and the quality checks that must be kept.

    What you get

    • A map of the workflow and its business context
    • A baseline to measure against
    • A plain statement of the problem and the opportunity

    Your part: The person who owns the workflow, time with the people who do it, and approved examples we can walk through together.

  2. Choose

    The simplest fix that will hold up.

    I compare the options side by side: a process change, software you already have, plain automation, or AI. We pick the one with the best practical return for your business, which is often not the most sophisticated one.

    You get
    A one-page brief
    We move on when
    There’s a worthwhile, feasible change with an owner and success criteria, or a well-reasoned decision not to build anything.
    What’s involved

    What I do

    • Weigh the business value of each option against effort, data readiness and risk.
    • Count the running costs too, including review time and who will support it.
    • Agree one focused piece of work, how we’ll judge success, and where the scope stops.

    What you get

    • A short, prioritized list of opportunities
    • A focused scope
    • Success criteria and a named owner

    Your part: Your priorities and constraints, and someone who can approve the scope.

  3. Prove

    Find out if it works, cheaply.

    I build the smallest version that can answer the important questions, then test it against approved examples. We look at what it gets right, where it breaks, and whether it’s worth taking further.

    You get
    A prototype and test results
    We move on when
    The results meet the quality, cost and usability bar we agreed. Live use is a separate decision.
    What’s involved

    What I do

    • Compare the prototype with how your team handles the same task today.
    • Test ordinary cases, exceptions, missing information and bad inputs.
    • Measure quality, speed, review effort and cost, and go through the results with the people who’ll use it.

    What you get

    • A working prototype with stated limits and a review date
    • Repeatable tests and their results
    • A decision to retire it, revise it or take it forward

    Your part: Approved examples, and time from someone who can tell a good result from a bad one.

  4. Integrate

    Built into how you already work.

    I connect the proven approach to your existing systems, with the access it needs and no more. Error handling and a way back to doing it by hand are part of the job, not extras.

    You get
    A pilot and operating checklist
    We move on when
    You’ve approved the pilot’s limits, its access and how it behaves when something fails, before it touches live work.
    What’s involved

    What I do

    • Connect to the authoritative records through approved accounts with the narrowest permissions that work.
    • Log what the system does, retry safely, and prevent the same action happening twice.
    • Keep anything consequential behind a person’s approval, and test the recovery path.

    What you get

    • A working pilot inside your systems
    • A map of access, data and ownership
    • A tested manual fallback and rollback plan

    Your part: Someone who can approve access, and the right system administrator or vendor contact.

  5. Launch & learn

    Judge it by the work, not the software.

    We roll it out to a small group first. I work alongside them, look at every exception, and measure whether the job is actually getting easier.

    You get
    A pilot review
    We move on when
    Results from real use support the next step, and the running costs and risks are acceptable.
    What’s involved

    What I do

    • Train a pilot group and make sure everyone knows who to go to when something looks wrong.
    • Compare quality, turnaround and total effort with the baseline.
    • Turn corrections and sticking points into better tests and better rules.

    What you get

    • A pilot review against the baseline
    • A log of issues and improvements
    • A decision to keep, change, expand or stop

    Your part: A pilot group, honest feedback, and someone who will own it day to day.

  6. Hand over

    Yours to run.

    I prepare your team to operate what we built: documentation in plain language, an owner who has done the recovery steps themselves, and an honest picture of what it needs to keep running.

    You get
    A runbook and ownership map
    We move on when
    Your owner can run it and use the recovery path, and any further support is agreed in writing.
    What’s involved

    What I do

    • Transfer the agreed code, configuration, tests and documentation.
    • Train an owner to monitor it, recover it and make routine changes.
    • Confirm who maintains what, any ongoing support, and the third-party costs.

    What you get

    • A runbook and a handoff session
    • An ownership and vendor-cost checklist
    • Agreed support and exit arrangements

    Your part: A named owner and an agreed plan for running and supporting it.

Where it usually helps

These are illustrations, not client stories. They’re the kinds of everyday work where time quietly goes missing, and where a small, well-chosen change tends to pay off.

Illustrative workflows

Customer requests

Usually: AI drafting and light automation

Today

A request comes in by email. Someone digs through the account history, checks the rules, and pieces together what needs to happen next. Every time.

Could be

The relevant history and rules are gathered automatically, missing information is flagged, and a draft reply and next step are waiting inside the tools the team already uses.

People still decide
Your team checks the facts, handles the odd cases and approves every reply before it’s sent.
We’d measure
Time to resolve, how often drafts need correcting, and total handling time, review included.

Invoice exceptions

Usually: extraction, plain rules and an approval step

Today

Someone re-keys invoice details, compares them with the order, and chases missing information across email and the accounting system.

Could be

The details are extracted, routine matches are checked with simple rules, and only the mismatches go to a person, with the supporting documents attached.

People still decide
Your team resolves the exceptions and approves every payment.
We’d measure
Re-keying time, match accuracy, time spent on exceptions, and duplicate payments caught.

Recurring reports

Usually: reliable data first, then the right format

Today

A weekly report is assembled by hand, then someone reads through it trying to work out what actually needs attention.

Could be

The data is pulled and checked automatically, and the few items that need a decision are surfaced as an alert, a short summary or a simpler report, whichever people will actually use.

People still decide
A named owner checks the numbers, interprets them and decides what to do.
We’d measure
Preparation time, time to decision, data errors, and whether the follow-up actually happens.

What I won’t skip

Most of what makes a system dependable is unglamorous. These are the parts I don’t cut corners on.

  1. Nothing touches your live systems until you’ve seen how it handles the awkward cases.
  2. Anything that sends money, emails a customer or changes a record waits for a person to approve it.
  3. The system gets only the access the job needs, and you can see what it did and why.
  4. You own the accounts, the code and the instructions. If I’m unavailable, your team can still run it and fix the usual problems.
  5. I’ll tell you what it costs to run, including the time your team spends checking its work.

Working together

You work with me directly, from the first conversation to the handoff.

Where I work
On site with your team whenever I can. I’m happy to travel, because the quickest way to understand a workflow is to sit with the people doing it. If remote suits you better, that works too, with screen-shared walkthroughs and regular video check-ins.
How a week looks
One working session a week with the person who owns the workflow: what I learned, what’s working now, and the next decision. Progress shows up as something you can use or a written finding.
Who does the work
I do. If part of the job needs a specialist, I’ll tell you why, and nobody else gets involved without your approval.
What I need from you
Someone who owns the workflow, time with the people who do it, approved examples to work from, and someone who can grant access.
What you keep
The code, the configuration, the tests and a plain-language runbook, in accounts you control wherever possible.
How it starts
With a conversation about one workflow that’s causing friction. If it’s worth looking into, we agree a focused first phase that ends in a recommendation you can use even if we stop there.

Questions people ask first

What does “forward-deployed engineer” actually mean?

It means I work where the work happens, alongside your team, instead of building something at a distance and handing it over. The job covers the whole path: understanding the problem, building the fix and making sure people actually use it.

Do we need to know what we want built?

No. A recurring headache is enough to start. We’ll map it and decide together whether anything is worth building. Sometimes the answer is a simpler process or a tool you already pay for, and that’s a good outcome.

Will we have to replace our existing software?

Usually not. I start with the systems you already have and the integrations they support. If something makes a safe connection impractical, I’ll tell you before we commit to anything.

How is the work scoped?

One workflow at a time. Before each phase we agree what it should produce and which decision it should support, and at the end we decide together whether to go further. Discovery can stand on its own.

What happens after launch?

Before anything goes live, we agree who runs it, how it’s monitored and what to do when it fails. You get documentation and a handoff session. Ongoing support is optional and agreed separately.

Tell me what’s slowing your team down.

Email me a sentence or two about the work. I’ll reply myself, and if it sounds like something I can help with, we’ll find a time to talk.

Not ready to talk yet?

Write it down first. Five short questions give you a one-page brief to keep, or to paste into an email. It stays in your browser.

Starting brief

Write it down first.

Describe one piece of work you’d like to improve. You’ll get a short brief to keep, or to paste into an email to me. Nothing leaves your browser.