Data platforms · Scale

Data contracts: a practical playbook for pipelines that stop breaking

Most data incidents start with a change nobody told the consumers about. Data contracts make the interface between producers and consumers explicit and checkable. Here is how I introduce them without a big-bang programme.

PlaybookSumanta Mukhopadhyay7 min read6 sources
#data#platform#governance#ai
PLAYBOOK · DATA PLATFORMS · SCALE21 Oct 2026 · 04:30 GST

A familiar incident: an application team renames a column, or changes a status code from a number to a string. Their tests pass. Two days later the finance dashboard is wrong, a machine learning feature has gone null and an executive is asking why. Nobody did anything unreasonable. The interface between the application and its data consumers was simply never written down.

Data contracts fix that by treating data like an API: documented, versioned and checked.

What a contract contains

The Open Data Contract Standard, maintained by the Bitol project under the Linux Foundation, gives a useful vendor-neutral structure. Version 3 covers a contract's fundamentals, schema, data quality rules, servers, ownership, SLAs and support channels, and extended support beyond relational tables to hierarchical, streaming and unstructured data13. Version 3.1.0 added executable SLAs, relationships between properties and stricter validation, while keeping v3.0 contracts valid2.

SectionQuestion it answers
SchemaWhat fields, types, keys and nullability can consumers rely on?
SemanticsWhat does each field mean, in business terms?
QualityWhat checks must the data pass, and what happens when it doesn't?
SLAHow fresh and available is it?
Ownership and supportWho owns it, and how do consumers raise problems?

A standard format matters less for the first contract than the tenth. Once contracts are machine-readable, catalogues, quality tools and CI checks can all read the same file.

The playbook

  1. Start where it hurts. Pick the two or three datasets behind recent incidents or critical reports. Don't try to contract the whole estate.
  2. Write the contract with both sides in the room. The producer knows what the data is; consumers know what they depend on. The contract is the overlap.
  3. Put it in the producer's repository, next to the code that emits the data, so changes to both are reviewed together.
  4. Fail breaking changes in CI. A pull request that removes a field, narrows a type or changes a key should fail before merge, as practitioners recommend45.
  5. Version intentionally. Additive changes such as a new nullable field are minor versions. Breaking changes get a new major version, run in parallel with the old one for an agreed deprecation window5.
  6. Check quality and freshness at runtime, against the same contract, and route failures to the owner named in it.
  7. Publish contracts in the catalogue, so consumers discover data through its contract rather than by browsing tables.

The contract only works if a breaking change actually fails a build. A contract that lives on a wiki page is documentation, and documentation drifts.

Where contracts sit in the architecture

Contracts are most valuable at the boundaries: where operational systems publish events or change streams, as in change data capture and event streams, and where curated datasets are shared between domains. They pair naturally with table formats that track schema and lineage, such as Apache Iceberg v3, and with semantic definitions from an ontology or semantic layer, which give fields meaning beyond their types.

Why AI raises the stakes

AI systems consume data silently. A dashboard with a broken number may get noticed; a retrieval index or a model feature fed malformed data often doesn't, and the model presents the result fluently. Contracts on the data feeding features, training sets and retrieval indexes are an inexpensive guard against that kind of quiet failure. The Bitol community is also working on making contracts more useful to AI consumers, though that work is still in progress6.

Common objections

  • "It slows producers down." Only for breaking changes, which is the point. Additive changes flow through.
  • "We have too many datasets." Start with the critical few. Coverage grows as teams see incidents drop.
  • "Our tools are different." A standard, machine-readable format is what lets different tools share one definition.

How I can help

I design data platforms where reliability is built in, from contracts and CI checks to catalogues and quality monitoring. As a fractional CTO I can lead the rollout across teams. Or analyse your challenge and bring the result to a call.

References
  1. 1
  2. 2
  3. 3
    Open Data Contract StandardData Contract documentation
  4. 4
  5. 5
  6. 6
FAQ

Common questions

What is a data contract?

A written, agreed and checkable description of the interface between a data producer and its consumers: schema, meaning, quality expectations, service levels and how changes are handled.

What is the Open Data Contract Standard?

ODCS is an open, vendor-neutral YAML standard for data contracts maintained by the Bitol project under the Linux Foundation. Version 3 covers fundamentals, schema, data quality, servers, ownership, SLAs and support, and v3.1.0 added executable SLAs and relationships.

How are data contracts enforced?

Typically in CI: a change that would break a contract's schema fails before it merges. Runtime checks then validate quality and freshness, and versioning with a deprecation window handles intentional breaking changes.

Keep reading

Related

Open to advisory, fractional CTO & select builds

Let's talk about what you're building.

The fastest route is a free 30-minute call. Prefer to write? Send a message and I'll reply personally within two business days.

Start a conversation

How would you like to reach me?

Book a 30-min callFastest. Pick any open slot on my calendar.→ Write in GmailOpens a pre-filled draft in your browser.→ Use my email appOutlook, Apple Mail or your default client.→

I reply personally within two business days. US & UAE time zones.