Forward Deployed Engineer: what the role is, and what it changes for the team buying one

The hottest role in the AI space for founders right now is an FDE- A forward deployed engineer. Read more to understand what the role entails.

UA
Unkapped Applied AI Team
Applied AI
Published
November 2, 2026
Reading time
15 Min
Forward Deployed Engineer: what the role is, and what it changes for the team buying one

Executive summary

  • For a chief information or technology officer (CIO or CTO) offered forward deployed engineers: how to decide whether to accept, and what your own team must own.
  • A forward deployed engineer is a software engineer who builds and ships production code inside your environment, for one customer at a time, and stays until the system runs.
  • Who employs the engineer shapes what gets built. A vendor's engineer builds on the vendor's platform, so ask what you will own and operate when they leave.
  • The receiving team owns four things the engineer cannot own for it: the problem, the access, the review gates and the handover.
  • An engagement has worked when someone on your team, not the engineer, can change the system and the test set still passes.

‍

If a model vendor, a cloud provider or an integrator has offered your team a forward deployed engineer, read this before you reply. Written for the CIO or CTO, it explains what the role is, whose interests the engineer serves, and what your own team must own so the system keeps running after the engineer leaves.

In 2026, several of those vendors turned forward deployed engineering into units they sell at scale. Accept an engineer without preparing the team that receives them, and you can end up with a system that runs only while its builder is in the building.

What is a forward deployed engineer?

A forward deployed engineer (FDE) is a software engineer who works inside a customer's own environment, on its data and systems, to build and ship a working production system for that customer. A software engineer on a product team builds a feature for every customer at once. An FDE builds for one customer at a time and stays accountable until the system runs.

Palantir, the data analytics software company, created the role in the early 2010s and still titles it forward deployed software engineer (FDSE). Palantir's own contrast is that a developer works on one capability for many customers, while an FDE works on one customer across many capabilities. "Forward deployed" means stationed with the customer rather than at head office.

The job has two halves: building inside your estate, and reporting back to the engineer's own company what its product cannot yet do. The Pragmatic Engineer describes OpenAI's FDEs building tests for a voice model at a call-centre customer, then taking the results to OpenAI's research team. The model improved for every customer.

The second half separates an FDE from a contractor, whose work ends at your boundary.

What does a forward deployed engineer do in a working week?

A forward deployed engineer splits the week between sitting with the people who do the work, writing and testing code in the customer's systems, and telling their own company what its product cannot yet do. The balance moves from listening towards building as the engagement goes from scoping to delivery.

OpenAI's FDE team, as The Pragmatic Engineer described in August 2025, runs projects in three phases. Scoping means a few days on site, sitting with users and prototyping on synthetic data. Validation sets success criteria and builds tests from labelled examples. Delivery ships the smallest system that works end to end.

Insist on the validation phase. It is where the scope meets your real data and gets corrected before anyone writes production code.

Time on site varies by provider. Palantir has expected about a quarter of an FDE's time with customers, and the healthcare company Commure up to half, according to job adverts cited in the same article.

A delivery week we recommend for an engagement like this shows what it asks of the people around the engineer:

  • Two mornings sitting with the people who do the work, to see where the workflow breaks in practice.
  • Most of the week building and testing against the test set, in a non-production environment.
  • Two half-hour decision slots with the problem owner.
  • One hour at the end of the week writing down what the build revealed.

How is a forward deployed engineer different from a solutions engineer, a consultant or a contractor?

Forward Deployed Engineer vs Other SImilar Roles like Solutions Engineer

‍

A solutions engineer designs and demonstrates before the sale, a consultant recommends and leaves, and a contractor takes tickets from your team. A forward deployed engineer writes production code in your environment after the sale and owns the outcome until it runs. For a buyer, the difference that matters is what you hold when they leave.

Read the table by its last column.

