A data mesh, end to end.
A working data-mesh reference: a domain of services modeling order-placement-through-shipment, each owning its data, its API surface, and its operational lifecycle, communicating through a deliberate mix of REST, gRPC, GraphQL, and Kafka — with contracts, a catalog, progressive delivery, autoscaling, and full observability.
It's organized as its own reading set — read straight through for the full build, or jump to the concept you came for.
The set
Read in order the first time. The conceptual pages (concepts, Kubernetes substrate) ground the implementation pages that follow; the anti-patterns page surfaces the failure modes to watch for; and the closing summary reorganizes everything by principle — what each delivers, and the implementation pieces that realize it.
00 The data mesh — start here
The map — what this reference builds, the reading order, and a link to each page in the set. Start here.
01 Data architectures — from pipelines to mesh
The landscape: data pipelines, data warehouses, data lakes, and data mesh — what each pattern is, the problem it solves, and why the mesh is a different kind of answer.
02 Concepts & principles
What a data mesh is, operational vs. analytical data, and Dehghani's four principles — the conceptual grounding before any commands.
03 Kubernetes as the substrate
Why Kubernetes is a natural substrate for a data mesh, and how the four principles map onto namespaces, operators, RBAC, and platform primitives.
04 Services & data products
The services, the order-service template, and the anatomy of a data product — its ports, its internal transformation, and the container image that ships it.
05 Contracts & the catalog
Versioned contracts in Apicurio and discovery plus lineage in OpenMetadata — and why a catalog is a mesh requirement, not an optional add-on.
06 The data planes
The async backbone of Kafka events and the read layer of GraphQL composing REST and gRPC — when to reach for each, and why the capstone uses all of them.
07 Progressive delivery & mTLS
Evolving a contract in the open with an Istio v1→v2 canary, and the decision to mesh selectively rather than enabling injection namespace-wide.
08 Elastic & resilient
Scaling to demand and to zero with KEDA, and the cloud-native recoverability the platform provides when things fail.
09 Observability
Seeing what the mesh is doing — metrics, distributed traces across products, and the live view of traffic between them.
10 Anti-patterns
The conceptual and organizational ways data-mesh efforts go wrong, drawn from the literature — so you can recognize them early.
11 Summary — the four principles, realized
A closing summary — for each of the four data-mesh principles, the value it delivers, the implementation pieces that realize it, and what happens without it.
12 Appendix: Running on OpenShift (CRC) locally
The same seven-service data mesh, redeployed to OpenShift Local: a Helm chart, Security Context Constraints, Routes, and the integrated registry.
What you'll need to run it
A Kubernetes cluster you can administer — the reference was developed on minikube (Docker driver, containerd) on Fedora, but anything that gives you cluster-admin on a node with enough headroom (16 GB RAM, ~16 vCPU recommended) will work. The runnable example tree ships the helm charts, manifests, scripts, and demos that bring the whole system up.
The presentation deck and *Data Mesh 101* slides live under
presentation/ in the repo, paired with the
implementation pages here.
Demos & examples
Run the reference end to end, then exercise each principle from a terminal — with callouts to Grafana, Kiali, Tempo, and OpenMetadata along the way.