Forward-deployed engineering has become one of the most repeated phrases in enterprise AI. Model companies hire for it, investors write essays about it, and firms that used to call the same work implementation or professional services have adopted the name. The term is only useful if it says where the work starts and where it ends.
Our answer: it starts inside an operation, with the people responsible for it, and ends when another team can run what was built.
Start with the operation
A procurement team does not experience its work as a list of software requirements. It experiences an invoice with a missing purchase order, a supplier who appears under three names, an approver on leave, and a month-end deadline. A system can implement every requested screen and leave all of those exceptions untouched. The team then builds another spreadsheet around the new system, and the modernization has added a dependency without removing any work.
Forward-deployed engineering starts at that boundary. An engineer works with the people responsible for the operation, learns the systems they actually use, and carries that understanding into the implementation. The engineer stays close enough to see when the software makes the work harder, and delivery includes changing the design in response. A discovery made in week six is information, not a failure to specify the project correctly.
The useful distinction is accountability. Where does the engineering team’s responsibility stop: at a recommendation, at a release, or at a working operating loop that another team can maintain? At Verne, the intended endpoint is the third. A release is a milestone inside that obligation. Ownership is the test of whether it has been met.
Where the role came from
The job title comes from Palantir. In a 2019 post explaining its engineering roles, the company described software engineers (“Devs”) who build its platforms and forward-deployed software engineers (“Deltas”) who deploy them for customers, a name left over from early business development teams named after letters of the NATO alphabet. Palantir summarized the difference as “one capability, many customers” against “one customer, many capabilities,” and drew a line against consulting: in its account, consultants tend to leave a one-time analysis or recommendation, while Deltas build a long-term solution with the customer.[1]
In 2025 the model spread across AI companies. An Andreessen Horowitz essay argued that AI applications need people with context and access to internal systems to make them work, and counted 22 of 311 open roles at OpenAI in forward-deployed and solutions engineering.[2] The Financial Times reported that monthly job listings for the role grew by more than 800 percent between January and September 2025.[3] OpenAI’s current posting asks its FDEs to “own discovery, technical scoping, system design, build, and production rollout”;[4] Anthropic’s asks them to embed with strategic customers and codify repeatable deployment patterns.[5] In May 2026, OpenAI launched a separate deployment company and agreed to acquire a consultancy bringing about 150 forward-deployed engineers and deployment specialists.[6]
Two cautions belong next to that list. Job posts and announcements describe intentions; they are not evidence that the model works. And the model has a known way of failing. An essay from the same investment firm put it plainly in January 2026: “if you only copy the embedded-engineer part, you end up with thousands of bespoke deployments that are impossible to maintain or upgrade.”[7] The same essay notes that Palantir’s embedded engineers build and maintain those capabilities on the company’s own platform. That is coherent when the customer is buying a platform. It is a different agreement when the customer is paying for a system it intends to own.
The public descriptions are detailed about discovery and rollout. They say much less about the moment the customer’s own team takes over, which is where this guide spends most of its time.
Why AI deployments stall
The hiring surge follows a plain problem: organizations adopt AI tools faster than they turn them into operational results. MIT NANDA’s 2025 report, built from interviews with representatives of 52 organizations, a survey of 153 senior leaders, and a review of more than 300 public initiatives, found that 95 percent of organizations were getting zero return from generative AI, and that only 5 percent of custom enterprise AI tools reached production. The authors attribute most failures to “brittle workflows, lack of contextual learning, and misalignment with day-to-day operations.” One interviewee was more direct: “Most vendors don’t get how our approvals or data flows work.”[8]
Read the headline number with care. The report calls itself preliminary; its success figures come from interviews rather than company reporting, and “success definitions may differ across organizations.” It found that external partnerships reached deployment about twice as often as internal builds, then warned that the difference may reflect the organizations rather than the approach. It had too little data on hybrid teams, where an internal team co-develops with an outside one, to measure them at all.
Larger surveys point the same way with less drama. McKinsey’s 2026 State of AI survey of 1,719 participants found that 37 percent attribute at least some EBIT impact to AI, about the same share as in 2025, and that roughly 6 percent qualify as high performers. Nearly three-quarters of those high performers report fundamentally redesigning workflows because of their AI use, compared with one-quarter of other respondents. The authors conclude that “the limiting factor is increasingly the organization’s ability to absorb change.”[9]
RAND interviewed 65 experienced data scientists and engineers about why AI projects fail. The most common root cause they described was that stakeholders misunderstand or miscommunicate what problem the AI is supposed to solve, which produces models optimized for the wrong metrics or models that do not fit the workflow.[10]
None of these studies tests forward-deployed engineering, and we will not pretend otherwise. What they show is where deployments break: in the workflow, in the understanding of the problem, and in the organization’s ability to change. Those are the things an engineer can only learn by being close to the operation, and the things that remain after the engineer leaves.
When embedding earns its cost
Embedding is expensive attention. It earns that attention when the important requirements cannot be learned reliably from a short brief: work spread across several systems, exceptions held in people’s memory, actions that carry real authority, poorly documented integration boundaries, or disagreement about what a good outcome looks like. Those conditions make learning part of the implementation.
The procurement example shows the point. The initial request might be to extract invoice fields with AI. Observation may reveal that extraction is already fast, while most of the delay comes from finding the right approver and proving that goods were received. An embedded team can change the first release from a document model to a receipt reconciliation and routing workflow. That change follows the bottleneck, even though it makes a less fashionable demonstration.
A clear, standardized requirement may not need any of this. Buying a maintained product, configuring an existing platform, or commissioning a small integration can be the better choice, and discovery should be able to reach that conclusion. If every discovery ends in a large bespoke build, it is a sales ritual, not an engineering decision.
0 of 5 embedding conditions
Delivery model
A model in the first release?
0 of 5 conditions. Delivery model: Commission a small integration. The requirement can be written down and tested. Embedding engineers would be expensive attention. Model: Leave the model out of the first slice.
Four phases, one test
Verne’s engagements run in four phases: Discover, Deploy, Build, and Transfer. Each should leave evidence a buyer can inspect without reading the code: a baseline, a decision record, a working loop, a passed drill. The phases overlap in practice, but each answers a question the next depends on.
Ownership moves with them, but not on a calendar. Some responsibilities belong to the client from the first day: deciding which exceptions matter, and holding the environments, credentials, and data. The rest move only when the receiving team shows it can carry them.
8% of day-to-day operation carried by your team
What is actually slow, and why?
Nothing to hand over yet. The output is evidence and options.
Evidence this phase leaves behind
- A baseline for each queue interval
- An exception register and workflow map
- A system inventory and access boundaries
- Options with costs, including not building
- Decides which exceptions matterYour team
- Holds environments, credentials, and dataYour team
- Knows why the system behaves as it doesMostly Verne
- Changes and deploys the softwareNothing to run yet
- Responds to alerts and failed jobsNothing to run yet
Discover. Nothing to hand over yet. The output is evidence and options. 8 percent of day-to-day operation carried by your team.
Discover: learn the exceptions first
Discovery produces a map of decisions and dependencies. Who starts the work? Which system holds the authoritative record? What evidence changes a decision? Who can override it, and what happens when that person is away? A workflow diagram that omits those questions usually describes the policy, not the operation. Both matter, and every difference between them needs an owner.
Ask operators to walk through recent difficult cases, with scoped and redacted records. Follow an item from arrival to completion and record the waits as well as the actions. A ten-minute task inside a five-day queue calls for a different intervention from a five-hour analysis task. This is also where the team finds data that cannot leave an environment, credentials that need brokering, and actions that require explicit authority.
Invoice arrives
Suppliers send invoices to the accounts-payable inbox.
Fields extracted
The brief: speed this step up with AI.
Matched to purchase order
Match each invoice to its purchase order.
Goods receipt confirmed
Confirm the goods were received.
Approver assigned
Route to the budget holder.
Approved and paid
Approved invoices go into the weekly payment run.
Six clean steps, and the brief points at step two. Nothing here says where invoices get stuck.
The deliverables are concrete: a system inventory, a workflow map, an exception register, access boundaries, and a baseline. For the procurement example, the baseline might separate arrival, validation, reviewer assignment, decision, and payment release, each measured from an agreed source. A promise to make procurement faster cannot be tested. A defined reduction in time waiting for reviewer assignment can.
End discovery with alternatives: perhaps a configuration change, a typed integration over the current ERP, or a new operational interface. Each needs its assumptions, costs, failure conditions, and the maintenance obligation it creates. That is RAND’s first recommendation in practical form: make sure the technical team understands the purpose and domain context before it builds.[10]
Deploy: a working relationship with boundaries
Embedding does not mean unrestricted production access. It means a reliable route between operational evidence and engineering decisions: a named operational owner, a technical counterpart, scoped access, and a place where decisions are recorded.
An operational owner decides which exceptions matter and whether the new workflow is usable. A technical owner agrees integration boundaries, deployment controls, and support expectations. A risk owner may be needed when the workflow changes who can approve or release something. An engineer cannot quietly absorb all three roles; doing so creates the very dependency the engagement is supposed to remove.
Team Topologies offers useful language here. It separates collaboration, “working together for a defined period of time to discover new things,” from facilitation, in which one team helps and mentors another.[11] An embedded engagement starts in collaboration and should plan its move to facilitation from the first week. A collaboration with no end date is a dependency with a friendlier name.
Keep a short decision cadence: pick one uncertainty at the start of the week, produce a small result by midweek (a trace of matched receipts and the ones that did not match), and record a decision at the review. Distinguish a new fact from a new preference. An undocumented approval rule may change the architecture; a preferred table layout usually should not.
Build: finish one operating loop
The first slice should cross the important boundaries. In the procurement example, that means taking an invoice from a controlled inbox, matching it to a purchase order and receipt, presenting the evidence to a reviewer, recording the decision, and updating the existing system through an approved interface. An extraction screen without the review and update steps demonstrates a component, not an operating loop.
Start with a narrow population (one business unit, one document class, or one low-risk action) so failures stay observable, and define how an operator returns to the previous process. A launch plan needs rollback and reconciliation, particularly when two systems can each hold a version of the same fact.
AI adds one more boundary: a proposed answer and an authorized action are different objects. A model can draft a classification or explain a mismatch, while a deterministic service enforces permissions and a reviewer authorizes the consequential change. The adapter below keeps that separation in the types. It also makes retries safe, because a common way for an integration to damage a system of record is to do the right thing twice.
from dataclasses import dataclass
from datetime import datetime
from typing import Literal, Protocol
@dataclass(frozen=True)
class Proposal:
"""What a model may produce: a suggestion and the evidence behind it."""
invoice_id: str
action: Literal["approve", "hold"]
evidence: tuple[str, ...] # document ids a reviewer can open
@dataclass(frozen=True)
class Decision:
"""What a person decided. Only a Decision reaches the ERP."""
decision_id: str # created once, when the reviewer submits; retries reuse it
proposal: Proposal
reviewer_id: str
decided_at: datetime
class Erp(Protocol):
def may_decide(self, user_id: str, invoice_id: str, action: str) -> bool: ...
def find_by_reference(self, reference: str) -> str | None: ...
def post_decision(
self, invoice_id: str, action: str, user_id: str, reference: str
) -> str: ...
class MissingEvidence(Exception): ...
class NotAuthorized(Exception): ...
def apply(erp: Erp, decision: Decision) -> str:
"""Write one reviewed decision to the ERP. Safe to call again after a timeout."""
p = decision.proposal
if not p.evidence:
raise MissingEvidence(p.invoice_id)
# Authority comes from the system of record, never from the model's output.
if not erp.may_decide(decision.reviewer_id, p.invoice_id, p.action):
raise NotAuthorized(decision.reviewer_id)
reference = f"verne:{decision.decision_id}"
# A timeout can hide a write that succeeded. Look before writing again.
if (existing := erp.find_by_reference(reference)) is not None:
return existing
return erp.post_decision(p.invoice_id, p.action, decision.reviewer_id, reference)Two details carry the weight. The reviewer’s authority is checked by the system of record at the moment of writing, not inferred from anything the model said. And each decision carries a reference created once and stored with the posting, so a retry after a timeout finds the earlier write instead of paying twice. Looking before writing narrows the race between two workers; it does not close it. If two workers can pick up the same decision, the ERP needs a uniqueness constraint on that reference, or the adapter needs a lock.
Evaluation belongs in this slice. Collect representative cases, including missing evidence, conflicting evidence, duplicates, and requests outside the intended scope, and agree the acceptable failure behavior for each. A system that declines an unsupported request may be working correctly; one that always answers can look helpful while making the process less reliable. Then instrument the queue intervals, reviewer overrides, and recovery work, and keep model quality separate from integration reliability. If a reviewer is waiting on access provisioning, changing the prompt will not help.
Transfer: test ownership instead of promising it
Transfer begins with the first repository and deployment decision. The client needs an agreed path to source code, environments, data exports, build instructions, and operational knowledge. Documentation written only in the final week tends to describe the intended architecture and miss the exceptions operators now handle every day.
A practical handover is a set of exercises. The receiving team deploys a small change, investigates a failed job, rotates a non-production credential, restores a test backup, and processes a representative exception, while the original engineers watch and record every point where the runbook was not enough. Site reliability teams have trained people this way for years: Google’s SRE book recommends “creating contained but realistic breakages for students to fix using real monitoring and tooling,” and lists training “strictly through operator procedures, checklists, and playbooks” as an anti-pattern, next to creating experts whose knowledge is compartmentalized.[12]
The drills can be executable. The receiving team runs the file below against staging; the original engineers observe and log any help they give. A drill passes only if the end state is correct and nobody from the delivery team had to step in.
"""Ownership drills for the invoice workflow.
The receiving team runs these against staging, working from the runbook.
The original engineers observe and log any help they give with the
drill-assist command. A drill passes only if the end state is right and
the assist log for that drill is empty. Fixtures live in conftest.py.
"""
from datetime import timedelta
import pytest
pytestmark = pytest.mark.handover
def test_deploy_a_small_change(staging, drill):
before = staging.deployed_version()
drill.brief("Ship the change on branch drill/label-copy to staging.")
drill.wait_until(
lambda: staging.deployed_version() != before, timeout=timedelta(minutes=45)
)
assert staging.health() == "ok"
assert drill.assists == [], drill.assists
def test_investigate_a_failed_job(staging, drill):
job = staging.break_job("receipt-sync", cause="supplier id format changed")
drill.brief(f"Job {job.id} failed overnight. Find the cause, fix it, re-run it.")
drill.wait_until(
lambda: staging.job_status(job.id) == "succeeded", timeout=timedelta(hours=2)
)
assert "supplier id" in drill.answer("What caused the failure?").lower()
assert drill.assists == [], drill.assists
def test_restore_a_test_backup(staging, drill):
marker = staging.write_marker(db="restore-check")
staging.take_backup(db="restore-check") # the backup now holds the marker
staging.drop_database("restore-check")
drill.brief("restore-check is gone. Restore it from the latest backup.")
drill.wait_until(
lambda: staging.has_marker(db="restore-check", marker=marker),
timeout=timedelta(hours=2),
)
assert drill.assists == [], drill.assistsA failing drill is a useful result. It names the missing runbook page, access grant, or alert route while the people who can fix it are still in the room. DORA’s research comes at documentation from another direction: for every technical practice it studied in 2022, the benefit to organizational performance was much larger for teams with above-average documentation quality.[13] The drills show which side of that line you are on. DORA’s 2025 report on AI-assisted development names the broader risk: AI’s primary role is “as an amplifier, magnifying an organization’s existing strengths and weaknesses.”[14] A system handed to a team that cannot operate it amplifies the weakness.
The exercises must reach past the code. Who renews an upstream API entitlement? Who receives an alert at night? What happens when a supplier changes its identifier format? A working service can still become unmaintainable when those answers belong to someone who has left.
Handover does not require the client to take on every specialist responsibility; managed support may be the right endpoint, as long as the boundary is explicit: which incidents each side handles, the response expectation, and how the client could move to another operator. Support should be a service the client chooses, not the consequence of knowledge that was never transferred.
What to ask before you buy
The answers should describe work and decisions, not list frameworks and model providers.
- Name the first operating loop, and the people needed to complete it.
- Which assumptions could make this project unnecessary?
- How will you measure the current process before claiming an improvement?
- If an automated step is disputed, what evidence will exist?
- What access do you need, how will secrets be supplied, and how does your access end?
- What will our team demonstrate, unaided, before you leave?
More access is not more embedding; a team that understands the environment asks for the minimum the work needs. If the answer to the last question is training attendance or a folder of documents, the transfer test is incomplete. Agree the drills at the start. That aligns the vendor’s incentive with the client’s independence.
Honest limits
Forward-deployed engineering cannot manufacture an accountable sponsor, repair a missing commercial agreement, or remove a legal restriction on data access. It can find those constraints early and design within them. If ownership is unresolved, the first deliverable may be a decision the organization has to make before anything is built.
It also creates risks of its own. An embedded engineer can become the undocumented integration between departments, solving every exception personally. That feels productive until the engineer leaves. At the scale of a firm, the same pattern becomes the services trap the a16z essay describes: many bespoke deployments, none maintainable by anyone else.[7] Explicit boundaries, recorded decisions, and repeated drills exist because close collaboration can otherwise hide dependency.
The evidence has limits too. The studies cited here describe why deployments stall; none shows that embedding engineers fixes it. Judge the model by what the operation can do afterward. Can people complete the work with fewer unexplained waits? Can they inspect a disputed decision? Can their own team change the software and recover it?
A release is a milestone. Ownership is the test.
Sources
- Dev versus Delta: Demystifying engineering roles at Palantir (opens in a new tab) Company account of where the forward-deployed role and the name “Delta” came from.
- Trading Margin for Moat: Why the Forward Deployed Engineer Is the Hottest Job in Startups (opens in a new tab) Investor commentary; source of the count of 22 FDE and solutions roles among 311 openings at OpenAI.
- Forward-Deployed Engineers Emerge as One of AI’s Fastest-Growing Jobs (opens in a new tab) Secondary report of a Financial Times analysis (paywalled) of job listings in 2025.
- Forward Deployed Engineer (FDE), San Francisco (opens in a new tab) Job posting, accessed September 2026; describes intended scope, not outcomes.
- Forward Deployed Engineer, Applied AI (opens in a new tab) Job posting, accessed September 2026; describes intended scope, not outcomes.
- OpenAI launches the OpenAI Deployment Company to help businesses build around intelligence (opens in a new tab) Company announcement, including the agreement to acquire Tomoro (about 150 FDEs).
- The Palantirization of everything (opens in a new tab) Investor commentary on the limits of copying Palantir's embedded-engineer model.
- The GenAI Divide: State of AI in Business 2025 (opens in a new tab) Preliminary, interview-based report; the authors list its limitations. MIT's original link now redirects, so this is a mirror of the July 2025 PDF.
- The state of AI in 2026: On the road to ROI (opens in a new tab) Online survey of 1,719 participants, fielded May to June 2026.
- The Root Causes of Failure for Artificial Intelligence Projects and How They Can Succeed (opens in a new tab) Interviews with 65 experienced data scientists and engineers.
- Key concepts: team types and interaction modes (opens in a new tab)
- Accelerating SREs to On-Call and Beyond (Site Reliability Engineering, chapter 28) (opens in a new tab) Recommended patterns and anti-patterns for training people to operate a system.
- Capabilities: Documentation quality (opens in a new tab) Summarizes the 2021 and 2022 State of DevOps research on internal documentation.
- State of AI-assisted Software Development 2025 (opens in a new tab)