How a forward deployed engineer compares with roles buyers often confuse it with
Role Usually works for Main output Writes production code in your environment When they are involved What you hold when they leave
Forward deployed engineer Vendor or services firm, sometimes you A working system in your environment Yes After the sale, through go-live and beyond A running system and the agreed handover
Solutions engineer or solutions architect Vendor Designs, demos and proofs of concept, often on sample data Rarely Before the sale A design and a demo
Sales engineer Vendor The technical case for the deal No Before the sale A signed contract
Implementation consultant Vendor professional services or a systems integrator A product configured to a specification Configuration, sometimes code A project that ends at go-live A configured product and project documents
Strategy consultant Consultancy Recommendations and a roadmap No Before build A document someone else must build
Staff augmentation contractor Staffing firm or self-employed Tickets your team assigns Yes, under your direction The contract term Code your team directed

Is a forward deployed engineer just a renamed solutions engineer?

Sometimes it is, so test the offer rather than the title. Three markers decide it: whose data the work runs on, where the code lives, and what the person is judged by. An offer that meets only one of them is solutions work with a forward deployed title.

  • Data. Solutions work runs on sample, anonymised or offline data. Forward deployed work runs on your production data, under your access controls.
  • Code. Solutions work produces a proof of concept that can be thrown away. Forward deployed work produces code in your repository that someone must run next year.
  • Accountability. Solutions work is judged by the decision to buy. Forward deployed work is judged by whether the system runs in production, and keeps running.

The confusion is real. Practitioners on Blind regularly call the FDE a solutions engineer with a new name, and The Pragmatic Engineer notes that many startups use FDEs to help close deals.

OpenAI draws the line on the same markers: its solutions architects build proofs of concept on offline or anonymised data, while its FDEs write code on the customer's infrastructure (The Pragmatic Engineer). The role is not a sales job either. Exponent, citing an analysis of 1,000 FDE job postings, reports that none carried a sales quota.

Whose forward deployed engineer is it?

Every forward deployed engineer works for someone: a model vendor, a cloud vendor, an application vendor, a systems integrator, an independent engineering firm or you. The employer decides what they build on and what they are measured on. So the first buying question is what your team will own and be able to operate when they leave.

The employer shapes the engineer's incentives. In 2025, a16z advised vendors to align forward deployed teams closely with account executives, and to set pricing and compensation to match. That is a sensible design for a vendor, and it means the engineer's success can be tied to how much of the vendor's product you use.

We recommend one ownership rule above the rest: own, do not rent. Everything built should live in your accounts, not the provider's.

The table compares provider types. The third column is our reading of public statements, not a fact about any named company.

What changes depending on who employs the forward deployed engineer.
Provider type Builds on Likely to optimise for What you are likely to own afterwards Question to ask before you accept
Model vendor Its models and tools Production use of its models Code in your repository if agreed; the model stays theirs Which parts would we rebuild to change model provider?
Cloud vendor Its cloud services Workloads on its platform Infrastructure as code in your account if agreed What runs only on your services, and is that a design choice or a requirement?
Application vendor (a platform you already licence) Its platform Adoption and expansion of the platform, and product improvements from field work Configuration and custom code on its platform What has your forward deployed team changed in the product because of field work?
Systems integrator or consultancy The platforms it partners with or is certified on Delivery and follow-on work Whatever the contract’s IP and handover clauses say Which partnerships or certifications does this team hold, and how do they shape what you recommend?
Independent engineering firm Your existing stack The outcome in the contract Everything built, in your accounts, if agreed Do you take margin, commission or referral fees on any software you recommend?
Your own hire Your stack Your goals Everything, including the knowledge Can we offer this person a roadmap beyond the first project?

Who is selling forward deployed engineers in 2026?

Model vendors, cloud providers and their partner firms scaled forward deployed engineering into units they sell in 2026. That is why whose engineer to accept has become a buying decision. Three launches set the pattern:

Should you hire your own forward deployed engineers instead?

