Data Mesh: Why It's Not Working (and How to Fix It) - Part 2

“Reshuffling your org chart without upgrading your infrastructure is rearranging deck chairs on the Titanic.”

Data mesh is still failing — not because its vision was flawed, but because the tech underneath it hasn’t kept up.

In Part 1, we covered the cracks: fractured domains, failed handoffs, policy without enforcement. Now we’ll explore what it actually takes to make domain ownership real — and how AprioriDB is building that foundation.

📐 Who is this post for?

• Data architects and platform engineers
• Data leaders and CDOs
• Domain teams frustrated by central bottlenecks
• Organizations struggling with data mesh implementations

…who want to understand the technical foundations needed to realize the data mesh vision.

TL;DR

• Data mesh is breaking on infrastructure, not intention.
• Five missing capabilities keep domain teams from operating independently and safely.
• AprioriDB builds these in natively: versioning, consistency, lineage, publishing, and governance.
• The result? Trustworthy autonomy — not just distributed chaos.
• You can’t federate responsibility without the systems to support it.

📚 What We’ll Cover

1. 🔍 The Essential Infrastructure for True Domain Ownership
2. 🚀 Building the Foundation for Domain Orientation
3. 📝 Contracts: The AprioriDB Superpower
4. ⏭️ What About Semantic Layers?
5. 🚗 Joining the Journey
6. ⏰ Taking Action Now

(If you haven’t read Part 1, we recommend starting there for context on the data mesh vision and implementation challenges.)

What’s Actually Missing?

Reorgs won’t save you if your platform can’t support domain ownership.

The hard truth is that most data stacks were designed for centralization — and it shows. To make data mesh real, you need infrastructure that doesn’t just accommodate domains, but assumes them.

Here are the five capabilities every domain-oriented system must have — not as bolt-ons, but as built-ins.

🔍 The Essential Infrastructure for True Domain Ownership

Versioning? Like software.

Domain data products need real version control — semantic tags (MAJOR.MINOR.PATCH), discoverability, and automated compatibility checks. Producers and consumers should be able to negotiate changes without side-channel coordination or risky assumptions.

Consistency across domains? Non-negotiable.

Cross-domain views fall apart without guarantees. You need temporal consistency (same point in time), semantic alignment (shared concepts), and version compatibility. Otherwise, every integration becomes a gamble — or a cover-up.

Lineage? Don’t make it optional.

Every value should carry its own receipt. Cell-level lineage, automatic citations, and inconsistency detection turn “unexplainable” issues into traceable events. If you can’t see where a number came from, you can’t trust it — and neither can anyone else.

Publishing? It’s a real release process.

Domain autonomy doesn’t mean cowboy deploys. Changes need staging, validation gates, and safe rollback paths — just like code. These aren’t rituals; they’re how you protect downstream consumers while shipping fast.

Governance? It has to stick.

Policy docs don’t enforce anything. Infrastructure must. That means automated standard checks, auditable data history, and cross-domain coordination baked into the platform. Without that, governance is just wishful thinking.

Federalism isn’t free; it takes the right technology to enable it.

🚀 Building the Foundation for Domain Orientation

AprioriDB: Built for Trust at the Edge

We didn’t retrofit a warehouse. We started over.

AprioriDB is infrastructure designed from first principles to make domain autonomy safe, observable, and interoperable.

That means:

• Version-first storage: Every value, every change, every version — permanently tracked.
• Native coordination: Domains can evolve independently, without breaking each other.
• Trust by default: Lineage, validation, and contracts baked into the core.
• Built-in publishing: Promote with confidence. Roll back with ease.

This isn’t a better control plane. It’s a new substrate.

Breaking the Implementation Walls

We’re not just checking boxes. We’re solving the actual problems.

🧱 The Domain Consistency Wall

Most tools overwrite. We remember.

• Semantic versioning and immutable history preserve integrity as domains evolve.
• Schema changes come with impact reports, not blind guesses.

Schema Evolution That Doesn’t Break Things AprioriDB maps the full dependency graph, alerts affected teams, and shows exactly what changes break what. And if you need to ship anyway? Fork safely, test collaboratively, then merge once everyone’s ready.

🔗 The Cross-Domain Integration Wall

Cross-domain joins shouldn’t feel like Russian roulette.

