A self-service platform is one of the core principles of data mesh. Domain teams can only take on decentralized ownership if they are empowered to build, deploy, and manage their own data products without friction or cognitive overload. The platform supplies the abstractions, automation, and tooling that make that autonomy practical.

Data mesh concepts have to be built into the platform itself. Data contracts give teams a controlled, stable handover of data; data products serve as the unit of reusability for productized data and connect to one another to form the mesh in which ownership is distributed across domains.

Where the platform gap comes from

Assembling a complete data product draws on many technologies: compute for transformations, storage, ingestion tooling, catalogs, query engines, quality tools, and more. Examined individually, these technologies lack abstractions for concepts such as data contracts and data products. A single data product needs a combination of them to work as an integrated whole, so no one underlying technology can cover a whole data product either. That is the platform gap.

Without built-in abstractions, what a data product is and how it shows up in the technology stack becomes unclear, and teams struggle to use the underlying technologies directly, which holds back data mesh adoption.

Bridging the gap with platform engineering

The straightforward response to the gap is to engineer a platform layer on top of the existing data technologies. That layer raises the level of abstraction, lowers cognitive load, and delivers a user experience centered on data contracts and data products, with automation and integration making it genuinely self-service.

Building it is not trivial. Platform teams frequently have trouble articulating their progress, prioritizing work, and demonstrating the value of their investment. A maturity model gives them a structured way to reason about all three.

The CNCF model as navigator

The Cloud Native Computing Foundation (CNCF) has published a Platform Engineering Maturity Model through the platform engineering community. It offers a framework for assessing and advancing platform capabilities, which makes it a fitting navigator for a data mesh journey.

The model combines maturity levels with aspects that evolve as a platform matures. The levels are:

  • Provisional: an initial, ad-hoc platform.
  • Operational: a more standardized platform, centrally managed.
  • Scalable: a self-service platform that encourages adoption.
  • Optimizing: a platform that keeps improving and is deeply integrated into the development workflow.

At each level, five aspects are assessed:

  • Investment: how staffing and funds are allocated to the platform.
  • Adoption: how and why users discover and use the platform.
  • Interfaces: how users interact with and consume platform capabilities.
  • Operations: how capabilities are planned, prioritized, developed, and maintained.
  • Measurement: how feedback is gathered and incorporated to improve the platform.

Applying the model in three steps

Using the model is straightforward:

  1. Know your current state. Map the existing platform against the aspects and levels. A dedicated platform investment team, for example, puts Investment at Level 2, while Operations and Measurement might still be ad-hoc at Level 1.
  2. Focus on one aspect. With the picture clear, pick a specific aspect to improve. To make sure you are building the right features, you might invest in a platform product team and start collecting insight into users' biggest pain points.
  3. Iterate. Apply the improvements and keep adapting.

Each iteration has to balance the aspects against one another. Investment and Adoption revolve largely around people, policies, and processes; Interfaces and Operations lean more toward technology. Used as a compass, the grid can guide the next steps consciously. A team might decide, for instance, to invest in self-service solutions and automated central enablement only after a dedicated product team and user insights are in place. That ordering keeps effort from piling into one area while others are left behind, and it gives the team a clear way to communicate the reasoning to stakeholders.

Maturity Levels for Data Product Platforms

Level 1: Provisional — ad-hoc provisioning through personal networks

At the provisional level, data technology is requested and provisioned entirely ad-hoc. A first data product developer must navigate the organization through personal connections: a DevOps engineer creates a Git repository on the Git platform, a second DevOps engineer creates a CI pipeline on the CI system, and a cloud engineer creates an S3 bucket on AWS Cloud. The developer then assembles their own processing tools — an Iceberg database on an Iceberg catalog and query engine and a Spark job on a Spark cluster — into something that resembles a data product.

A second developer, with no platform documentation or self-service interface to consult, asks the first developer how to get started and is referred to the same DevOps engineers, who create another Git repository and another CI pipeline. For analytics, however, they go in a completely different direction: a dataset on Google BigQuery, a dbt model on dbt Cloud for transformations, and a view on a data virtualization tool to serve the data.