Hire your own when the work is permanent, the workflows are core to how you compete, and you can offer the engineer a roadmap beyond one project. Buy the capacity in when the technical path is unproven, speed matters more than headcount, or you need someone who has solved the same class of problem elsewhere.

Box's chief executive, Aaron Levie, wrote in May 2026 that, alongside technology and services firms, most mid-size and large enterprises will hire this talent internally. Hiring is slow, though: a September 2026 recruiting guide opens by describing three-month searches for the role.

A deliberate handover connects the two. &above, a London engineering firm, describes outside engineers opening up a capability before the client's own engineers take it over. Our view is to buy in to start and hire to keep, with the handover planned from the first week.

When does a team need a forward deployed engineer, and when is it a warning sign?

You need a forward deployed engineer when the work is specific to your workflows, the requirements only become clear once someone sits with the users, and the system must run inside your own controls. Treat it as a warning sign when a vendor needs one just to make its product work in a standard environment.

Place your own situation in the table before you reply to the offer.

Signals that embedded engineering fits, and signals that something else is needed first.
Signal What it indicates What to do
The workflow is specific to your business, and requirements only become clear once someone sits with the users Embedded build fits Consider an FDE, and write the charter first
The problem is clear, and the gap is engineering headcount Capacity, not discovery A contractor or a hire is simpler to manage
The vendor says its product needs an FDE to work in a standard environment A product gap you would pay to cover Ask what the forward deployed team has changed in the product, and price the dependency
Nobody on your side can own the workflow during the engagement and after it No receiving team Do not start until ownership is fixed
The system will act on customer data, money or external messages Controls matter more than speed Agree gates and security sign-off before access is granted
You need the capability permanently, and it is core to how you compete Long-term ownership Plan to hire, and use an outside engagement to start and hand over

What is the strongest case against forward deployed engineers?

The strongest case is that many FDEs exist to cover products that do not deploy cleanly, and that the customer ends up paying for the gap. The critics are right about part of the market, and one question tells you which part you are dealing with.

In June 2026 the chief executive of dotCMS, a content platform vendor, argued that there are two kinds of FDE. One kind exists because the product cannot deploy cleanly, which he calls technical debt passed to the customer. Decagon's chief executive goes further: embedding engineers for the long term means the software does not work.

Both kinds exist. Ask what the engineer will build that the product should already do. "Connect it to your single sign-on and read your customer relationship management (CRM) system" describes a product gap. "Redesign how your sales engineers answer security questionnaires, using your own approved answers" describes embedded build.

Keep the scale in proportion as well. Andrew Ng, the artificial intelligence (AI) researcher and educator, expects far more AI engineer roles than FDEs, and notes that a company might accept only a few embedded engineers.

Our position breaks in two cases. If vendors' platforms start deploying in enterprise estates without customer-specific build, the role shrinks to configuration. If receiving teams that prepared none of what follows still end up self-sufficient, we will revise this guide.

TL;DR: A forward deployed engineer builds inside your environment and stays until the system runs, which separates the role from a solutions engineer who advises and a contractor who takes tickets. Before accepting one, check whose engineer it is and whether you need custom build at all, or only a product that works.

What changes for the team that receives a forward deployed engineer?

FDEs work best when receiving team owns

The receiving team takes on four jobs the engineer cannot do for it: owning the problem and its success measure, granting scoped access to systems and data, setting the review gates a system must pass before it runs unattended, and preparing the people who will run it after handover.

We call these the problem, the access, the gates and the handover. The engineer controls the code. Your side controls who decides, what the engineer can touch, what counts as good enough, and who holds the system at the end.

Who owns the problem?

One named person on your side, with authority over the workflow being changed, owns the problem. They agree the success measure before build starts, make decisions within days rather than weeks, and will still own the system after the engineer leaves. Without that person, the engineer ends up deciding for you.

The owner is not the vendor's account lead, and not a steering committee that meets once a month. A steering committee can approve a budget. It cannot answer the small questions that come up every day once someone builds against real data.

