Skip to content

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:

  1. export the data through the portable path;
  2. import it into a stand-in (a different provider, a local database);
  3. run the application against the stand-in;
  4. time it, and record what broke;
  5. 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

  1. Record the four facts for the most sensitive dataset. Checkpoint: none of them is "default".
  2. Define core and add the import check. Checkpoint: a planted vendor import fails.
  3. Run one exit drill. Checkpoint: the timing and the breaks are recorded.
  4. 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.

  1. Sovereignty = jurisdiction · residency · access · governance, recorded per dataset.
  2. Portability is a check, not a virtue — define core, ban the vendor import, fail the build.
  3. Exit drills are cheap enough to run, and they produce the only honest cost of leaving.
  4. Provenance and SBOM are how you prove what you shipped, from an artefact.
  5. A default is not a decision — every sovereignty leak starts with one.