Stackable Docs Hub

Stackable

Stackable

How do you control where shared data can be processed and accessed?

When data is shared across teams, systems, or organisational boundaries, a deceptively simple question emerges: who decides where that data can go, who can touch it, and under what conditions? The answer matters more than ever in 2026, as regulatory frameworks like the Digital Operational Resilience Act (DORA) and the NIS-2 Directive push organisations to demonstrate not just that data is protected, but that they can prove it. Data sovereignty is no longer a preference: it is a compliance requirement for many industries.

The challenge is that most data infrastructure was not designed with fine-grained location and access control in mind. Data moves freely across pipelines, clouds, and regions, and governance is often bolted on after the fact. This post walks through the architectural patterns and practical mechanisms that give domain owners, platform engineers, and data teams real control over shared data access and processing location. We look at how Stackable approaches this specifically at the end.

The challenge of governing data across distributed environments

Distributed data environments create a fundamental tension: the more you share data to extract value from it, the harder it becomes to control where it ends up and who processes it. A single dataset might be consumed by an analytics team in one region, a machine learning pipeline in another, and a third-party partner system somewhere else entirely. Each hop introduces a new governance surface.

Traditional approaches to data governance (centralised catalogs, manual access reviews, network-level firewalls) struggle to keep pace with the speed and scale of modern data platforms. They tend to produce either over-restriction (teams can’t get the data they need) or under-restriction (data flows freely with minimal audit trail). Neither outcome is acceptable when regulatory compliance or data sovereignty is at stake. What organisations need is governance that travels with the data and enforces rules at the point of processing, not just at the perimeter.

How data mesh architecture shifts control to domain owners

Data mesh reframes the governance problem by distributing ownership. Instead of a central team responsible for all data quality, access, and movement, each business domain owns its data products and is accountable for how they are shared and consumed. This is not simply a political reorganisation: it has direct technical implications for how access control and processing boundaries are enforced.

In a data mesh model, domain teams publish data products with explicit contracts: what the data contains, who can access it, under what conditions, and where it can be processed. This shifts the control plane closer to the people who understand the data best. A finance domain team, for example, can specify that certain datasets must remain within a specific geographic boundary or can only be queried by systems that meet defined security standards. Centralised governance does not disappear: it becomes federated, setting the rules that domain owners implement locally.

The practical benefit is that governance scales with the organisation. As new domains are added or data products evolve, each team manages its own access policies without creating bottlenecks at a central data office. The tradeoff is that federated governance requires strong tooling to remain consistent and auditable across domains, which is where policies as code become essential.

Policies as code: enforcing processing boundaries programmatically

Policies as code means expressing access rules, processing location constraints, and data handling requirements as machine-readable definitions that are version-controlled, tested, and applied automatically. Rather than relying on documentation or manual configuration, the rules are embedded directly into the infrastructure and enforced at runtime.

This approach has several concrete advantages for shared data access control. First, policies are auditable: every change is tracked in version control, and every enforcement decision can be logged. Second, they are reproducible: the same policy applied in a development environment will behave identically in production. Third, they are composable: domain-level policies can inherit from organisation-wide baselines, reducing duplication while allowing local customisation.

What policies as code looks like in practice

In a Kubernetes-native data platform, policies can be expressed using tools like Open Policy Agent (OPA) or Kyverno, which evaluate requests against defined rules before allowing workloads to run or data to be accessed. A policy might specify that a particular Apache Spark™ job can only execute in a cluster tagged with a specific geographic region label, or that a Trino query against a sensitive table requires the requesting service account to hold a particular role. These rules are declared in YAML or Rego, stored in a Git repository, and applied through the same GitOps workflows used to manage the rest of the infrastructure.

The result is that data processing location and access control become first-class infrastructure concerns, not afterthoughts. When a new data product is published, the access policy is part of the deployment artifact, not a separate ticket raised to a security team weeks later.

Running data workloads where sovereignty demands it

Data sovereignty requirements often translate directly into location requirements: certain data must be processed within a specific country, region, or even a specific data centre. This is particularly relevant for organisations operating under European data protection frameworks, or for public sector entities with strict on-premises mandates.

