Chapter 11: Build, Buy, or Assemble¶
The Decision Record and Its Exit Plan¶
1. The Decision Made on an Invoice¶
A team adopts a new observability platform. The reason is honest and it is not architectural: an agent can write the integration adapter in an afternoon, and the free tier covers the first month. Six months later the adapter has grown four undocumented branches, the platform's query language has appeared in six services, and the data migration costs three engineer-months. Nothing failed. The decision was made on an invoice, not on an architecture.
That is the shift this chapter is about. Chapters 2 to 10 built the internal machinery of the self-improving repository — the command interface, the vocabulary, the routing, the continuity, the procedures, the escalation policy, the execution log. This chapter looks outward, at the repository's boundaries: the database, the platform, the product, the AI model. Each is a dependency someone chose, and AI has changed the economics of choosing. Writing the glue is cheap now, which makes assemble the default posture of the Software Orchestrator — compose the estate, enforce policy at the seams, and let providers carry the commodities. A seam is the integration point where two systems meet, and — more usefully — the place you design so it can be cut. Policy is enforced at seams because that is where your behaviour meets someone else's.
The decision lives in the repository. The dependency is outside; the record of choosing it is not. Every artefact in this part is a file you commit — the decision record with its matrix and exit plan, the integration charter, the contracts, the drill results — so the boundary is not a place the repository stops. It is the edge the repository governs, from the inside, like every other control in this book.
This is where the workbench turns outward. Every chapter so far in this part was an instrument you build and hold: the command interface, the vocabulary, the routing, the handoff, the procedure, the boundary, the budget, the log. This chapter and the ones that follow are about what those instruments stand on — an upstream product, a provider's commodity, a contract with a service you do not own. The workbench is what you build; the estate is what you connect to, and the Orchestrator is accountable for both.
Cheap glue has a price of its own. It is now easy to add a dependency, write the adapter, and never record why — so an AI-accelerated team can accumulate architectural sprawl faster than it can review it. The controls are the ones this book has already built, applied at a different boundary: the command surface, the view it renders and the procedures live in the glue; the capacity that constrains it is the human authority the escalation policy protects; and the record of the choice belongs beside the execution log.
The rule this chapter defends: a build-or-buy choice without an exit plan is not a decision; it is a commitment with an unknown price. The decision record is the workflow structure applied to an architectural choice.
💰 Cost Check: the invoice is the smallest line. A provider that costs £200 a month and takes a week to exit costs less than one that costs £50 and cannot be left. Write the total — integration, on-call, upgrade, exit — or the comparison is between two numbers that do not mean the same thing.
🎯 What You'll Learn¶
- The five axes — control, cost, time, sovereignty, reversibility — and why the decision is which conflict you can live with
- Why assemble is the default — providers for commodity, agents for the glue, a person for the differentiator
- The total cost of a dependency — integration, on-call, upgrade and exit, not the invoice
- The exit plan as a deliverable — the seam, the data, the drills and a trigger, written with the decision
The Five Axes¶
| Axis | The question | What a bad answer costs |
|---|---|---|
| control | can you change the behaviour when it matters? | a workaround culture |
| cost | total, beyond the invoice | integration and on-call, unbudgeted |
| time | what does it cost to reach the first working version? | a quarter spent rebuilding a commodity |
| sovereignty | where does the data live, and who can read it? | a compliance answer you cannot give |
| reversibility | what does leaving cost? | a price the vendor now sets |
The axes conflict, and the decision is which conflict you can live with. Writing the answer down is what makes it reviewable; a decision that lives in memory is re-made, differently, by the next person.
flowchart LR
N["need"] --> Q{"commodity,<br/>or differentiator?"}
Q -->|"commodity"| B["buy — a provider"]
Q -->|"differentiator"| A["assemble — own the glue"]
A --> D["agents for the glue<br/>the human for the judgement"]
B --> X["exit plan required"]
A --> X
What this shows: the first question is not build or buy — it is whether this capability is the thing you compete on.
✅ What to Check¶
- Take your five biggest dependencies. For each, can you name the axis that decided it?
- Which of them has no exit plan? That is the one whose price you do not know.
2. Assemble as the Default¶
The old choice was binary: build or buy. The orchestrated choice has a middle: assemble.
| Layer | Who builds it | Why |
|---|---|---|
| commodity — transport, storage, mail delivery | a provider | nobody differentiates on it |
| the glue — integration, policy, approval, the seam | you, with agents | it is where your behaviour lives |
| the differentiator — the judgement, the method | you, by hand | it is the thing you sell |
Agents change the calculus at the middle layer. Glue that used to take a week now takes an afternoon, so the constraint moves: it is no longer typing, it is review capacity. That single shift is why "assemble" became the default — the part that used to be expensive to hand-write is now cheap, and the part that was always scarce (attention) has not moved.
This posture is the Orchestrator's job. The provider is accountable for the commodity; the Orchestrator is accountable for the estate's composition — which pieces touch, what is allowed across each seam, and what happens when one of them is replaced. That work lives in the glue, and the glue is built from the instruments the book has already given you: the command surface is how the seam is operated, and the procedures are how it is changed safely.
Total Cost, Beyond the Invoice¶
A dependency's cost is not the subscription. It is:
- integration — the seam, its tests, its drift;
- on-call — what breaks at 2am, and who knows it;
- upgrade burden — the rehearsals and the patch drift;
- exit cost — the migration you would face, and how long it would take.
An invoice comparison that ignores the last four is not a comparison.
✅ What to Check¶
- For each dependency, name the layer it occupies: commodity, glue, or differentiator.
- Has anything at the differentiator layer been bought? That is a strategy problem, not a budget one.
3. The Exit Plan¶
An exit plan is a deliverable, written when the decision is made, and it has four parts:
- the seam — the interface that would survive the change;
- the data — where the data lives, and how it moves;
- the drills — what a vendor change would break, and who would notice;
- the trigger — the condition under which you would actually leave (price, terms, API change).
The drill makes it real. Pick one dependency and ask the vendor-change question: if the price doubled tomorrow, what would we do? If the answer is "we would have to do something", the exit plan is a wish. If it is a named path with a cost and a duration, it is a plan.
Vendor-change drills are cheap and rare. One per dependency per year is enough to keep the plan honest, and cheap enough that skipping it is a choice, not an accident.
✅ What to Check¶
- Does each major dependency have an exit plan with a trigger?
- Has any drill been run? Which dependency would survive a price doubling?
4. How Agents Move the Calculus¶
They make the glue cheap. Integration code, adapters and policy layers are now hours, not weeks — which makes assembling more attractive, and buying more tempting, because the provider's own integration is also cheap to replace.
They make review the constraint. More glue means more diffs to review, and the review is the scarce resource. So the decision shifts: can we review this seam steadily? — not can we build it? This is the same scarcity the escalation policy protects: the human authority to approve a change. An agent writes the adapter in an afternoon; a person still has to verify it against the Law, and that capacity does not scale with the agent's output.
They do not change sovereignty. Where the data lives is a legal and architectural fact, not an effort question. An agent that can write an adapter in an hour still cannot make a provider's data residency acceptable.
Two records, one question apart. The decision record is the strategic log: why this capability, on which axes, with what exit. The execution log is the tactical log: what the work read, decided and gated while using it. One without the other leaves a question unanswerable — a record that says why but never what, or a log that says what but never why.
✅ What to Check¶
- For each recent build-or-buy, was the deciding axis effort or review capacity?
- Is any decision justified by "the agent can build it"? That is a cost argument, not a control one.
5. Build the Decision Record¶
Artefacts¶
| Artefact | What it is for | Where it lives |
|---|---|---|
| decision matrix | the five axes, scored per option | docs/decisions/<capability>.yaml |
| decision record | the choice, the axes that decided it, the date, the trigger to revisit | docs/decisions/<capability>.md |
| exit plan | seam · data · drills · trigger | inside the record |
| drill record | one vendor-change drill, with its answer | the evidence pack |
The decision matrix, as a shape — five axes, one row per option:
# docs/decisions/<capability>.yaml
capability: <what is being decided>
options:
- name: <build | buy | assemble: provider X>
control: <low | medium | high>
cost: <total, not the invoice>
time: <to first working version>
sovereignty: <where the data lives>
reversibility: <what leaving costs>
decision: <the chosen option>
decided_by: <who> date: <when>
revisit_when: <the condition that reopens this decision>
Decisions¶
| Choice | Default | What changes if you choose otherwise |
|---|---|---|
| the default path | assemble | a rebuild of commodity, or a buy of the differentiator |
| cost basis | total cost (integration · on-call · upgrade · exit) | an invoice comparison that hides three costs |
| exit plan | written with the decision | a price the vendor sets later |
| drill cadence | one per dependency per year | a plan that has never been tested |
✅ Checks¶
- Every major dependency has a record with five axes, not a paragraph.
- Every record has an exit plan with a trigger.
- One drill has been run, and its answer is recorded.
Sequence¶
- List the dependencies and place each at commodity, glue or differentiator. Checkpoint: no differentiator is bought.
- Write the matrix for the next decision. Checkpoint: five axes, total cost.
- Write the exit plan into the record. Checkpoint: a trigger and a named path.
- Run one drill on the least reversible dependency. Checkpoint: the answer is a path, not a shrug.
Done When¶
- The next dependency decision is a record, not a conversation.
- Every major dependency has an exit plan and a trigger.
- One drill has been run on the hardest case.
6. 🔑 Chapter Summary¶
Build, buy, or assemble is a record with a price on the way out.
- Five axes — control, cost, time, sovereignty, reversibility — and the decision is which conflict you can live with.
- Assemble is the default: providers for commodity, agents for the glue, the human for the differentiator.
- Total cost includes integration, on-call, upgrade and exit — not the invoice.
- The exit plan is a deliverable, with a seam, a data path, drills and a trigger.
- Agents make glue cheap and review scarce; they do not change where the data lives.