Stackable Docs Hub

Stackable

Stackable

The documents your auditor will ask for – producing data-sovereignty evidence from your platform

Audit season has a way of concentrating minds. Somewhere between the auditor’s opening email and the first document request, most data teams discover that the evidence they assumed existed is either scattered across three systems, locked inside someone’s head, or simply missing. Data sovereignty audits are particularly unforgiving in this respect: regulators and external reviewers want to see not just that you have a policy, but that your platform enforces it, traces it, and can prove it on demand.

Frameworks like the General Data Protection Regulation (GDPR), the Digital Operational Resilience Act (DORA), and the NIS-2 Directive are increasingly specific about what „demonstrable compliance“ means. They want documentation that is current, traceable, and tied to actual system behaviour, not to a slide deck from last year’s governance workshop. This article walks through the document types auditors request most often, the gaps that generate findings, and how to build an audit package that does not need to be rebuilt from scratch every cycle. We look at how the Stackable Data Platform (SDP) supports this specifically at the end.

What auditors actually look for in data-sovereignty reviews

Auditors conducting data-sovereignty reviews are not primarily looking for perfection. They are looking for evidence of control: proof that your organisation knows where data lives, who can reach it, and what happens when something changes. The underlying question behind almost every document request is the same: „Can you show me that this is actually true, not just written down somewhere?“

In practice, this means auditors want artefacts that are generated by the system itself, not produced retrospectively. A policy document is a starting point. A log showing that the policy was enforced at 14:37 on a specific date is evidence. The distinction matters enormously under GDPR and DORA, where the burden of proof sits with the data controller or the regulated entity. Sovereignty-specific reviews add another layer: auditors want to confirm that data does not leave a defined perimeter without explicit authorisation, and that the platform itself, not just a firewall rule, enforces that boundary.

The six document types that satisfy most sovereignty audits

Most data-sovereignty audits converge on a recognisable set of document categories. Knowing these in advance means you can instrument your platform to produce them continuously rather than assembling them under pressure.

1. Data residency records

These confirm where data is stored and processed, down to the infrastructure level. Auditors want to see that data classified as subject to a specific jurisdiction never leaves that jurisdiction, and that the platform enforces this rather than relying on manual process.

2. Access control logs

A complete, timestamped record of who accessed what data, when, and from which identity. This includes both successful and denied access attempts. Gaps in access logs are one of the most common causes of audit findings.

3. Data lineage documentation

Lineage records show how data moves through your platform: from ingestion through transformation to consumption. Auditors use lineage to verify that sensitive data is not inadvertently copied to environments with weaker controls, and to trace the origin of any data used in a regulated process.

4. Configuration change history

A record of every change made to platform configuration, including who made it, when, and what the previous state was. This is particularly relevant under DORA, which requires financial entities to demonstrate operational resilience through traceable change management.

5. Encryption and key management evidence

Documentation showing that data at rest and in transit is encrypted, which keys are used, who manages them, and how key rotation is handled. Auditors increasingly ask for evidence that encryption is enforced at the platform level, not just recommended in a policy.

6. Incident and anomaly records

A log of detected anomalies, security events, and the actions taken. Under NIS-2 Directive requirements, organisations must demonstrate not only that they detect incidents but that they respond to them within defined timeframes and document the outcome.

How a Kubernetes-native platform generates evidence automatically

One of the practical advantages of running data infrastructure on Kubernetes is that the platform’s control plane is itself a source of audit evidence. Kubernetes records every state change, every resource creation, and every configuration update in its audit log. When your data platform is built natively on Kubernetes rather than layered on top of it, that audit trail extends naturally to your data applications.

A Kubernetes-native approach means that access control is expressed as code, stored in version control, and applied consistently across every component. Role-based access control (RBAC) policies are not configured through a GUI that leaves no trace; they are declared in YAML, committed to a repository, and enforced by the cluster. The same is true for network policies that enforce data residency boundaries: the policy is a file, the enforcement is automatic, and the audit log records every enforcement decision. This is the difference between a platform that supports compliance and one that generates compliance evidence as a by-product of normal operation.

For teams working with integrated data security across multiple components, this matters because the evidence is consistent. The access log from your query engine and the network policy enforcement record from your cluster speak the same language, reference the same identities, and can be correlated without manual translation.

Mapping platform outputs to specific auditor requests

The gap between „we have logs“ and „here is the evidence you asked for“ is where many audit preparations stall. Auditors ask specific questions, and the answer needs to be a specific document or query result, not a pointer to a logging system.