A cloud-agnostic, Kubernetes-native architecture makes this tractable. Because Kubernetes abstracts the underlying infrastructure, the same workload definitions can be deployed to an on-premises cluster, a private cloud, or a hyperscaler without rewriting pipelines or reconfiguring data apps. The scheduling layer can be configured to respect node labels, taints, and affinity rules that map directly to physical or logical location constraints. A workload that must stay within a German data centre can be pinned to nodes that carry the appropriate labels, and that constraint is enforced by the platform itself rather than by convention.

This matters because location constraints that live only in documentation are not really constraints at all. When the infrastructure enforces them automatically, the guarantee is structural rather than procedural, and that is the kind of guarantee that satisfies both internal auditors and external regulators.

Avoiding lock-in while maintaining centralised visibility

One of the less obvious risks in distributed data governance is that solving the sovereignty problem by committing deeply to a single cloud provider’s native tooling simply trades one problem for another. Proprietary access control mechanisms, vendor-specific policy languages, and platform-native audit logs create dependencies that are difficult and expensive to unwind.

Open standards and open-source tooling provide a path that avoids this. When access policies are written in open formats and enforced by open-source policy engines, they are portable. When audit logs are emitted in standard formats and collected by open-source observability stacks, they are not trapped in a proprietary system. Centralised visibility (the ability to see across all domains what data is being accessed, by whom, and from where) can be achieved without centralising control in a vendor’s platform.

The key is choosing a data platform architecture that treats interoperability as a design principle rather than a feature. That means Kubernetes-native workloads, open-source data apps, and governance tooling that integrates through standard APIs rather than proprietary connectors.

Practical steps to implement access and location controls in SDP

Translating these principles into a working implementation requires a few concrete decisions. The following steps reflect a practical sequence for teams building or maturing their data governance posture on a Kubernetes-native platform.

  1. Define your data classification schema first. Before writing a single policy, agree on how data is classified (by sensitivity, by regulatory category, by domain ownership). Policies without a clear classification model tend to be inconsistent and hard to maintain.
  2. Label your infrastructure to reflect location and trust boundaries. Kubernetes node labels and namespace annotations are the foundation for location-aware scheduling. Map your physical or logical boundaries to these labels early, so policies can reference them consistently.
  3. Adopt a GitOps workflow for policy management. Storing policies in Git and applying them through a continuous delivery pipeline ensures that every change is reviewed, versioned, and auditable. The Argo CD GitOps demo illustrates how this pattern works in practice with the Stackable Data Platform (SDP).
  4. Enforce access control at the data app layer, not just the network layer. Network policies are necessary but not sufficient. Tools like Trino support fine-grained column- and row-level access control, which means sensitive fields can be masked or restricted without blocking access to the entire dataset.
  5. Build observability into the governance layer from the start. Audit logs, policy evaluation traces, and access metrics should be collected and queryable from day one. Governance that cannot be inspected cannot be trusted.

For teams working with sensitive data pipelines, the integrated data security demo shows how authentication, authorisation, and encryption can be layered across the SDP stack in a coherent, inspectable way.

How Stackable helps with data sovereignty and access control

The SDP is built specifically for organisations that need to control where their data is processed and who can access it, without trading that control for convenience or locking themselves into a single vendor’s ecosystem. Here is what that looks like concretely:

  • Cloud-agnostic deployment: The SDP runs on-premises, in any cloud, or in hybrid environments. Location constraints are enforced at the Kubernetes scheduling layer, not by convention.
  • Policies as code, natively: The platform supports federated computational governance through policies as code, allowing domain teams to define and enforce access rules programmatically within a consistent organisational framework.
  • Open-source data apps with integrated security: Components like the Trino Operator and the Stackable Operator for Apache Kafka® include built-in support for authentication, authorisation, and encryption, configured through standard Kubernetes resources, not proprietary consoles.
  • No vendor lock-in: All platform components are open source. Policies, configurations, and workloads are portable across environments and not tied to a proprietary control plane.
  • Fully traceable software supply chain: Every component in the SDP has a traceable provenance, which supports compliance requirements that extend beyond data governance to software supply chain integrity.

If you are working through how to implement data sovereignty controls in your own environment, get in touch with the Stackable team: we are happy to work through the specifics with you.

Related Articles

Comments are closed.