• AprioriDB ensures temporal and semantic alignment across data products.
• Dependencies are tracked and resolved automatically.
• Shared context, not shared Slack threads.

🛠️ The Self-Service Platform Wall

No more “self-service” that still pings the platform team.

• Governance guardrails are built in — not bolted on.
• Domains publish safely with standardized workflows.
• Compatibility checks run automatically. No guesswork.

📦 The Undefined Products and Contracts Wall

Data products aren’t just tables with fancy names.

• AprioriDB makes contracts enforceable, versioned, and machine-readable.
• SLAs are real — not wishful documentation.

🧑‍⚖️ The Federated Governance Wall

You don’t need a central team to enforce standards — if your system can do it.

• Automatic policy enforcement
• Auditable data history
• Trust-but-verify mechanisms across domain lines

📝 Contracts: The AprioriDB Superpower

Old-school contracts assume perfect schemas. Real organizations aren’t that tidy.

AprioriDB shifts the model:

• Semantic transparency: See the logic, not just the shape.
• Lineage for interpretation: Understand how numbers were made — not just what they are.
• Forking and merging: Manage changes without blocking or breaking.
• Contextual quality: Producers see exactly how their data is used — and why it matters.

Instead of policing boundaries, we enable negotiation — with the infrastructure to make it safe.

⏭️ What About Semantic Layers?

Current semantic layer technologies like dbt, Looker, or AtScale function as meta-code - they’re essentially inputs into code generation engines that produce SQL or other queries. This approach creates several critical limitations:

• Meta-Code vs. Real Code Drift: The abstractions in semantic layers can drift from the actual code being executed, creating hidden discrepancies
• Black Box Transformation: The actual transformations become hidden inside the tool’s code generation layer
• Limited Granularity: Most semantic layers operate at the table or column level, not at the cell level where real business meaning lives
• No True Historical Preservation: Semantic definitions change over time with limited or no version control

AprioriDB’s Source-of-Truth Approach

Rather than adding another layer of abstraction, AprioriDB preserves and exposes the reality:

• Real Code Preservation: We capture and maintain the actual code that produced every data product - every version of every edition of every publication series
• Cell-Level Lineage: Tracking flows down to the individual value level, not just table or column relationships
• Perfect Historical Reproducibility: Any past state can be perfectly reproduced with the exact code and data that created it
• Transparent rather than Abstract: The system prioritizes visibility into what really happened, not conceptual models of what should happen

This commitment to reality over abstraction enables the trust necessary for true domain autonomy.

🚗 Joining the Journey

We’re building AprioriDB because we believe the vision of domain-oriented data is too important to fail due to infrastructure limitations. But we can’t build this alone.

If you’re:

• Struggling with data mesh implementation barriers
• Frustrated by the gap between centralized infrastructure and domain orientation
• Passionate about building truly trustworthy data systems
• Excited about the potential of domain ownership with organizational coherence

We’d love to connect with you. Whether as design partners, early adopters, or collaborators, we’re looking for people who share our vision of empowered domains built on trustworthy foundations.

Reach out at jenny@aprioridb.com to join us on this journey.

⏰ Taking Action Now

Maybe you can’t wait for AprioriDB. Maybe you need to take action now.

Whether you’re just beginning your data mesh journey or struggling with implementation challenges, here are three concrete steps you can take today:

1. Assess your technology stack against the five fundamental capabilities we’ve outlined. Where are the gaps that might be preventing true domain autonomy?

2. Look for workarounds that teams have created to compensate for missing infrastructure. These are your clues to what’s really needed.

3. Start a conversation about whether your organization is addressing both halves of the data mesh equation — not just the organizational structure, but the technical foundation it requires.

And if you’re building data infrastructure or designing data platforms, consider how these principles might reshape your approach. The organizations that solve these challenges will define the next era of data architectures.

📣 I’m passionate about creating the conditions for true domain ownership in data. If you’ve experienced the challenges we’ve discussed or want to help build the solution, I’d love to hear from you.

Written by Jenny Kwan, co-founder and CTO of AprioriDB.

Follow me on Bluesky and LinkedIn.

What do you think?

• Which of these missing capabilities would have the biggest impact in your organization?
• Do you see value in building these capabilities as foundational rather than add-ons?
• What would true domain ownership unlock in your organization?

Share your experiences and thoughts in the comments below. 👇