The failure modes are structural. Human bottlenecks sit at every step, since progress depends on knowing someone who knows how to do something. There is no explicit concept of a data product or data contract — only isolated, manually stitched pieces of infrastructure. The results are excessive cognitive load, deep technological fragmentation and growing shadow IT.

Level 2: Operational — centralized requests, fragmented experience

To introduce order, organizations establish dedicated infrastructure teams (for example a DevOps Team, a Cloud Team and a Data Platform Team) and channel requests through a centralized ticketing system such as Jira. Developers now file a ticket per component: a Git Repository Ticket fulfilled by the DevOps Team, a CI Pipeline Ticket, an S3 Bucket Ticket fulfilled by the Cloud Team, and an Iceberg Database Ticket and Spark Job Ticket fulfilled by the Data Platform Team.

This brings central visibility and a standardized technology catalog, but it swaps personal requests for queues and handoffs. Ticket fulfillment takes significant time, and once the components arrive the developer is still alone in gluing them into a functioning data product. Tempted by the delays and integration friction, developers often bypass the platform and manage their own shadow IT solution (“My Data Platform”).

Automation through typical Infrastructure-as-Code scripts (e.g. Terraform) can remove the ticketing system and its human bottlenecks, with each specialized team publishing reusable scripts that developers execute themselves: createGitRepository provisions a Git repository, createCIPipeline a CI pipeline, createS3Bucket an S3 bucket, createIcebergDatabase an Iceberg database, and createSparkJob a Spark job.

Ticketing delays disappear, but the integration work does not: developers must still configure and integrate networking, security roles, storage, pipelines, secrets and more. Cognitive load stays high, a knowledge bottleneck remains, and errors still send developers to the DevOps, Cloud and Data Platform teams for human help. The organization ends up with “Frankenstein” data products that look alike on the surface but are architecturally inconsistent underneath, and shadow IT persists.

Level 3: Scalable — platform as a product

The scalable level changes the developer interface entirely, replacing individual technologies with a data product-centric abstraction. A dedicated Data Product & Data Mesh Platform Team treats the platform as a product, offering a self-service Data Product Developer Portal backed by a Data Mesh Platform Backend instead of tickets or disconnected scripts.

The developer clicks 'Create Data Product' and defines the architectural specification — input and output ports, data transformation code setup, and data contracts covering structure and guarantees. The portal captures this intent and instructs the backend, which orchestrates resources across every infrastructure domain: a Git repository on Git, a CI pipeline on the CI System, an S3 bucket on AWS Cloud, an Iceberg database on the Iceberg Catalog & Query Engine, and a Spark job on the Spark Cluster. Crucially, the backend does not just spin up isolated components — it wires and glues them into a cohesive, standardized data product.

The effect on developers is substantial. Cognitive load drops because they work with the data product abstraction instead of the underlying technologies, and the knowledge bottleneck disappears because infrastructure plumbing expertise is no longer required. Because the backend enforces architectural standards, uniformity replaces Frankenstein products, and that same consistency lets the platform inject automated policy checks, audit logging, access controls and data quality verification across all data products. When creation is frictionless, adoption becomes voluntary and shadow IT is naturally discouraged.

Level 4: Optimizing — platform as an ecosystem

At the optimizing level the platform moves into the developer's daily context rather than requiring a trip to a portal. An IDE plugin or dedicated CLI makes the local tools data product aware, so developers can create, develop, deploy and monitor data products without disruptive context switching. These local tools create the data product on the centralized Data Mesh Platform Backend maintained by the Data Mesh Platform Team, which provisions and integrates the Git repository, CI pipeline, S3 bucket, Iceberg database and Spark job exactly as at Level 3.

The second defining dimension is a federated platform ecosystem in which the central team is no longer the bottleneck for new capabilities:

  • An engineer from a Domain Team can contribute a domain-specific extension, such as Platform Capability X (e.g. specialized data product templates), available to the entire organization.
  • An engineer from a Specialized Team (security, compliance or data governance) can contribute platform capabilities such as Platform Capability Y (e.g. automated PII masking, fine-grained access policies or audit logging).

