AI delivery · Customer deployment

Take a stalled customer deployment through to handover

If you have signed customers waiting on AI integrations your team cannot reach, you can commission a forward-deployed engagement: I work inside one customer deployment, connect your product to their systems, agree acceptance criteria with both sides, and hand over a running integration, an ownership map and a runbook. It starts with a scoping call on one named deployment.

This is a good fit if…

  • You sell an AI product and signed enterprise customers are waiting on integration work your solutions team cannot schedule.
  • A customer deployment has stalled on identity, data access or security review, and needs someone who can work through it with the customer's engineers.
  • You are an enterprise that bought an AI platform and need it connected to your own systems, with someone accountable for it working.
  • You want the first deployment of a new product line done carefully enough to become the template for the next ones.

Look elsewhere if…

  • You want an engineer to join your team under your manager and work your backlog. Hire a forward-deployed AI engineer on contract instead.
  • Your internal team already built the system and now needs to take it over. Use AI system handover and internal ownership.
  • You need advice on whether to build, buy or integrate before any work starts. Read the build, buy or integrate guide first.

What you get

Customer-embedded implementation with agreed acceptance criteria

  • One named customer deployment live against acceptance criteria that your team and the customer agreed in writing.
  • An ownership map showing which party owns each integration point, credential, data flow and support route.
  • A runbook for the deployment: how it is monitored, what to do when it fails, and who to call.
  • A record of the decisions and workarounds that the next deployment should reuse or avoid.
  • Your solutions or support team able to operate the deployment without me.

How it runs

  1. 01

    Scope one deployment

    We pick one customer deployment, list the integration points and blockers, and write acceptance criteria that the customer can sign. If the work is not bounded enough to scope, I say so.

  2. 02

    Embed and map

    In the first week I meet the customer's engineers, get access through their normal process, and draw the ownership map: systems, credentials, data flows and approvals.

  3. 03

    Build and integrate

    I implement the integration in your codebase and the customer's environment, with tests, evaluation where model output matters, and observable failure paths.

  4. 04

    Accept and hand over

    We run the acceptance checks with both sides, then hand over the runbook, the ownership map and the decision log to the people who will support it.

What needs to be in place

  • A signed customer and a named contact on their side with authority to grant access and accept the work.
  • A named owner in your organisation who will support the deployment afterwards.
  • Access to your product's codebase, deployment tooling and any integration SDKs.
  • Agreement between you and the customer on where code runs and what data may be processed.

Not included

  • Running your customer relationship or commercial negotiation. I work under your account lead.
  • Ongoing support after acceptance unless agreed separately, for example through a maintenance retainer.
  • Rewriting your core product. Changes are limited to what the deployment needs, and product changes go through your review.
  • Fixed delivery dates promised before access and blockers are understood.

Four ways to get an AI deployment done

AdviceStaff augmentationEmbedded implementationManaged outcome
What you buy Expert judgement on architecture, risk and sequencingEngineering hours under your directionA scoped deployment delivered inside the customer's environmentAn operated service with service levels
Who directs the work You, informed by the adviserYour managerShared: acceptance criteria agreed up front, delivery led by meThe provider
Who writes production code Your teamThe contractor, in your processMe, in your codebase and the customer's environmentThe provider's team
How acceptance is judged Usefulness of the recommendationYour normal review of each changeWritten acceptance criteria signed by you and the customerService-level reporting
Who owns it afterwards YouYouYou, with a runbook and ownership mapOften the provider, which can create dependency
Good fit when Your team can deliver but needs a second opinionYou have a manager and backlog, but not enough handsA specific deployment is stuck and needs one accountable leadYou want to buy an operated capability rather than own one

When integrations fall behind sales

The pattern is familiar to anyone who sells AI software to enterprises. The product demos well, contracts get signed, and then each customer turns out to need something specific: single sign-on through their identity provider, documents pulled from a records system nobody has an API for, model calls routed through their approved region, outputs written back into a ticketing or case-management tool. The solutions team is spread across too many accounts, the product team is building the roadmap, and the customer’s renewal clock is running.

