What a forward-deployed engineer actually does

A forward-deployed engineer works inside a customer's team to make a product or AI system actually work in their world. The job runs in six steps: discovery, a scope that does as much as possible without a model, a prototype, deploying in the customer's own cloud, proving it with evals and cost numbers, and handing over. It needs engineering plus ten traits, from listening and judgement to ownership of the customer's result and the big picture.

A product works perfectly in the vendor's demo. Then it meets a real customer. Their data is in three systems that disagree. Their security team will not let anything leave their cloud. Their finance lead wants to know what it costs per month before anyone says yes.

Someone has to close that gap. Not a salesperson, and not a slide deck. An engineer who goes and sits with the customer's team, learns how their world works, and makes the product work in it.

That person is a forward-deployed engineer, or FDE. "Forward" is borrowed from the army: you work at the front, where the customer is, not back at headquarters.

An engineer with a backpack

The simplest picture of the job is an engineer who packs a bag and moves into the customer's office for a few weeks or months.

the bag carries what travels well; the customer's world is already in the officethe FDEIn the bagthe product, tools,build-test-measure habitswalks inTHE CUSTOMER'S OFFICETheir datathree systems that disagreeTheir ruleswho may see whatTheir peoplethe real problem, in wordsTheir cloudnothing leaves itThe jobjoin the bag to this world
An FDE brings the product and the habits. Everything that makes it hard is already in the customer's office.

The bag holds the things that travel well: the product, a set of tools, and habits for building, testing and measuring. What is not in the bag is the customer's world. Their data, their rules, their people and their cloud are all already in that office. The FDE's job is to join the two.

This is why the role exists mostly around AI systems and data platforms today. A model or a platform is generic. The value only appears when it is wired into one company's messy, specific reality.

The job in six steps

Every engagement is different, but the shape repeats. Here it is as a path.

one path, six milestones; each stop answers a question before the next1 Discoveryproblem, data,rules2 Scopewhat code can dowithout a model3 Prototypeone slice, realdata, end to end4 Deployin their cloud,their sign-in5 Proveeval score andcost per task6 Hand overrunbook, note,their own team
The six-step journey. The finish line is not the demo; it is the customer running it without you.
  1. Discovery. Find out three things before writing any code: what problem, in the customer's own words; what data exists, where it lives and how good it is; and what rules apply, such as who may see what and what must never happen. A good week of discovery saves a bad month of building.
  2. A deterministic-first scope. "Deterministic" means the same input always gives the same output, like ordinary code or a SQL query. Before reaching for a model, ask how much of the job plain code can do. Often a lookup, a rule and a template answer most cases, and the model is only needed for the part that truly needs language. This makes the system cheaper, easier to test and easier to trust.
  3. A prototype. Build the smallest thing that works end to end on the customer's real data, even if only for one slice: one region, one product line, one kind of request. Show it early. The first reaction from real users is worth more than any requirement document.
  4. Deploy in their cloud. The customer's data usually cannot leave their account, and their security team must be able to see and switch off everything. So the system runs inside their cloud, with their sign-in, their network rules and their logs. This step is often slower than building the prototype, so plan for it from day one.
  5. Prove it with evals and cost numbers. An eval is a test set of real cases with known right answers that the system must pass before each release. Run it and show the score slice by slice. Then show what each answer or task costs, in rupees, including the people who review the output. "It looks good" is an opinion. "It got 92 of 100 refund cases right at about ₹3 a case" is a decision someone can make. (Those numbers are an example.)
  6. Hand over. The customer's own team must be able to run, change and fix the system after you leave. That means a runbook, a short design note, the eval set they can re-run, and at least one person on their side who has made a change while you watched. If it only works while you are in the room, it doesn't work.

The posts on offline evals and measuring agent ROI cover step five in depth, and one harness, five homes helps with step four when the customer's cloud is Azure, Google Cloud, AWS or Databricks. Together they make a decent toolkit.

The skills mix

Engineering is the base. You need to build things that run, read unfamiliar systems quickly and debug in someone else's environment. But engineering alone is not enough, and it is the ten traits across the top that make the job.

a T-shape: one deep skill, ten traits across the topListeningthe problem insidethe requestWritingscope, notes,runbookJudgementwhat not tobuildOwnershiptheir result,not my codeBig pictureupstream, downstream,company goalsEarning trustsmall promiseskeptAmbiguitya first stepwithout a specLearning speednew domainin daysPragmatismgood enough,shippedLessons backone fix becomesa product pieceEngineeringbuild, debug anddeploy in someoneelse's environmentthe stem gets youin the doorthe bar makes itwork for them
Engineering is the stem. Ten traits across the top turn it into the FDE job.

A useful test: could you explain what you built, why, and which company goal it moves, to the customer's finance lead in five minutes? If yes, the traits are working. The habit underneath all of them is in fail fast, own the result.

How it differs from nearby roles

The FDE is often confused with three other jobs. They overlap, but the centre of each is different.

same customer, three different centres of gravityCONSULTANTadvisesleaves witha reportPRODUCT ENGINEERbuilds for everyonerarely meets onecustomerFDEbuilds for this onestays until itworks, hands over
Consultant, product engineer, FDE. The solutions engineer sits between the first two, before the sale.
RoleMain jobWrites production code?Stays until it works?
ConsultantAdvise on what to doSometimesOften leaves with a report
Solutions engineerShow the product can fit, before the saleDemos and proofs of conceptUsually hands off after the sale
Product engineerBuild the product for all customersYes, in the productRarely meets a single customer
Forward-deployed engineerMake it work for this customerYes, in their environmentYes, then hands over

These are generalisations; real jobs blur the lines. The short version: a consultant advises, a solutions engineer persuades, a product engineer builds for everyone, and an FDE builds for one customer until it works. A good FDE also carries lessons back to the product team, because the same gap they closed by hand at one customer will appear at the next.

What goes wrong

How to grow into it

You don't need the title to practise the job. Most FDEs started as data, software or platform engineers who kept ending up in rooms with the people who used their work.

  1. Sit with your users. Ask to shadow the analysts or support staff who use what you build, for one afternoon. Write down every workaround you see.
  2. Practise deterministic-first. On your next feature, write down which part plain code can do before you reach for a model or a new service.
  3. Deploy into an environment you don't control. A different cloud account, a locked-down network, someone else's sign-in. It is uncomfortable, which is the point.
  4. Always end with a number. Get used to closing every piece of work with a test score and a cost.
  5. Write the hand-over note even when nobody asks. Then ask a colleague to make one change using only that note.
  6. Build one end-to-end project as if for a customer. On this site, projects carrying the "Forward-deployed ready" label are good ones to copy: take one, run it through the six steps above, and finish with an eval score, a cost and a hand-over note.

Seven questions to check your own FDE readiness

  1. Can you name the problem, the data and the rules for the last thing you built, in the user's words?
  2. Which part of it could have been done without a model or a new service?
  3. Could it run in someone else's cloud account by next week?
  4. Do you know its pass rate and its cost per task?
  5. Could someone else change it tomorrow without calling you?
  6. What is the customer better off by, in their own numbers?
  7. Who upstream and downstream would notice if your piece changed?

The product gets them interested; the forward-deployed engineer gets it working, proves it, and leaves it in good hands.