Write the success measure down before any code is written, with the threshold the system must reach. Then meet the engineer at a fixed cadence so decisions do not queue.

The failure to watch for is quiet. When the owner is absent, the engineer fills the gap with their own idea of what matters, and that idea comes from their employer. For a chief operating officer (COO), the owner is also the person accountable for the service level once the engineer has gone.

What access does the engineer need, and who grants it?

The engineer needs the narrowest access that lets them build against real data: a non-production environment, read access to the source systems, a service account with named permissions, and logging. Your system owner and security team grant it, and the access plan is agreed before the engineer starts, not requested ticket by ticket.

Integration is where pilots stall, and access is where integration problems first appear. One FDE course posted on X in August 2026 opens with a model that could not reach the customer's old SQL (Structured Query Language) databases, failed its single sign-on and broke three data residency policies.

Two parts of the plan are easy to skip: no standing write access to production during build, and an expiry date on the service account. Access granted broadly to save a week tends never to be taken back.

Which review gates must exist before anything runs unattended?

Three gates at minimum: a test set built from your own past cases that the system must pass before it runs unattended, a human approval step on any action that changes customer data, money or external communication, and logs a reviewer can audit. Your team sets the pass threshold, not the engineer.

A test set, sometimes called evals, is a collection of past cases with answers your team agrees are correct. The system runs against it after every change, and a change that drops the score below the threshold does not ship.

The business owner sets the threshold, because only they know what "good enough" costs in their workflow. The engineering lead builds the gate into the deployment, and a named reviewer reads the logs, weekly at first. Gates loosen only by the owner's decision, with evidence from the logs, never because the engagement is nearly over.

What should your team have ready before the first week?

Have five things ready before the engineer arrives: a named owner and success measure, a written description of the current workflow, a sample of real cases to test against, an agreed access plan, and time booked with the people who do the work. These are the inputs an engineer would otherwise spend the first weeks chasing.

Two more belong in the contract or statement of work: the internal engineer who will take the handover, and the exit criterion.

What goes in a receiving-team charter?

A receiving-team charter puts the problem, the access, the gates and the handover on one page, with an owner for each line. Fill it in for the workflow the offer covers before you accept. A line you cannot fill is the conversation to have with your own team first.

The example column comes from the illustrative plan in the next section.

What the team receiving a forward deployed engineer owns, who owns it and when.
Item Owner on your side What they provide When Exit criterion
Problem and success measure Business owner of the workflow The measure, the threshold and fast decisions Before week one, then throughout The owner signs off that the threshold is met
Systems and environments System owner A non-production environment that matches production Before week one The system runs in your production environment under your controls
Access and credentials System owner, with security A scoped service account, logging and an expiry date Before week one Vendor access revoked or reduced as agreed
Data and test cases Business owner, with the people who do the work Past cases with agreed correct outcomes Weeks one and two The test set lives in your repository
Review gates Business owner sets thresholds; engineering lead implements Test-set pass threshold, human approval steps, log review Before anything runs unattended Gates documented and running without the engineer
Security and compliance sign-off Security reviewer Review of access, data handling and logs Before access, and before go-live Sign-off recorded
Handover and ongoing operation Named internal engineer Pairing on every change From week one to exit The internal engineer ships a change and the test set still passes
TL;DR: Embedded engineering becomes a capability only when the receiving team names an owner, grants scoped access, sets review gates and plans the handover before the engineer starts. Write those four into a charter before you accept.

What does a receiving-team plan look like in practice?

Illustrative example: a cloud security company of about 1,500 employees accepts a two-engineer pod from its model vendor for six weeks. The pod will build an agent that drafts first answers to customer security questionnaires. Every number here is illustrative and describes no client or result.

The work fits embedded build for three reasons. The answers depend on knowledge spread across a wiki, past questionnaires and product documents. The workflow belongs to sales engineering. The drafts go to customers, so controls matter.

