The forward-deployed engineering model: how it works when the system has to run

The forward-deployed engineering model: engineers work with your teams, decide what to build and own it until it runs. How it works, and when it fits.

By Published 6 min read

The forward-deployed engineering model: a production definition signed with the process owners, then diagnosis, integration, security review, measurement, approvals and handover, with one team answerable for the system until it runs.

The forward-deployed engineering model puts engineers to work directly with the client’s business and technical teams, to determine what has to be built and take ownership until it runs, instead of building from a specification handed over in advance. It trades a fixed upfront specification for a production definition agreed with the people who own the process.

The forward-deployed engineering model is a way of delivering software in which engineers work directly with the client’s business and technical teams, determine what has to be built, and take ownership until it runs.

This article explains the model itself: where it comes from, how an engagement runs end to end, how it differs from a license or a services contract, and when it fits. For the full guide to the practice, read forward-deployed engineering: what it is, how it works and when you need it.

Key takeaways

  • The model starts from a production definition, not from a requirements document.
  • The same team decides what to build, builds it and answers for it running.
  • Model and cloud providers now run forward-deployed teams of their own. A model-neutral team chooses the model per use case.
  • It fits a system that has to run in a real operation. A one-off deliverable with a closed specification is better served another way.

What is the forward-deployed engineering model?

Three things set the forward-deployed engineering model apart from other delivery models:

  • The starting point is a production definition. Before any build, the engineers and the process owners write down what “running in production” means for this system: who uses it, what it connects to, what it must never do, and how it is measured.
  • The engineers are close to the work. They learn how the operation really runs, including the systems, the exceptions and the people, rather than working from a document written elsewhere.
  • Ownership does not stop at delivery. The engagement ends when the client’s team runs the system and holds the runbook.

Two roles carry the model. The forward-deployed engineer is the technical role: builds, integrates and runs the system in the client’s repository. The forward-deployed lead is the senior lead accountable for the business outcome, working with the forward-deployed engineers from problem to production. The forward-deployed team is what the client gets: the lead alone, or the lead together with forward-deployed engineers. The engineer’s role is described in detail in what is a forward-deployed engineer.

Where did the forward-deployed model come from?

The model started in the 2010s at a data-software company that sent engineers to work at its customers’ sites, because its software only created value once it was fitted to the customer’s real data and processes.

It reached the wider market when AI moved from pilots to operations. Model providers and cloud providers now describe forward-deployed teams that work with customers on production use cases. The signal for a buyer is simple: the people who build the models and the platforms have concluded that the work of fitting AI to a real operation is where production value is created. We cover why in why forward-deployed engineering is rising.

Research on production machine learning pointed the same way years earlier. A NeurIPS paper by Google researchers found it “common to incur massive ongoing maintenance costs in real-world ML systems” (Hidden Technical Debt in Machine Learning Systems). The cost sits in the system around the model, which is the part a forward-deployed team owns.

How does the forward-deployed engineering model work end to end?

An engagement follows the same sequence, whatever the system:

  1. Diagnosis. The engineers study the process, the data and the systems, and write the production definition with the process owner.
  2. Integration. They build against the real systems, with the client’s access rules and data conditions, not a sandbox.
  3. Security review. Access, data handling and the failure cases are reviewed before anything is released.
  4. Measurement. The agreed measures are tracked from the first release, so the client sees whether the system does its job.
  5. Approvals. Approval gates for sensitive automated actions, so a person decides where a mistake would be costly.
  6. Handover. The client’s team receives the system, the runbook and the training to run it.

Each step closes with a written gate that the client signs, so progress is visible and nobody discovers a gap at the end. The same sequence, week by week, is in how a forward-deployed engineering engagement works.

The forward-deployed engineering model end to end, each step closed by a signed gate: 1 diagnosis, production definition written with the process owner. 2 integration, built against your real systems and access rules. 3 security review, access, data handling and failure cases reviewed. 4 measurement, agreed measures tracked from the first release. 5 approvals, approval gates for sensitive automated actions. 6 handover, system, runbook and training for your team.

