Chapter 16: Sovereignty, Portability and Exit Drills¶
Proving You Could Leave¶
1. Sovereignty Is a Requirement¶
The three structures hold data someone else may have a claim on. Sovereignty is the answer to who can read this, where is it, and what governs it — and it is a requirement, like uptime, not a value statement.
Four facts, each written down:
| Fact | The question |
|---|---|
| jurisdiction | which legal regimes govern the data? |
| residency | where is it stored, and where does it move? |
| access | who can read it — you, a provider, a support engineer? |
| governance | what policy applies, and where is it recorded? |
An answer that cannot survive a client's questionnaire is not an answer. Writing the four facts into the repository is what makes sovereignty checkable rather than asserted.
💰 Cost Check: sovereignty decided by default costs a client questionnaire you cannot answer; a vendor SDK in core costs the rewrite you cannot schedule; an exit that was never drilled costs the estimate nobody can give. A drill costs a day and produces a number. The rest costs the same day, annually, in a meeting where everybody guesses.
🎯 What You'll Learn¶
- The four facts sovereignty is made of
- Portability as a gate that fails a build
- The exit drill that replaces theorising
Where Sovereignty Leaks¶
| Leak | How it happens |
|---|---|
| a provider's default region | nobody chose it; it was the default |
| a support session | a human reads production data without a record |
| a backup in a convenient bucket | residency decided by convenience |
| an analytics export | data moves to a third jurisdiction quietly |
flowchart LR
D["data"] --> J["jurisdiction"]
D --> R["residency"]
D --> A["access"]
D --> G["governance"]
J --> C["the four facts, written down"]
R --> C
A --> C
G --> C
What this shows: sovereignty is four facts, and a missing one is the leak.
✅ What to Check¶
- Can you answer all four facts for your most sensitive dataset?
- Which of them was decided by a default rather than a choice?
2. Portability as a Gate¶
Portability is not a virtue; it is a check. The rule: core logic may not import a vendor's SDK. Adapters may. The check fails the build when the rule is broken.
That requires defining "core" — the part that must be replaceable. It is the domain logic, the policy, the method. It is not the adapter that talks to a provider; that is the seam, and it is allowed to be vendor-specific because it is meant to be replaced.
| Where | May be vendor-specific | Must be portable |
|---|---|---|
| domain logic | no | yes |
| adapters | yes | — |
| the seam | yes, behind an interface | — |
| migrations | standard SQL where possible | the recovery path |
The lock-in check fails on a violation: a vendor import in core, a proprietary query syntax in a migration, a recovery procedure that only a vendor's console can perform.
✅ What to Check¶
- Is "core" defined, so the rule is enforceable?
- Does a vendor import in core fail the build, or a review?
3. Exit Drills¶
Porting got cheaper. Agents read schemas, generate adapters, and draft a migration path in hours. That changes the economics of exit: rehearsing a departure is cheaper than theorising about it, so the drill replaces the discussion.
The drill, in five steps:
- export the data through the portable path;
- import it into a stand-in (a different provider, a local database);
- run the application against the stand-in;
- time it, and record what broke;
- decide: is the path real, or was it a story?
The drill produces the only honest number in a sovereignty conversation: what leaving would cost, in hours and in breaks.
✅ What to Check¶
- Has any exit been rehearsed, or only described?
- Which dependency would fail the drill today?
4. Provenance and SBOM¶
An exit is not only data: it is also knowing what you shipped. Provenance and a software bill of materials answer what components are in this release, and where did they come from — which matters to a client audit, to a security review, and to the day you must rebuilt the release somewhere else.
| Artefact | Answers |
|---|---|
| SBOM | what components, and which versions |
| provenance | who built it, from which source, when |
| the lock-in check | whether the build depends on one vendor's tooling |
All three are produced by the pipeline, not by a document written afterwards. A provenance record assembled by hand is a claim.
✅ What to Check¶
- Can you list the components of your last release from an artefact, not from memory?
- Does the build depend on a vendor's tooling to reproduce?
5. Build the Workbench¶
Artefacts¶
| Artefact | What it is for | Where it lives |
|---|---|---|
| sovereignty record | the four facts, per dataset | docs/sovereignty/<dataset>.yaml |
| portability rule | what "core" is, and the import ban | the Law, plus a check |
| lock-in check | fails on a vendor import in core | the gate |
| exit drill record | the drill, its timing, what broke | the evidence pack |
The sovereignty record, as a shape — four facts, no prose:
# docs/sovereignty/<dataset>.yaml
dataset: <name>
jurisdiction: <regimes that govern it>
residency: <where stored, where it moves>
access: [<you>, <provider role>, <support>]
governance: <policy, and where it is recorded>
Decisions¶
| Choice | Default | What changes if you choose otherwise |
|---|---|---|
| where the facts live | the repository, per dataset | a questionnaire answered from memory |
| portability rule | core may not import a vendor; adapters may | a build that only one vendor can reproduce |
| exit drills | one per dependency per year | a cost everybody quotes and nobody measured |
| provenance | produced by the pipeline | a claim assembled afterwards |
✅ Checks¶
- All four sovereignty facts are recorded for each dataset.
- A vendor import in core fails the build.
- One exit drill has been run, timed and recorded.
Sequence¶
- Record the four facts for the most sensitive dataset. Checkpoint: none of them is "default".
- Define core and add the import check. Checkpoint: a planted vendor import fails.
- Run one exit drill. Checkpoint: the timing and the breaks are recorded.
- Produce provenance in the pipeline. Checkpoint: the release's components come from an artefact.
🎯 Done When¶
- Sovereignty is four recorded facts, per dataset.
- A vendor import in core cannot merge.
- The cost of leaving one dependency is a measured number, not an opinion.
6. 🔑 Chapter Summary¶
Sovereignty is four facts; portability is a gate; exit is a drill.
- Sovereignty = jurisdiction · residency · access · governance, recorded per dataset.
- Portability is a check, not a virtue — define core, ban the vendor import, fail the build.
- Exit drills are cheap enough to run, and they produce the only honest cost of leaving.
- Provenance and SBOM are how you prove what you shipped, from an artefact.
- A default is not a decision — every sovereignty leak starts with one.