The charter's example column shows each line filled in. Weeks one and two go to the solutions engineers' workflow and the test set, weeks three and four to improving the agent against it, and week five to live use behind the approval gate.

Week six is the handover. The internal engineer adds a new product's documentation to the answer library, and the test set still passes. That change, made by someone who is not the engineer, is the exit.

How do you know a forward deployed engagement worked?

A forward deployed engagement worked when someone on your team, not the engineer, can change the system and the test set still passes, and the code, tests and runbook live in your own repositories. Agree that test in the contract, and run it before the engineer leaves.

Falkster, which writes about running forward deployed teams, uses a similar test: a deployment has landed when someone who is not the FDE can change it. We add the test set, so the change is checked rather than assumed.

Cohere, which builds enterprise AI models and employs its own FDEs, separated two kinds of dependency in August 2026. The first comes from the technology you chose, and exists whoever deploys it. The second is operational: the knowledge stays with the vendor's engineers, so your team cannot diagnose, change or check the system without them.

Cohere's answer is to build knowledge transfer in from the start, including test suites the customer's team can run. Convective made the same point that month: self-sufficiency is the exit.

We recommend holding every system to three rules before anyone calls it handed over:

  • A system that needs its builder awake to run is not finished.
  • Everything built lives in your accounts, not the builder's.
  • Every module has a defined input and output, so a fault can be traced to one place.

A system that fails any one of them has a dependency built into it, however good the code. Agree a recall rule as well: what brings the engineer back, such as results falling below the threshold or a change in a source system.

What should the handover include?

Five things: the code, the test set, a runbook, an architecture note, and an internal owner who has already shipped one change. A document on its own is not a handover.

  • The code lives in your repository, under your access controls.
  • The test set lets your team change the system without guessing whether they broke it.
  • The runbook covers deploying, rolling back and fixing the failures most likely to wake someone up.
  • The architecture note records why each design choice was made, so the next change does not undo it by accident.
  • The internal owner has paired on the build from the start, so the knowledge moves with them.

The vendor keeps its model or platform. Everything built on top of it should be yours if the contract says so.

TL;DR: An engagement has landed when your own team can change and run the system without the engineer, with the code, tests and runbook in your repositories. Make that the exit test in the contract.

Frequently asked questions

What is a forward deployed engineer?

A software engineer who works inside a customer's own environment, on its data and systems, to build and ship a working production system for that customer, and who stays accountable until the system runs. Palantir created the role in the early 2010s.

How is a forward deployed engineer different from a software engineer on a product team?

A software engineer on a product team builds a feature for every customer at once. A forward deployed engineer builds for one customer at a time. Our forward deployed engineer vs software engineer comparison covers the difference in full, including pay.

What does a forward deployed engineer do in a working week?

The week is split between sitting with the people who do the work, writing and testing code in the customer's systems, and telling their own company what its product cannot yet do. The balance moves from listening towards building as the engagement goes from scoping to delivery.

Who owns the code a forward deployed engineer writes?

Whoever the contract says, so agree it before the engineer starts. Ask for the code, tests, runbook and configuration to live in your repositories and accounts, under terms you can work with. The vendor's model or platform stays the vendor's. This is not legal advice: have your counsel check the IP and handover clauses before you sign.

What is forward deployed engineering, as opposed to the forward deployed engineer?

Forward deployed engineering is the delivery model: embed with the customer, build in their environment, ship to production, and feed what was learnt back into the product. The forward deployed engineer is the person doing the building. A provider can run the model with a team that also includes a deployment strategist, who owns the business problem while the engineer owns the build.

Does a forward deployed engineer need to be on site?

Not for the whole engagement. Scoping needs time in the room with the people who do the work, and most building can happen remotely once access is in place. Write the on-site days into the charter, so they are planned rather than requested, and protect them when the schedule slips.

‍

Newsletter

Subscribe to UNKAPPED Weekly

Your weekly dose of AI and GTM sanity. Frameworks, playbooks and breakdowns that actually move revenue.

Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.