Forward deployment is the response to that gap. An engineer works inside one customer deployment, alongside the customer’s own engineers, until the integration is running and someone on your side can support it. The discipline is less about writing clever code and more about closing the distance between a product that works in your environment and one that works in theirs.

What the work involves

Every deployment is different, but the work runs through the same four areas:

  • Access and identity. Getting credentials through the customer’s process, mapping their roles onto your product’s permissions, and making sure the AI component cannot see data the user cannot.
  • Data paths. Connecting the customer’s sources, deciding what is copied versus queried in place, and documenting what personal or confidential data crosses which boundary.
  • Model behaviour in their context. Checking that outputs hold up on the customer’s own documents and vocabulary, with a small evaluation set agreed with their subject experts, not just your demo data.
  • Failure paths. Deciding what happens when a source is down, a model call times out or an output fails validation, and making those failures visible to the people who will support it.

I work in your codebase through your review process, and in the customer’s environment through theirs. Product changes that the deployment needs are raised with your product owner, not merged quietly into a customer branch.

The signature deliverable

You receive a customer-embedded implementation with agreed acceptance criteria: the running integration, the acceptance record, an ownership map and a runbook. Illustrative example of an ownership map extract:

Integration pointOwnerCredential held byFailure signalFirst responder
SSO and role mappingCustomer ITCustomerLogin errors in product audit logCustomer IT, then your support
Document sync from records systemYour productService account in customer tenantSync lag alert above agreed thresholdYour support team
Model calls via customer’s approved regionYour productYour platformError rate and latency dashboardYour platform on-call
Write-back to case toolSharedCustomer-issued API keyFailed write queueYour support, escalating to customer

Illustrative example. Not taken from a client engagement.

How acceptance is judged

Acceptance criteria are written before the build starts and signed by you and the customer’s named contact. They usually combine functional checks (the integration completes the agreed workflows end to end), quality checks (outputs meet an agreed standard on the customer’s evaluation set), and operational checks (alerts fire, the runbook procedures work when rehearsed). If a criterion cannot be met for reasons outside the scope, that is recorded with the evidence rather than quietly dropped.

Ownership and handover

Your organisation owns the code, the configuration and the customer relationship throughout. The handover goes to a named person on your side, usually in solutions or support, and includes a walk-through of the runbook and the ownership map. The decision log records what was customised for this customer, so the next deployment can reuse what worked. If the internal team needs a more structured transfer, AI system handover and internal ownership covers that as its own engagement.

When to choose something else

If you want an engineer inside your team under your manager, see hire a forward-deployed AI engineer. If you are a software vendor looking for a longer-term delivery partner across many customer deployments, see AI deployment partner for software vendors. If the question is whether to integrate a product at all, start with build, buy or integrate.

Questions buyers ask

How is this different from hiring a forward-deployed engineer on contract?

A contract buys my time under your manager and priorities, and you carry the delivery risk. This engagement is a commissioned outcome: one deployment, written acceptance criteria, and me accountable for reaching them. If you already have a solutions lead who can direct the work day to day, the contract is usually the better fit.

Do you work directly with our customer?

Yes, with your agreement and under your account lead. I attend the customer's technical meetings, work through their access and security review, and raise commercial or scope questions back to you rather than settling them with the customer myself. Your account lead sees every scope change before the customer does.

What happens if the customer's environment blocks the deployment?

Blockers such as missing data access, an unresolved security review or an unavailable system are written into the scope as dependencies. If one stops the work, I report it with the evidence and options, and we agree whether to pause, rescope or stop. You are not billed for waiting on undefined work.

How is the engagement priced?

As scoped delivery with acceptance criteria, shown in the engagement model on this page. The price depends on the number of integration points and the customer's environment, which is why the first step is scoping one named deployment rather than quoting a range.

Is this you personally or a team?

Me personally. If a deployment needs a specialist, for example in a customer's identity platform, I name them and you approve them before they start. There is no hidden team behind the engagement, and the person who scoped the deployment is the person who builds it, sits in the customer's meetings and hands it over.

Scope an embedded delivery engagement

A short, non-confidential description is enough to start. I read every brief personally and reply within two business days, including when the answer is that I am not the right fit.

Step 1 of 2 · The basics