Governed Database
Most platforms treat governance as something you build around a database: a CDC pipeline feeding an audit lake, a WHERE tenant_id = ... clause every query has to remember, a compliance tool bolted on to satisfy an auditor. The Governed Database inverts that. The controls a regulated buyer normally assembles from application logic are properties of the engine itself — enforced structurally at the substrate, not advised by a library a developer might forget to call.
This is the operational core of Kilimanjaro — a multi-region, residency-aware engine that answers SQL, document, full-text, and vector queries behind one surface (see Data architecture for the mechanics). This page is the conceptual framing: what makes it governed, and why that is a different category from both a hosted Postgres and a ledger database.
1. Governance intrinsic to the substrate
The defining property is where the governance lives. In a conventional stack, audit, residency, access-scoping, and erasure are each a separate system a team integrates and keeps in sync. In the Governed Database they are enforced at the engine layer, so they cannot drift out of sync with the data and cannot be skipped by a code path that forgot them.
Two contrasts sharpen what this is:
- Not a hosted BaaS Postgres. A managed database gives you storage and leaves governance to your application. Here the governance controls are structural — a query cannot escape its residency region or its tenant scope, because the engine narrows it, not because a developer wrote the guard.
- Not a ledger database. Ledger and immutable-database products (AWS QLDB, Azure SQL Ledger, immudb) are append-only — they record history and cannot delete. That satisfies audit but fails erasure: an append-only store cannot honor a lawful right-to-be-forgotten request. The Governed Database is the opposite where it counts — provably auditable and provably erasable in one engine (see §4).
2. The Forensic Identity loop
The Governed Database does not authenticate — it consumes an identity that was already cryptographically established. The pairing with the Identity-Aware Kernel is the platform's core governance loop:
- Gate signs the actor. Every request context is cryptographically signed at the gateway ingress — the Forensic Identity (Identity-Aware Kernel §7). This tracks who is asking.
- The engine attests the action. The Governed Database consumes that signed identity to enforce row-scoped multi-tenancy, and pins the resulting mutation to the tamper-evident audit trail at the origin. This evidences what was actually done.
Gate signs the actor; the Governed Database governs and evidences the action. Because the identity is consumed at the engine rather than checked in application code, a developer who forgets a tenant filter never leaks data — the scoping already happened one layer down.
3. The four pillars
Each pillar is enforced structurally, not advised. The claims are also scoped precisely — the accurate word matters as much as the mechanism.
| Pillar | What the engine enforces | Boundary |
|---|---|---|
| Tamper-evident audit | Every mutation is a signed event in a hash-chained trail, periodically checkpointed to a signed transparency anchor across all three namespaces | Tamper-evident, not tamper-proof; detection covers anchored events and rests on signing-key custody — see §3.1 |
| Data-residency | Row-level geo-partitioning; residency-scoped data region-homed per subject, no global key | Home region is fixed; the spanned residency set can grow or shrink via audited operations |
| Access | Relational rows are scoped at the engine via row-level security resolved against the Forensic Identity | Scoped to relational rows; object storage and maker-checker approvals are policy-evaluated at the application layer — see §3.3 |
| Provable erasure | Crypto-shred of your declared encrypted footprint renders it unrecoverable — live data and backups — within the erasure SLA | Scoped to the personal data you store encrypted (encryption is customer-declared); referenced-subject appearances are a disclosed, custodian-scoped boundary — see §3.4 |
3.1 Tamper-evident audit
Every data-plane mutation — a write, a policy publish, a maker-checker decision, an erasure — is recorded as a signed event in a hash-chained audit trail (the project's _sys.audit_log): each event's hash references the prior event's, so an event cannot be silently inserted, removed, or altered without breaking the chain. The chain is periodically checkpointed to a signed transparency anchor, which can optionally be published to an external transparency log.
- Tamper-evident, not "immutable" or "tamper-proof." The chain lets you detect and prove alteration; it does not physically prevent it. An immutable store cannot forget, which conflicts with the erasure pillar below.
- Independently verifiable via external anchoring. The transparency anchor is signed by the platform's ledger key, so a compliance package can attest tamper-evidence without trusting the platform's word for it. Verification against the platform's own signature resists outside tampering; resistance to a platform insider holding the signing key is the property external anchoring specifically provides.
This data-mutation trail is a distinct system from Kibo's audit ledger — each event's hash-chain linkage is checked by an internal chain-walk verifier. Detection has a window: it covers every anchored event, and the tail since the last anchor is bounded by the anchor cadence.
3.2 Data-residency
Residency is a structural property of the data, not a deployment convenience. A project's home jurisdiction is fixed at creation and cannot be moved; the set of regions the project spans can grow or shrink through audited operations. Residency-scoped data is region-homed per subject — each subject's rows and per-subject key live in one region of the project's residency set, with no global key that could span jurisdictions. Removing a region does not export and re-import data: it re-keys the affected subjects into another region internally, then destroys the departing region's key. Cross-border movement is opt-in and audited, never a side effect of where a query originated. This is the substrate-level half of the platform's sovereignty posture.
3.3 Access
Access control over relational rows is the same row-level security the data plane enforces, resolved against the Forensic Identity (§2). JSON policies authored in migration files compile to Postgres RLS clauses; the developer never writes RLS directly. Because the policy is enforced at execution time inside the engine, a relational access rule cannot be reasoned around by a query that skipped an application-layer check.
Object-storage access and the maker-checker approval gate are evaluated by a separate policy engine at the application layer, not by RLS — the same JSON policy language, but not the engine-level enforcement the relational plane gets. The "enforced structurally, not by code discipline" claim is scoped to relational rows; object storage and approval decisions are governed, just by a different mechanism.
3.4 Provable erasure
Data you declare and store encrypted is sealed under a key unique to your project, so destroying that key renders the encrypted data cryptographically unrecoverable at once — live data and backups together — without locating and scrubbing each copy (cryptographic erasure, NIST SP 800-88 crypto-erase). The act is evidenced by platform-signed shred receipts (backed by destruction of the key-encryption key) — the same platform key that signs the audit ledger verifies the shred receipt.
The guarantee is scoped:
- It covers your declared encrypted footprint, not "all your data." Encryption is a per-column choice you declare; a column you leave plaintext is your own classification decision and sits outside the crypto-erasure guarantee. The claim is over the personal data you hold as a record-owner and store encrypted.
- Extension-owned storage is a separate boundary. Tables an installed extension owns (
_ext_<slug>) sit outside the declaration mechanism entirely — there is no customer-facing way to declare encryption scope on extension-owned data, so it is outside both the encrypted-footprint claim and this erasure guarantee. - Referenced-subject appearances have different technical properties, not the same guarantee. Where you appear as a referenced subject inside another record-owner's data — including derived context and embeddings that relate to multiple data subjects — that cross-owner appearance is crypto-shredded custodian-scoped, when that owner's own data is erased, within the same SLA. It is not independently erasable on your own request: selective identification and erasure of one individual's information within a multi-subject derived artefact may not always be technically achievable. This is a disclosed scope limitation, not an exclusion from erasure obligations.
- Completion is SLA-bound, not instantaneous. Key destruction is immediate; backup reach completes within the platform's 28-day erasure SLA, not in real time.
- Erasure and key-custody sovereignty are different claims. Provable erasure says the data is destroyed; it does not by itself say the platform cannot see the data while the project is live — that operator-blind property is BYOK / HYOK custody, kept distinct.
4. The reconciliation: auditable and erasable
The category's genuine innovation is holding two properties that usually trade off against each other. Ledger databases achieve audit by being append-only, which makes them unable to forget — a direct conflict with data-protection law's right to erasure. A Governed Database resolves this precisely because its audit trail is tamper-evident, not immutable:
- An immutable store cannot forget — erasure would violate the immutability it claims.
- A tamper-evident store can erase as a legitimate, evidenced operation — the deletion is itself a signed, chain-anchored event, so the record reads "this was deleted, and here is the tamper-evident proof that it was."
That is why "tamper-evident" (not "immutable") is the load-bearing word for both the audit and the erasure pillars: it is the single framing under which provable audit and provable erasure coexist in one engine.
5. What the Governed Database is not
Being precise about the category means naming its edges:
- It is not a separately branded offering. The transactional engine is Kilimanjaro at its core — the sovereign foundation the rest of the stack rests on. Its name is its category.
- It does not claim immutability, tamper-proofing, or real-time erasure.
- It does not make governance optional. The four pillars are structural properties of the substrate; a project cannot opt into storage while opting out of residency, audit, or access scoping.
6. See also
- Identity-Aware Kernel — Gate signs the actor the engine consumes.
- Data architecture — the schema families, the query surface, and RLS mechanics beneath the pillars.
- Sovereign Stack — where the Governed Database sits among the pillars.
- Kibo — audit ledger — the tamper-evident ledger and its formal-verification boundary.
- Kibo — cryptographic erasure — the provable-erasure mechanism and its precise scope.
- Regions & residency — the residency model the data-residency pillar rests on.