Delivering AI Solutions: working with the customer's internal team
Designing for handoff means shaping the project from its earliest days so the customer's team can run the system after the builders leave.
Why the Builders Cannot Stay
Picture a team that spends months building an AI system for a customer. The system is finally running, and the builders leave. The people who built it are no longer around, but the system still has to keep working. Someone on the customer's side has to notice when something goes wrong, check whether the system is still producing good results, and respond when it is not.
This is the situation that designing for handoff is meant to prepare for. Designing for handoff means shaping the project from its earliest days so that the customer's own team can run the system after the builders step away. The source is clear that this is not a final chore done at the end. It is a set of decisions that shape the project from its very first days.
Who Runs the System Before and After Handoff
Before handoff, the people who built the system are the ones operating it. They are close to its behavior and can respond directly when something changes. The customer's internal team is not yet the party responsible for keeping the system running. After handoff, that responsibility moves. The customer's team must be able to operate the system without the builders in the room.
The diagram below shows the shift in ownership. Notice that the roles do not simply swap. The change is in who holds the responsibility, and that is why the work done during the build has to prepare the customer's team in advance.
Starting Instrumentation at the First Commit
Instrumentation is the set of signals a system emits about its own behavior. The source states that instrumentation begins at the first commit, because telemetry is what makes a launch possible. It is not something added after the system is already live.
What do you think happens?
Put these three project checkpoints in the order they occur: the customer dashboard goes live, design for handoff begins, instrumentation begins.
Reveal answer
Instrumentation begins at the first commit, design for handoff begins in the first week, and the customer's dashboard goes live the day the system enters production. The correct order is instrumentation, handoff, dashboard.
The source gives these three checkpoints as a sequence along the life of a project. Handoff preparation is spread across the whole project rather than concentrated at the end.
Laid out in order, these checkpoints show that handoff preparation runs through the whole project. The signals gathered from the first commit are the ones that let the team evaluate the system and adjust it later. The source also points forward to a loop that runs from telemetry back into evaluations and prompt changes, which Chapter 12 covers in depth. For this article, the key link is the direction of that dependence: early signals make later evaluation possible.
The Dashboard as a Confidence Tool
A customer dashboard is usually imagined as a place to read numbers. The source asks us to think of it differently. Its main job is to build confidence. When the customer can watch what the system is doing in real time, their worry about the unknown decreases.
That confidence matters for the engineer as well. The source notes that a live, visible dashboard supports the engineer's ability to make scope decisions while the work is underway, because the customer is more willing to let the engineer make those decisions when they can see what is happening.
A dashboard is useful during the build for trust and scope decisions, and after the build for the customer's team to see the system at work. It is part of the delivery from the start, not a view added once the system is finished.
The Four Handoff Artifacts
Designing for handoff produces four specific artifacts for the customer's internal team: a runbook, a set of alerts, an eval set, and a playbook. The source describes them as part of the delivery. They are not extra documents written in a rush at the end. Each one serves a different purpose, and together they let the customer's team notice problems, check quality, and respond.
The diagram places all four artifacts under the delivered system, because each one exists to support the running system and is handed over with it. The sublabels summarize each role as the source describes it: alerts help notice problems, the eval set helps check quality, and the runbook and playbook help the team act. The source does not give step-by-step contents for each artifact, so the sections below describe their purpose rather than a fixed template.
Tracing an Alert Through to Resolution
An alert fires after handoff
Some time after handoff, an alert fires. The customer's team must move from noticing the problem to resolving it, using the artifacts that were delivered with the system. Which artifact guides each step?
- 1The alert fires
The alert is the artifact that helps the customer's team notice a problem. Its existence depends on telemetry gathered from the project's early days, which is why it was possible at all.
- 2Check the system's behavior
The team uses the eval set to check quality, comparing how the system is behaving against the standard the eval set defines.
- 3Follow the run guidance
The runbook describes how the system is meant to be operated, so the team can work through the system's normal procedures while investigating.
- 4Respond
The playbook tells the team how to respond once the problem is understood, so the response does not depend on the builders being available.
The alert starts the sequence, the eval set and runbook inform the investigation, and the playbook guides the response. Each artifact has a role, and all four were delivered as part of the system rather than added afterward.
Notice that every step in this trace depends on something built earlier. The alert needs early telemetry, the eval set needs quality checks defined during the build, and the runbook and playbook need to exist before the builders leave. This is the practical meaning of treating the artifacts as part of the delivery.
Mistakes Teams Make With Handoff
Common mistake Waiting until launch to add instrumentation
What it looks likeThe team plans telemetry for the production release and leaves it out of the early commits.
Why it failsThe source states that instrumentation begins at the first commit because telemetry is what makes a launch possible. Adding it at launch leaves a gap in early data.
Do this insteadStart instrumentation at the first commit and treat it as part of the project from the beginning.
Common mistake Treating the dashboard as a reporting extra
What it looks likeThe dashboard is built only after the system is finished, as a summary view for managers.
Why it failsThe source describes the dashboard's main job as building confidence, both for the customer and for the engineer's ability to make scope decisions during the work.
Do this insteadMake the dashboard live and visible during the build so it can support trust and decisions as they happen.
Common mistake Writing the handoff documents in a rush at the end
Why it failsThe source says the four artifacts are part of the delivery and should be built alongside the system, not written at the end.
Do this insteadBuild the runbook, alerts, eval set, and playbook as the system takes shape.
Common mistake Assuming the builders will always be available to respond
Checking Your Handoff Readiness
A team is six weeks into a project and has not yet set up any telemetry. They plan to add instrumentation and the customer dashboard when the system goes to production. Using the three checkpoints, explain what the team is missing and what they should do now. Then name which of the four handoff artifacts depend on early signals, and why.
Hints
- Recall the three checkpoints: instrumentation at the first commit, design for handoff in the first week, and the dashboard at production day.
- Think about what an alert can watch, and what the eval set needs in order to check quality over time.
Key Takeaways
- Designing for handoff shapes the project from its first days so the customer's team can run the system after the builders leave.
- Instrumentation begins at the first commit because telemetry is what makes a launch possible, not something added later.
- A live customer dashboard builds confidence and supports the engineer's scope decisions during the work, not only afterward.
- The runbook, alerts, eval set, and playbook are part of the delivery and are built alongside the system, each serving a different purpose for the customer's team.