AI Skill Report Card
Architecting Digital Sovereignty
Architecting Digital Sovereignty
Designs sovereignty architectures that give organizations control over their data, infrastructure, and governance — reducing lock-in and external dependency.
Quick Start14 / 15
Given a request, produce three deliverables in this order:
- Sovereignty Model — the architecture that ensures data/infrastructure independence
- Ownership Framework — who owns what, and how ownership is enforced technically and legally
- Governance Layer — decision rights, policies, and oversight mechanisms
Example prompt: "Design a digital sovereignty architecture for a national health records system currently hosted on a foreign hyperscaler."
Output structure:
Recommendation▾
Add an edge case for partial sovereignty scenarios where full independence is legally impossible (e.g., regulated industries)
Sovereignty Model
- Current dependency risks
- Target architecture (infrastructure, data residency, interoperability)
- Migration/independence path
Ownership Framework
- Data ownership (who legally/technically controls what)
- Access control & custody model
- Portability & exit guarantees (no lock-in)
Governance Layer
- Decision-making bodies & authority
- Policy enforcement mechanisms
- Audit, compliance, and dispute resolution
Workflow14 / 15
Progress:
- Identify the sovereignty subject (nation, org, community, individual)
- Map current dependencies (cloud providers, foreign jurisdictions, proprietary formats)
- Assess risk exposure (legal, technical, geopolitical, economic)
- Design Sovereignty Model (infrastructure + data layer independence)
- Design Ownership Framework (legal + technical custody)
- Design Governance Layer (who decides, how enforced)
- Define transition/migration path from current state to sovereign state
- Flag residual dependencies that cannot be fully eliminated
Step details:
- Identify subject — sovereignty means different things at different scales (a nation vs. a company vs. an individual). Clarify scope before designing.
- Map dependencies — list every third party with control over data, compute, identity, or keys. This is the risk surface.
- Sovereignty Model — favor open standards, self-hosted or federated infrastructure, encryption with self-held keys, and multi-vendor redundancy over single-vendor lock-in.
- Ownership Framework — separate legal ownership (contracts, jurisdiction) from technical ownership (who holds keys/root access). Both must align.
- Governance Layer — define an authority structure (e.g., steering committee, data trust, multi-stakeholder board) with explicit powers: policy-setting, auditing, veto, dispute resolution.
- Migration path — sovereignty is rarely achieved instantly; sequence it (e.g., data portability first, compute independence second, identity/key independence third).
Recommendation▾
Include a brief note on cost/resource trade-offs quantification to make the risk assessment step more actionable
Examples18 / 20
Example 1: Input: "A city government wants sovereignty over its citizen data currently stored in a US-based SaaS CRM." Output:
Recommendation▾
Consider adding a third, more complex example (e.g., multi-national consortium) to show scalability of the framework
Sovereignty Model
- Risk: data subject to foreign legal jurisdiction (e.g. CLOUD Act exposure)
- Target: self-hosted or in-region CRM on open-source stack (e.g. CiviCRM/Odoo) with data residency guaranteed in-country
- Encryption at rest/in-transit with keys held by city IT, not vendor
Ownership Framework
- City retains legal title to all citizen records (contractual clause)
- Technical custody: city-controlled key management service (KMS)
- Export guarantee: full data export in open format (CSV/JSON) on 30-day notice
Governance Layer
- Data Governance Board (city CIO, legal, citizen privacy officer)
- Quarterly audit of access logs and third-party integrations
- Formal process for citizens to request data access/deletion
**Example 2:**
Input: "An open-source community wants infrastructure independence from GitHub."
Output:
Sovereignty Model
- Mirror repos to self-hosted Forgejo/Gitea instance
- CI/CD on community-owned runners, not tied to single platform
- DNS and identity (SSO) decoupled from any single vendor
Ownership Framework
- Code ownership already clear (licenses); add mirror-of-record policy
- Infrastructure owned via community-controlled entity (foundation/co-op)
- Backup/export cadence: nightly full mirror to independent storage
Governance Layer
- Maintainer council decides infra changes by majority vote
- Transparent incident/postmortem process
- Escape hatch documented: how to fully fork away from any single host
Best Practices
- Always separate legal ownership from technical custody — sovereignty requires both.
- Prefer open standards and formats over proprietary ones to guarantee portability.
- Design for graceful degradation: if one dependency disappears, the system should survive.
- Make exit/migration paths explicit — sovereignty without an exit plan is theoretical.
- Governance should have named authorities and enforcement mechanisms, not just principles.
- Where full independence is impossible, flag and quantify residual dependency rather than ignoring it.
Common Pitfalls
- Don't conflate "self-hosted" with "sovereign" — sovereignty also requires legal and governance control, not just infrastructure location.
- Don't propose 100% independence as a default; identify realistic trade-offs (cost, expertise, resilience).
- Don't skip the Governance Layer — architecture without decision-rights collapses under real-world disputes.
- Don't ignore key/credential custody — whoever holds the encryption keys holds real control, regardless of stated ownership.
- Don't present a static end-state only — always include the migration/transition path.