When a Gold product reads tables from several teams, its job has to wait for all of them. The common ways to do that on Databricks, their trade-offs, and how LakeLogic keeps the order tied to what each product actually reads.

A single quality score can be green on the day half the data never arrived. The data product quality metrics and KPIs worth tracking, which consumer question each one answers, the tools teams use to measure them, and what LakeLogic records per run.

A data product specification written in a document template drifts from the table it describes. A copyable template in two parts: YAML that a validator and a pipeline can read, and a short Markdown page for what no machine checks. Every YAML field comes from the Open Lakehouse Contract format, and the article says which parts are checked.

Green pipeline tests prove the code does what the engineer intended. They do not prove the data product still keeps its promises. A test strategy in five layers, what each one catches, the tools for each, and where LakeLogic fits.

A version number only protects consumers if something checks it against the change. Which schema changes break readers, the ways teams version data products today, and how LakeLogic derives the minimum bump from the contract diff.

A medallion lakehouse tells you how refined a table is. It does not tell you which tables a team has promised to someone. How teams map data products onto bronze, silver and gold, the common ways to record that mapping, and a worked example where the product lists its outputs and the contracts point back.

Medallion architecture organises tables by how refined they are. A data product organises them by who promises what to whom. The two are often argued about as rivals. What each concept is, where they differ, the strongest case on each side, and how to tell which framing your estate needs.

A worked example of ownership, quality rules, lineage and personal-data retention, with clear lines between what the contract checks and what Unity Catalog enforces.

A test workspace with empty tables, or a masked copy of production nobody has refreshed in months, cannot tell you whether the platform works. The common ways to fill a non-production environment, where each fits, and how LakeLogic seeds one from data contracts without reading production rows.

A catalog per domain gives each Databricks team a clear namespace and a natural place for grants. It does not give them access isolation until you write the grants. A worked example from the RideFlow reference project.

Claude, Cursor or Copilot can write a uniqueness check in seconds. What they cannot tell you is what it would reject or who agreed to it. The common ways to govern assistant-written changes, and how LakeLogic's MCP server adds a sandbox test and a person's decision.

Row rules decide what happens to one bad record; dataset checks decide whether a whole batch is fit to use. The common ways to do both, their trade-offs, and how LakeLogic keeps the failing rule on every quarantined row.

When a data product has to run on Databricks and Microsoft Fabric, some of it can be written once and some cannot. How teams split the work today, where the business rules drift, and what a portable contract does and does not keep in sync.

A good model and a careful prompt still give a confident wrong answer when the table behind them is stale or half-loaded. Where data checks belong in an AI application, the common approaches, and what LakeLogic contracts add.

How to test that quality rules and quarantine actually work without production data: generate valid and deliberately broken rows from the contract, run them back through it, and investigate every disagreement.

A fact row that cannot find its dimension disappears from an inner join or lands on a null key. How teams handle SCD Type 2 history, late dimensions and calendar logic in Gold, and how a contract can declare the policy and count the misses.

Insurance certificates and licences arrive as PDFs and photos full of personal data. Compare the common ways to extract them, then see how a contract makes the parse deterministic, the misses visible and the personal fields explicit.

Run data contracts on Polars or DuckDB for fast feedback, then know exactly which checks still need Spark. A worked example where one regex rule passes on one engine and errors on another.

Six rows, one YAML file, two commands. See what a data contract does to bad data, where the rejected rows go and why each was rejected, before you connect anything to a warehouse.

Follow one bad trip record through a Databricks data mesh: which team owns the rule, where the failed row goes, what a batch-level limit does and does not stop, and what the platform team should not have to decide.

A right-to-erasure request turns into a hunt through every table that might hold the person. Compare the usual approaches, then see how contracts can declare personal fields, drive a dry-run-first erasure and record evidence, and what they leave to the platform.

Waiting for a Spark cluster to test one quality rule is a tax on every change. How teams iterate locally, why a local pass can still be wrong on Spark, and how one contract run on Polars, DuckDB and Spark keeps the two honest.

A shared #data-alerts channel that pings hundreds of times a day gets muted, and the one alert that matters is missed. The common fixes, their trade-offs, and how LakeLogic routes alerts from the contract's owner and folds repeats into one episode.

Language models are good at plausible values and poor at deciding what is valid. How to use AI for test data without letting it become the judge of your quality rules.

dbt model contracts, dlt schema contracts and platform expectations each guard one point in a pipeline. Where row-level rules belong, what each tool does with a bad row, and when a contract runtime at ingestion is worth adding.

A data contract is an agreement a machine can read. What the Open Data Contract Standard covers, the ways teams enforce contracts today, and where an executable contract fits.

From pipeline failure to root cause in minutes, not hours.

Catch bad data at the door, and see each rejected row with the rule it broke.

Read from cloud storage, flatten nested JSON and write results back to a bucket.

Change a rule, then reprocess past data from the raw source without double counting.

GDPR-ready pipelines: erase a person in two lines and keep the audit trail.

Run the same data contract on Polars, DuckDB or Spark, with no code changes.

Add data contracts to what you already run: dbt, dlt, streams, cloud storage and databases.

A production Bronze, Silver and Gold pipeline in one notebook, on Delta Lake or any database.

Read every event once, survive a crash, and never count anything twice.

Realistic test data that catches bugs, with no production samples needed.

The Marketplace team publishes trusted trips, drivers and riders, plus revenue, rider lifetime value and surge pricing. Start the series here.

Finance matches every Stripe charge and refund to its trip, so revenue reconciles.

Trust & Safety governs Zendesk, Checkr and Twilio data under one set of rules, with each ticket and background check linked to its driver.

Growth brings Google Analytics, HubSpot, Meta and Google Ads together, and compares ad spend with the value of the riders it won.

Company-wide KPIs built only from data the other teams have published, without touching their raw data. Builds all four teams’ data first.

Erase one rider from every team’s tables on request, with an audit-ready report (GDPR Article 17).

See the whole ride-hailing lakehouse in interactive dashboards, inside the notebook.

The open-source runtime engine for executable data contracts. Install, configure, and contribute to the project.

The definitive open-source YAML specification for data contracts. Schema, quality, and SLA in a tool-agnostic way.

Runnable reference contracts and interactive notebooks in the OSS repo: Bronze/Silver/Gold layers, quality rules, SCD2, and integrations you can clone and adapt.

How LakeLogic abstracts Spark, DuckDB, Polars, BigQuery, and friends behind a single contract execution interface.

Book a demo, get a 30-day trial of the LakeLogic Platform set up for you, then connect your data platform and see what LakeLogic finds in your estate.

The standard (OLC), the open-source engine (Core) and the LakeLogic Platform: what each does and where it runs.

Author and change a contract in Contract Studio, from fields and types to quality rules, and deliver it as a pull request.

Use Claude, Cursor or Copilot with your governed estate: assess gaps, propose a rule, test it in a sandbox, and approve it in LakeLogic.

Fowler's foundational essay on domain ownership, federated governance, and data-as-a-product. Required reading for anyone building a mesh.

A clear walkthrough of what data contracts are, who needs them, and how they fit alongside data observability.

AWS's take on data mesh architecture, with cloud-specific patterns for federated governance and inter-domain sharing.

A field guide to implementing data mesh: common pitfalls, organisational design, and the role of contracts.

A hands-on technical introduction to data contracts as a discipline. Good starting point for engineers new to the pattern.

Workshop by one of the data contracts community's founding voices. Practical patterns for rolling them out in a real org.