Lifecycle management at this level lets the organization migrate data products when underlying technologies evolve — upgrading an Iceberg or Spark version, or absorbing breaking changes in data contract formats — without every team rewriting its data products. Tracking which capabilities and data products are actually consumed allows teams to prune unused data products and decommission obsolete platform features, continuously refining the platform.

Which maturity level a mesh actually needs

Not every point on the model can carry a data mesh. The provisional level is, in effect, chaos: there is no real platform, and domain teams either wait for resources or build their own. A decentralized, interoperable mesh cannot be assembled from disconnected, unmanaged tools.

The operational level is more organized but still a poor foundation. Cognitive load stays high and the developer experience stays fragmented, so teams must still glue the pieces together themselves. This is the typical outcome of automating the provisioning of individual technologies without addressing the overall developer experience; friction drives low adoption and shadow IT persists. Many data mesh efforts stall here because participation remains too complex and too costly for domain teams.

The scalable level is the minimum for success. The platform team shifts from an IT helpdesk into a product team centered on developer experience, closing the platform gap. Developers interact with the abstraction of a data product rather than the underlying technologies, which makes voluntary adoption realistic and enables the decentralized ownership data mesh depends on.

How adoption follows maturity

Adoption tracks maturity closely. Through the operational level, leadership must push the platform via mandates, policies and architectural review boards; engineers in large organizations route around painful tools through shadow IT, so the platform struggles. Only at the scalable level does adoption rise significantly, because using the platform becomes easier than doing it yourself — the effect described as intrinsic pull. Growth is still not automatic: the platform team must evangelize and educate. But scalable is where voluntary adoption first becomes possible, and a mesh spanning many domain teams requires it.

Investing with the model as a compass

Assessing the current maturity level exposes the aspects causing the most friction, so investment can be targeted at them. That iterative approach raises overall maturity and keeps every aspect covered. A journey rarely advances all five aspects in lockstep:

  • Step 1: All five aspects sit at the provisional level — ad-hoc technology, fragmented requests, no dedicated platform team.
  • Step 2: A common trap: teams push technology alone, building self-service interfaces and automating operations (Level 3). Adoption still lags at Level 2 because nobody communicates how easy the platform is to use, and capabilities nobody needs may get built because measurement for feedback remains ad-hoc at Level 1. Organizational enablement and feedback gathering become urgent.
  • Step 3: A course correction redirects the next investment cycle into the lagging aspects instead of more technical features: a platform-as-a-product mindset, actionable usage insights, and voluntary adoption driven by evangelizing, embedding with domain teams and refining the developer experience. All five aspects reach the scalable level — the minimum for data mesh success.
  • Step 4: Later cycles pull the platform into Level 4 by integrating capabilities into local IDEs and CLIs, enabling contributions from domain and specialized teams, and using measurements and feedback for continuous optimization.

This is one scenario among many; organizational contexts differ and may prioritize other aspects first. The model's role is to reveal what lags and to keep people, processes and technology balanced.

Balancing technology and people, and starting small

A self-service platform for data products and data mesh has to lower cognitive load sharply and be as easy to use as possible, yet it is not a purely technical project: the goal is adoption without coercion. Used as a navigator, the Platform Engineering Maturity Model shows where the platform stands today, surfaces the greatest friction, and supports small, iterated improvement steps. It also gives stakeholders a way to understand progress, priorities and the value of investments, which helps secure buy-in and funding. A practical start: bring the model to the next platform or architecture discussion, map current capabilities, pick the single area creating the most friction for domain teams, and aim the next investment cycle there. The end goal is to bridge the platform gap — from a fragmented, mandated toolchain to a user-centric self-service platform that lets teams succeed with data mesh, data products and data contracts.

Acknowledgments

The article grew out of a presentation at Data Mesh Live 2026; thanks to the audience and the conference organizers. Special thanks to Martin Fowler for attending, for the enthusiastic feedback that prompted turning the talk into an article, and for editorial guidance and hosting. Further thanks to the wider Data Mesh community, to the CNCF Platforms Working Group for the Platform Engineering Maturity Model underlying this navigator, to colleagues, and to family. All core concepts, narrative, ideas and original visual designs were authored by the presenter from practitioner experience; an AI assistant served as editorial and production aid, polishing prose and coding the SVG diagrams from initial visual drafts.

05 November 2026: published