Public-sector organisations face a specific tension when it comes to data sharing: the need to collaborate across agencies, municipalities, and departments sits in direct conflict with legal obligations around data residency, citizen privacy, and regulatory compliance. Getting this balance right requires more than good intentions. It requires a deliberate architectural approach that treats sovereignty not as a constraint to work around, but as a design principle to build from.
This post walks through the core requirements, architectural patterns, and practical steps for building a sovereign data-sharing platform suited to public-sector realities. We look at how open-source infrastructure and data mesh principles apply in this context, and where teams most commonly go wrong. At the end, you’ll find a concrete overview of how the Stackable Data Platform (SDP) supports this kind of architecture.
Core requirements for public-sector data sovereignty
Sovereign data sharing in the public sector starts with a clear definition of what sovereignty actually means in practice. It is not simply about keeping data on-premises. It means maintaining full control over where data lives, who can access it, under what conditions, and with full auditability of every interaction.
Several regulatory frameworks shape these requirements directly. The NIS-2 Directive (always hyphenated) sets baseline cybersecurity obligations for essential and important entities, including many public-sector bodies. The Digital Operational Resilience Act (DORA) applies to financial public institutions. Beyond these, national data protection laws and sector-specific regulations add further layers. From our perspective, any architecture that cannot demonstrate compliance traceability is not fit for public-sector use.
The practical requirements that follow from this include: data residency controls that enforce where data is stored and processed, fine-grained access governance that ties permissions to roles and policies rather than individuals, full audit logging, and the ability to operate independently of any single cloud provider. A cloud-agnostic data platform is not a nice-to-have here. It is a prerequisite.
How open-source infrastructure enables data sovereignty
Open-source infrastructure gives public-sector organisations something proprietary solutions structurally cannot: full visibility into what the software does. When the source code is auditable, security teams can verify behaviour rather than trust vendor assurances. This matters enormously when the data in question belongs to citizens.
Beyond auditability, open-source tooling avoids the vendor lock-in that has historically made it difficult for public bodies to change direction. When a proprietary vendor changes its licensing model or discontinues a product, organisations that built on it have limited options. Open-source stacks, by contrast, allow organisations to fork, self-host, and maintain continuity regardless of what any single company decides.
Kubernetes has become the de facto standard for deploying open-source data infrastructure at scale. A Kubernetes-native approach means workloads are portable across environments, infrastructure-as-code practices are straightforward to apply, and operational consistency is achievable whether the platform runs in a government data centre, a private cloud, or a hybrid setup. This portability is central to maintaining data sovereignty across complex, multi-environment public-sector IT landscapes.
Key architectural components of a sovereign sharing platform
A sovereign data-sharing architecture for public-sector use is not a single product. It is a composition of components, each responsible for a specific layer of the stack.
Data ingestion and transport
Event streaming infrastructure handles the movement of data between systems in a traceable, auditable way. Apache Kafka® is the most widely adopted tool for this layer, providing durable, ordered message delivery with strong access controls. The Kafka Operator approach to deployment ensures that configuration is version-controlled and reproducible, which matters for compliance audits.
Storage and query
The storage layer needs to support open formats that are not tied to any vendor’s proprietary encoding. Apache Iceberg is a strong choice here, providing table-format interoperability across query engines. Trino serves as a federated query layer, allowing analysts to query data across multiple sources without centralising everything into a single store. This separation of storage and compute is architecturally important for sovereignty: it means data does not need to move to be queried.
Access governance and policy enforcement
Policies as Code is the right model for public-sector governance. Rather than managing access through manual processes or GUI-based tools, access rules are defined in version-controlled policy files, applied consistently, and auditable by default. This approach supports the federated governance model that data mesh architectures rely on, and it scales across departments without creating a centralised bottleneck.
Observability and audit
Every data access event, configuration change, and pipeline execution should produce structured logs that feed into a centralised observability layer. OpenSearch is a capable open-source option for log aggregation and search, and it integrates well with the rest of an open-source data stack.
Applying data mesh principles to public-sector data sharing
Data mesh is particularly well-suited to public-sector environments because it mirrors how these organisations actually work: as a collection of semi-autonomous domains, each with its own data, responsibilities, and governance requirements.
In a data mesh model, each domain, whether that is a ministry, a municipality, or a department, owns and publishes its data as a product. Other domains consume those products through well-defined interfaces, without needing direct access to the underlying systems. This federated model reduces the risk of data being misused or accessed outside its intended scope, which is a core concern in public-sector data governance.
The self-serve infrastructure layer is what makes this practical. Without it, each domain would need its own dedicated platform team, which is not realistic at scale. A shared, self-serve data platform allows domain teams to provision, configure, and operate their own data products without deep infrastructure expertise, while the platform itself enforces governance policies consistently across all domains. The integrated data security demo illustrates how these access and governance layers can work together in practice.
Common pitfalls when building sovereign data architectures
Several patterns consistently cause problems in public-sector data architecture projects, and most of them are avoidable with early planning.
Treating sovereignty as an afterthought. Organisations that bolt on access controls and audit logging after the architecture is built typically end up with gaps. Sovereignty needs to be a design constraint from the start, not a compliance checkbox at the end.
Centralising too aggressively. The instinct to build a single, central data lake for all agencies often creates a governance nightmare. When everything is in one place, access control becomes complex, data ownership becomes unclear, and the platform becomes a bottleneck. Federated architectures are harder to build initially but far more manageable at scale.
Underestimating operational complexity. Open-source tools are not self-managing. Running Apache Spark™, Apache Kafka®, and Trino in production requires operational expertise. Teams that underestimate this end up with platforms that work in demos but struggle under real workloads. Infrastructure-as-code and operator-based deployment patterns significantly reduce this burden, but they do not eliminate it.
Ignoring interoperability standards. Public-sector data sharing only works if different systems can exchange data reliably. Choosing open formats and standard APIs from the beginning avoids painful migration work later and supports the kind of cross-agency collaboration that makes sovereign data sharing valuable in the first place.
Practical steps to deploy a sovereign data-sharing platform
Building a sovereign data-sharing platform is a multi-stage effort. The following sequence reflects what tends to work in practice for public-sector organisations starting from a complex existing environment.
- Define your sovereignty requirements explicitly. Document which data must stay within specific jurisdictions, which regulatory frameworks apply, and what audit evidence you need to produce. This shapes every subsequent architectural decision.
- Choose open formats and open-source components. Commit to open table formats like Apache Iceberg, open messaging standards, and open-source query engines. This protects future flexibility and supports auditability.
- Deploy on Kubernetes with infrastructure-as-code. Use a Kubernetes-native deployment model so that your platform is portable, reproducible, and consistently configured across environments. Every configuration change should be version-controlled.
- Implement Policies as Code from day one. Define access governance rules as code, not as manual configurations. This makes policies auditable, testable, and consistently enforced across all domains.
- Start with one domain, then federate. Rather than trying to onboard all departments simultaneously, start with a single domain that has clear data ownership and a motivated team. Use that experience to refine the self-serve platform before scaling.
- Build observability in from the start. Structured logging, metrics, and alerting are not optional extras. They are the evidence layer that makes compliance audits possible and operational issues diagnosable.
A data lakehouse demo using Apache Iceberg, Trino, and Apache Spark™ gives a concrete starting point for understanding how these components fit together in a working architecture.
How Stackable supports sovereign data-sharing architectures
The SDP is built specifically for the kind of architecture described in this post. It is a modular, Kubernetes-native data platform that runs entirely on open-source components, with no proprietary lock-in and no dependency on a specific cloud provider.
For public-sector organisations building sovereign data-sharing infrastructure, the SDP provides:
- Kubernetes-native operators for Apache Kafka®, Trino, Apache Spark™, Apache NiFi, and other core data components, all managed through infrastructure-as-code
- A fully traceable software supply chain, so every component can be audited and verified
- Support for Policies as Code and federated governance, aligned with data mesh principles
- Cloud-agnostic deployment, meaning the platform runs in your own data centre, in any cloud, or in a hybrid environment, without modification
- A community edition with all core modules included, and commercial support subscriptions for organisations that need guaranteed response times and expert guidance
Stackable is made in Germany and built with European data sovereignty requirements in mind. If you are evaluating options for your public-sector data architecture, explore the platform solutions overview or get in touch with the team to discuss your specific requirements.
Related Articles
- How do you design a sovereign data platform for multiple departments or organisations?
- What does data sovereignty mean for cross-border data collaboration in Europe?
- Trino and Spark: when to use which in a data lakehouse?
- What is a data lakehouse architecture?
- What is a data platform migration checklist?