One engineer runs seven steps — workflow, bottleneck, scope, build, validate, measure, feed back — and iterates until the use case actually works.
ConceptWhat it is
The FDE delivery loop is the seven-step working cycle of a forward-deployed engagement: understand the workflow, find the bottleneck, scope a solution, build and integrate, validate with the user, measure the return, and feed what was learned back to the product. It exists because the hard part of applied AI is rarely the model call — it is knowing which step of whose day to change, proving the change paid, and making that proof reusable.
The loop's exit condition is a measured outcome, not a merged pull request; 'iterate until the use case works' is the job description, not a failure mode.
How it worksThe mechanics
The first two steps are discovery, done beside the people who run the workflow: watch how the work actually flows, then locate the bottleneck that costs the business most — often not the step anyone complained about. Scoping cuts the smallest solution that removes that bottleneck; build-and-integrate lands it inside the tools the team already uses rather than beside them. Validation happens with the user on their real cases, and measurement converts the result into the business's own units — hours saved, error rate down, cases cleared. The final step writes the learning back: what worked, what failed and why, folded into the roadmap, the playbook and the evals so the next engagement starts from it.
At a glanceSee it
When to use itWhere it fits
- Engagements where the use case is discovered on site rather than specified up front.
- Workflows with a measurable unit of pain — hours per case, error rate, backlog depth — that the loop can close against.
- First deployments at a new account, where trust is built by validating with the user before widening scope.
- AI features whose behavior on real data cannot be predicted from a specification.
When NOT to use itLimits & anti-patterns
- Well-specified builds under a fixed contract — the discovery steps add cost where the bottleneck is already known and agreed.
- Situations where nobody will sit with you: steps one, two and five all require the user's time, and skipping them turns the loop into a guess.
- Outcomes that cannot be stated in the customer's own units — a loop that cannot close its measurement step never terminates honestly.
Trade-offsAdvantages & costs
Advantages
- Starts from the bottleneck, so the thing built is the thing that pays.
- Validation and measurement are steps, not afterthoughts — the loop cannot complete around an unproven build.
- One owner end to end; nothing is lost between the person who heard the problem and the person who ships the fix.
- The seventh step makes every engagement raw material for the next one.
Trade-offs & costs
- Discovery time is real cost before any code exists — and it can conclude the best fix is not an AI build at all.
- Iterating until it works resists deadline-driven planning.
- Honest measurement can implicate the scoping — sometimes the bottleneck moved rather than shrank, and the loop has to say so.
- The whole cycle depends on a single engineer's range across discovery, engineering and communication.
ExampleIn the real world
Palantir made the role famous — its forward-deployed engineers build working software inside customer operations rather than back at headquarters — and the frontier AI labs now run the same loop, embedding engineers with enterprise customers to find the bottleneck, ship an integrated solution, measure it, and route what the field taught into the product itself.
ToolsHow to implement it
- Streamlita working interface in an afternoon: good enough to validate with, cheap enough to throw away after the pass.
- FastAPIthe fastest path from a scoped solution to an endpoint the customer's systems can actually call.
- pytest golden setsfreeze the user's validated cases as a re-runnable check before every subsequent change.
- The customer's own systemsthe integration target is their CRM, ticket queue or ERP; building beside them instead of into them is the classic step-four failure.
Cost & effortWhat it takes
Mostly labor: expect discovery and validation together to take as long as the build, and cost the loop in passes rather than weeks — two or three circuits before the metric clears is normal, and the cheapest engagements are the ones that kill a weak use case at the bottleneck step, before anything was built.