Deutschland-Stack | Doublecheck IT

The Deutschland-Stack is an attempt to define a common technical foundation for digital systems in Germany.

It brings together:

standards
technologies
platform components
and a shared direction for implementation

The goal is clear:
reduce fragmentation, increase interoperability and enable digital sovereignty across federal, state and local systems.

Why this matters

The current landscape is fragmented.

Different systems, formats and interfaces make integration difficult and slow down digital progress.

A shared technical foundation is a necessary step.

The focus on:

open standards
interoperability
and provider independence

is technically sound.

Our perspective

We approach the Deutschland-Stack from an operational standpoint.

Not as a policy or architecture concept —
but as something that has to work in real systems.

In practice, the relevant questions are different:

Can a system actually be moved between environments?
Can it be restored under pressure?
Can it be operated without hidden dependencies?
Can teams work with it without excessive coordination overhead?

This is where concepts become systems.

Where we see alignment

Several aspects of the Deutschland-Stack align with how we think about systems:

use of open and widely supported standards
emphasis on interoperability
reduction of vendor lock-in
integration of open infrastructure approaches such as SCS

These are necessary conditions for sovereign systems.

Where the real work begins

Defining standards is only the first step.

The critical part is what happens next.

In real systems, sovereignty depends on:

how deployments are structured
how data is stored and accessed
how systems are observed and debugged
how failures are handled
how recovery is executed

These aspects are not solved by standards alone.

They have to be implemented, tested and operated.

From model to system

The Deutschland-Stack describes systems in layers.

In practice, systems behave as chains:

Code → Build → Deploy → Runtime → Data → Operations

Sovereignty can be lost at any point in this chain.

This is where we focus our work.

Our approach

We use our own systems and platform to explore how these principles behave under real conditions.

This includes:

building reproducible deployment pipelines
operating container-based runtimes
managing data lifecycles and access paths
implementing observability across services
defining and testing recovery processes

Not as isolated components,
but as a connected system.

Testing assumptions in practice

Many assumptions around sovereignty are reasonable on paper:

open standards enable portability
APIs enable interoperability
cloud abstractions reduce dependency

In practice, this has to be verified.

We treat the Deutschland-Stack as a working model.

And we use real implementations to test:

where switching actually works
where dependencies remain
where additional constraints appear
where operational complexity increases

What we contribute

We do not define standards.

We do not design policy frameworks.

We work on the part in between:

translating principles into systems
identifying where they break
and making those points visible