Measurement is the step most often left vague. Engineering teams that run services in production agree on a target before they argue about results: the Google SRE book defines a service level objective as a target value or range of values for a service level measured by an indicator. The production definition plays that role for an AI system.

How is it different from a product license or a services contract?

A product license gives you software and leaves the fitting to you. A conventional services contract gives you a report, a plan or a build against a specification. The forward-deployed model gives you a system running in your operation, with one team answerable for that result.

Product license Specification-based contract Forward-deployed engineering model
Starts from The vendor’s product A specification written in advance A production definition written with the process owner
Engineers work At the vendor Away from the operation Directly with your business and technical teams
Changes Wait for the roadmap Handled as change requests Handled inside the gates
Ends when The license is active The build is delivered Your team runs the system
Who carries the pilot-to-production gap The client Shared between the parties The forward-deployed team

Product license, specification-based contract and forward-deployed engineering model compared, the forward-deployed column highlighted in blue. Starts from: the vendor’s product; a specification written in advance; a production definition written with the process owner. Engineers work: at the vendor; away from the operation; directly with your business and technical teams. Changes: wait for the roadmap; handled as change requests; handled inside the gates. Ends when: the license is active; the build is delivered; your team runs the system. Who carries the pilot-to-production gap: the client; shared between the parties; the forward-deployed team.

When does the model fit, and when not?

It fits when:

  • a pilot works but has not reached production, and nobody owns the path to production;
  • an AI company has sold an enterprise customer and needs to get them live;
  • the system touches several of your systems and rules, so a specification cannot capture it up front.

It is the wrong tool when:

  • the deliverable is closed and fully specified, such as a defined report or a fixed integration with documented interfaces;
  • there is no process owner on the client side who can agree a production definition;
  • the aim is only to explore, with no intention to run the result.

Why does model neutrality matter in the forward-deployed model?

When a technology provider runs a forward-deployed team, its engineers start from that provider’s own models and platform. A model-neutral team starts from the problem.

A model-neutral team works the other way round. It chooses per use case among the models you approve, and can change them, because the right model depends on the task, the data conditions and the cost of an error. Neutrality does not mean avoiding the large providers. It means the choice follows the problem.

What should a buyer ask a forward-deployed engineering company?

Five questions show whether an engagement follows the model:

  1. Who writes the production definition, and when? It should exist before the build, signed by a process owner.
  2. Who is answerable when it runs? One named team, with a senior lead accountable for the business outcome.
  3. What are the gates, and what does each one produce? Each should end in a written deliverable you can inspect.
  4. Where are sensitive actions approved? Automated actions that are costly to get wrong should pass through approval gates.
  5. What do you own at the end? The system, the runbook and the knowledge to operate it.

Public frameworks ask for the same accountability. The NIST AI Risk Management Framework puts it under its Govern function, and the OECD AI Principles list accountability among their values-based principles.

What should you do next?

To see how the model applies to your own system, read about forward-deployed engineering at OrNsoft, or book a call. One call is enough to know whether we can help.

Questions

What is the forward-deployed engineering model?
A delivery model in which engineers work directly with the client's business and technical teams, decide what has to be built with the people who own the process, and stay responsible until the system runs in production.
Is forward-deployed engineering a services business?
Engineers do the work, so it involves services, but the deliverable differs from a conventional services contract: a system running in production with a handover, not a document or a build against a fixed specification.
Why are AI companies building forward-deployed teams?
Because a model or a platform creates value only once it is fitted to a real operation: its data, its systems, its rules and its people. That fitting work is where most of the difficulty sits.
Does the forward-deployed model work for one-off projects?
When the project is a system that has to run, such as an agent that handles a live process, yes. A one-off deliverable with a closed specification, such as a defined report, is better served by a conventional contract.
What is the difference between a forward-deployed engineer and a forward-deployed lead?
The engineer is the technical role that builds, integrates and runs the system. The lead is the senior lead accountable for the business outcome, working with the forward-deployed engineers from problem to production.

Bring us the problem.

Book a call