A useful exercise is to map each of the six document types above to a concrete platform output. For access control logs, this might be a query against your centralised log aggregator filtered by resource type and time range. For data lineage, it might be an export from your metadata catalogue showing the transformation graph for a specific dataset. For configuration change history, it is typically a Git log from the repository where your infrastructure-as-code definitions live, combined with the Kubernetes audit log for the corresponding deployment events.

The key is to define these mappings before the audit, not during it. Document the query or export procedure for each document type, test it against a realistic time range, and store the procedure alongside your audit package. When the auditor asks for access logs covering a specific three-month window, the answer should take minutes, not days. Teams using GitOps-based deployment workflows already have a significant portion of their configuration change history in a format auditors can read directly.

Common gaps that cause audit findings, and how to close them

Audit findings in data-sovereignty reviews tend to cluster around a small number of recurring gaps. Recognising them early is the most efficient way to avoid them.

Incomplete identity coverage

Access logs that cover human users but not service accounts are a frequent finding. Automated pipelines, ETL jobs, and data applications all access data under service identities, and those identities need to appear in your access control records with the same completeness as human users. If your platform does not log service account activity at the same level of detail, that is a gap worth closing before the audit begins.

Lineage that stops at the platform boundary

Data lineage documentation often covers transformations within a single tool but breaks at integration points. If data moves from a streaming platform into a data lakehouse and then into a reporting layer, the lineage record needs to follow it across all three. Partial lineage is better than none, but auditors will note where the chain breaks.

Configuration drift without a record

When platform configuration is managed manually or through ad-hoc scripts, the change history is often incomplete or absent. Infrastructure-as-code approaches address this directly: every change is a commit, every commit has an author and a timestamp, and the full history is queryable. Teams that have not yet moved to this model often discover the gap when an auditor asks who changed a specific setting and when.

Encryption evidence that is policy, not proof

Stating that encryption is required is not the same as demonstrating that it is enforced. Auditors increasingly ask for evidence at the platform level: TLS configuration records, key management audit logs, or automated compliance scan results that confirm encryption is active across all data paths.

Building a living audit package that stays current

A static audit package assembled once a year is a liability. By the time the auditor arrives, it is already out of date, and the effort required to refresh it is substantial. A living audit package, by contrast, is a set of continuously updated artefacts that reflect the current state of the platform at any point in time.

The practical approach is to treat audit evidence as a platform output rather than a manual deliverable. Define the queries, exports, and reports that produce each document type, schedule them to run regularly, and store the outputs in a location that is itself access-controlled and auditable. When the audit window opens, the package is already populated; the only work required is to scope it to the relevant time period and verify completeness.

Version control plays a central role here. Infrastructure-as-code definitions, RBAC policies, network policies, and encryption configurations should all live in a repository with a complete history. That repository is itself a primary audit artefact: it shows not just the current state but every state the platform has been in, who changed it, and when. Pair that with automated log aggregation and a metadata catalogue that tracks query-level data access, and the audit package largely builds itself.

The goal is to reach a point where an unannounced audit request is a minor operational event rather than an emergency. That requires investment in instrumentation upfront, but the return is not just audit readiness: it is operational visibility that benefits the platform team every day, not just once a year.

How Stackable supports data-sovereignty audit readiness

The SDP is built on Kubernetes, which means the audit trail described throughout this article is a natural property of the platform rather than something bolted on. Here is what that looks like concretely:

  • Infrastructure-as-code by default: Every data application managed by the SDP is declared in Kubernetes-native custom resources. Configuration changes are tracked in version control and applied through the Kubernetes API, giving you a complete, timestamped change history without additional tooling.
  • Consistent RBAC across components: The SDP applies Kubernetes RBAC uniformly across all managed data applications, including the Stackable Operator for Apache Kafka® and Apache Spark™. Service account activity is logged alongside human user access, closing one of the most common audit gaps.
  • Network policy enforcement for data residency: Kubernetes network policies define and enforce data perimeter boundaries at the platform level. The SDP uses these to ensure that data classified for a specific environment does not leave it, and the enforcement decisions are recorded in the cluster audit log.
  • Open-source transparency: Because the SDP is fully open source, there are no black-box components that auditors cannot inspect. Every operator, every configuration option, and every default is visible and documented, which supports the „demonstrable control“ standard that sovereignty audits require.
  • Cloud-agnostic deployment: The SDP runs on-premises, in any cloud, or in hybrid environments, which means data residency boundaries are enforced by the platform regardless of where it runs, not by a cloud provider’s terms of service.

If you are preparing for a data-sovereignty audit or building the instrumentation to make future audits less painful, we are happy to walk through what the SDP produces out of the box and where additional configuration may be needed for your specific regulatory context. Get in touch with the Stackable team to start that conversation.

Ähnliche Artikel

Comments are closed.