A Data Product Can Be Well Described and Still Mean Nothing
There’s a gap I keep running into in data product programs. The catalog is tidy. Every product has an owner, a description, an endpoint, and a lifecycle status. You can find things. Then an agent pulls “active customers” from two well-documented products, gets two different numbers, and nothing in the catalog explains why.
The catalog described the packaging. It never described what was inside.
That’s the job split this article is about. DPROD, the Data Product Ontology, is an OMG specification for describing data products in a machine-readable way. Version 1.0 is published, still marked beta. The Knowledge Spine is an architecture for holding and resolving what the business means. People sometimes ask me which one to pick. That’s the wrong question. Used together, they cover each other’s blind spots, and the result is a product a person or an agent can find, trust, and use correctly.
Below is how I’d build that, step by step.
What DPROD Gives You, and What It Leaves Open
DPROD comes out of the Enterprise Knowledge Graph Forum and is built as a profile of DCAT, the W3C vocabulary for data catalogs. That choice matters. It means a data product description is linked data from the start, not a row in a proprietary catalog.
The core shape is simple. A data product has an owner, a purpose, and a lifecycle status. It exposes output ports and consumes input ports, and each port is a DCAT data service: an API, a database, a file share. A port serves a distribution, which is a concrete format like JSON or Parquet. A distribution is a representation of a dataset. Lineage falls out of the ports: one product’s input port points to another product’s output port, and for finer detail the spec suggests PROV-O. Governance hooks are built in too. ODRL policies express usage rights down to the column level, and each dataset can carry an information sensitivity classification. Conformance is checked against SHACL shapes the spec publishes.
That’s a lot of useful structure. But notice where it stops. When it comes to what a dataset actually means, DPROD points outward. A dataset “conforms to” a logical model, and the spec recommends existing standards like FIBO or CDM, or your own SHACL shapes if none fit.
In other words, DPROD is deliberately silent on business meaning. It gives you a slot labeled “the model this data conforms to” and trusts you to fill it with something real. In practice it often gets a link to a schema document, or stays empty.
What the Spine Adds
The Knowledge Spine is what goes in that slot, made operational. It’s the enterprise ontology instantiated on a semantic platform and connected at query time to the lakehouses, domain graphs, and documents that hold the actual data. Every consumer, human or machine, resolves meaning through it.
Three things make it different from a logical model sitting in a repository.
It holds more than data definitions. The same model describes the processes, decisions, actions, and rules that act on the data. A data product’s purpose can point to the decision it supports, not just to a sentence of prose.
It’s bound to real assets. Each concept is linked to the tables, fields, and documents where it actually lives, and those bindings are tested. When a source changes, the spine knows which concepts, and which products, are affected.
It stays current. The spine has a metabolism: drift detection, versioned releases, a suite of real questions run on every change, and a named owner for every contested definition. A logical model referenced by URL ages quietly. A spine is built to notice when it’s aging.
DPROD tells you what a product is and how to get it. The spine tells you what the product’s data means and keeps that true. You need both answers.
How They Fit
The two meet in two places. The product’s purpose points to a decision modeled in the spine, and its dataset conforms to a shape built from governed concepts. Consumers find products through the catalog and resolve what they mean through the spine.
Step 1: Start With a Question and the Product That Answers It
The first instinct in a data product program is to inventory what exists and wrap each source as a product. Resist it. A product built around a table is a table with a nicer label.
Start where the spine starts: one real business question with a named sponsor who cares about the answer. For the running example here, take a procurement question: “What is our total exposure to this supplier, across contracts, open obligations, and recent risk events?”
That question tells you three things at once. It tells you which concepts the spine has to model: Supplier, Contract, Obligation, Risk Event, and how they relate. It tells you which sources hold the data: the procurement system, the contract repository, the ERP, a risk feed. And it tells you what the product is: a Supplier Exposure product whose purpose is to support a named decision, such as approving a new contract or renewing an existing one.
Write the question down as a competency question, along with the answer you’d expect for two or three suppliers you know well. That becomes the first test, and you’ll come back to it in Step 4.
Step 2: Model the Meaning in the Spine First
Before you describe a single product, model the concepts the question needs. Order matters here. If you describe products first, each product team invents its own idea of “supplier,” and the catalog ends up recording the disagreement in a standard format.
The modeling itself doesn’t have to be slow. Have an LLM draft candidate classes, relationships, and definitions from your existing schemas and glossaries. Then have the domain experts review the draft and cut it to what the question needs, usually 15 to 30 classes. Add SHACL constraints from day one: a supplier has exactly one legal identifier, a contract has at least one counterparty, an obligation belongs to a contract.
Solve identity at this stage too. The same supplier will show up under different IDs in procurement, the ERP, and the risk feed. Give each real-world supplier one IRI in the spine and link the source IDs to it with owl:sameAs. Products will refer to suppliers by that IRI, never by a raw source key.
Where an industry standard fits, align with it rather than competing with it. In financial services that usually means FIBO. The spine’s Supplier class can extend or map to the relevant FIBO concepts, so a product that “conforms to” the spine also, transitively, speaks the industry standard.
Finally, decide ownership. The central spine team owns the small set of shared concepts and the identity layer. The procurement domain owns the supplier definition and the mappings from its own systems. Write those owners into the model.
Step 3: Describe the Product in DPROD and Bind It to the Spine
Now describe the product. This is where the two fit together, and the joint is one property: the dataset’s conformsTo points at the spine, not at a document.
Here’s a condensed version of the Supplier Exposure product. The ex: and spine: namespaces are illustrative; the DPROD, DCAT, and Dublin Core terms come from the spec.
@prefix dprod: <https://www.omg.org/spec/DPROD/dprod/> .
@prefix dcat: <http://www.w3.org/ns/dcat#> .
@prefix dct: <http://purl.org/dc/terms/> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix ex: <https://example.com/products/> .
@prefix spine: <https://example.com/spine/> .
ex:supplier-exposure a dprod:DataProduct ;
rdfs:label "Supplier Exposure" ;
dprod:purpose spine:ContractApprovalDecision ;
dprod:dataProductOwner spine:ProcurementDomain ;
dprod:lifecycleStatus <https://www.omg.org/spec/DPROD/data/lifecycle-status/Consume> ;
dprod:outputPort ex:supplier-exposure-api .
ex:supplier-exposure-api a dcat:DataService ;
dcat:endpointURL <https://api.example.com/supplier-exposure> ;
dprod:isAccessServiceOf ex:supplier-exposure-json .
ex:supplier-exposure-json a dcat:Distribution ;
dct:format <https://www.iana.org/assignments/media-types/application/json> ;
dprod:isDistributionOf ex:supplier-exposure-dataset .
ex:supplier-exposure-dataset a dcat:Dataset ;
dct:conformsTo spine:SupplierExposureShape .
Three lines carry most of the weight.
dct:conformsTo spine:SupplierExposureShape says the dataset’s meaning is defined by a SHACL shape in the spine, built from the governed Supplier, Contract, Obligation, and Risk Event classes. Anyone can follow that link and get the actual definitions, constraints, and owners.
dprod:purpose spine:ContractApprovalDecision ties the product to the decision it exists to support. The decision is modeled in the spine too, with the policy that governs it. That turns “purpose” from a sentence into something an agent can reason about. DPROD doesn’t require this, and most teams write purpose as a short description. Linking it to a modeled decision is an extension I’d recommend.
dprod:dataProductOwner spine:ProcurementDomain points the owner at an entity the spine already knows, so ownership of the product and ownership of the meaning line up.
The product doesn’t copy supplier data into a new store to do this. Its output port is served by the spine’s query layer, which resolves the bound sources at query time.
Step 4: Validate Both Layers, and Validate Them Differently
You now have two things to test, and they fail in different ways.
The product description can be wrong in structure. An output port with no endpoint, a distribution that serves no dataset, a missing owner. DPROD publishes SHACL shapes for exactly this, so run them on every product description in CI. That check is cheap and should block a release.
The product’s data can be wrong in meaning, and that’s the failure that hurts. The description is valid, the endpoint answers, and the numbers are quietly off because a source field was repurposed last month. Structural checks will never catch it.
That’s what the competency question from Step 1 is for. Write it as a SPARQL query against the product, with the known answers for your two or three reference suppliers. Run it on every product release, every spine release, and every schema change in a bound source. If a renamed field breaks the binding, the test fails before a consumer sees a wrong number.
Over time, grow that set into a regression suite: the real questions consumers depend on, each with its expected answer. It doubles as documentation. A new team can read the suite and see exactly what the product promises.
If you let agents maintain bindings, and at scale you’ll want to, this suite is what makes it safe. An agent can propose a mapping update after a source change, the tests verify it, and it merges. A change to what “supplier” means doesn’t merge on test results alone. It goes to the named owner.
Step 5: Govern Ownership, Policies, and Lifecycle in One Place
DPROD gives you the governance vocabulary. The spine gives that vocabulary something to hold on to.
Ownership. The product owner in DPROD is accountable for the product through its lifecycle. The steward in the spine is accountable for what the concepts mean. Often that’s the same domain, and it should be recorded as the same entity. When they differ, for instance a shared Supplier concept used by a product owned by finance, the split is explicit instead of assumed.
Access policies. DPROD lets you attach ODRL policies at the product, dataset, service, or column level, and tag datasets with a sensitivity classification. Define those policies against spine concepts rather than physical columns. A rule like “supplier bank details are restricted to treasury” is written once against the concept and enforced wherever that concept is served, including through an agent acting on someone’s behalf. When a source renames the column, the policy still applies, because it was never bound to the column name.
Lifecycle. DPROD’s lifecycle states run from ideation through design, build, and deployment to consumption, following the EDM Council’s CDMC framework. Link them to the spine’s versioning. When a concept a product depends on gets a breaking change, the spine’s deprecation window should show up as a status change on every affected product, with lineage naming the consumers who need to migrate.
Lineage. DPROD’s port-to-port links give you product lineage. The spine’s bindings give you concept lineage: which field in which system backs which concept. Together they answer the auditor’s question end to end, from a number in a report back to the source record and the definition that applied at the time.
Step 6: Serve Products to People and Agents
Because DPROD descriptions are DCAT, they publish naturally into a catalog, and the spec is explicit that this enables federated search across catalogs with one query structure. That’s the discovery side. A person or an agent searching for “supplier exposure” finds the product, its owner, its status, and its endpoint.
The spine handles the step after discovery, which is where most catalogs leave the consumer on their own. Having found the product, the consumer needs to know what its fields mean, which definition of supplier applies, and whether it can combine this product with another one. Because the dataset conforms to spine concepts, those answers are one hop away.
For agents, expose both through the same door. In my own work that door is an MCP server in front of the spine. An agent can ask which products cover a concept, read a product’s DPROD description, look up the definitions it conforms to, and query the data, all with the same identity and access rules. The agent doesn’t need a separate integration per product, and it never has to guess whether two products mean the same thing by “supplier.” The spine already says.
This is also where the combination starts paying for itself. When two products both conform to spine concepts, joining them is a matter of following shared identities, not a new integration project. The tenth product should cost far less than the first, because most of what it needs is already modeled.
Where Teams Go Wrong
A few patterns come up again and again.
Describing products before modeling meaning. You get a beautifully standardized catalog of incompatible definitions. Model the shared concepts first, even if it’s only the 15 to 30 the first question needs.
Pointing conformsTo at a PDF. It satisfies the property and helps nobody. If a machine can’t follow the link and get a definition, the product isn’t really described.
One product per table. That’s a re-labeled source system. A product should exist because a question or decision needs it, and its purpose should name that decision.
Copying data into the product. Every copy is another place for meaning to drift. Serve the product through the spine’s query layer and let the sources stay authoritative, except where latency or heavy reasoning genuinely require materializing.
Testing only the description. DPROD’s shapes tell you the product is well formed. They can’t tell you its numbers are right. Without competency questions running against live data, you’ll find out from a consumer.
Writing policies against columns. Columns get renamed. Concepts don’t, or when they do, it’s a versioned release. Bind access rules to the concept.
The Packaging and the Contents
DPROD solves a real problem well. It gives data products a standard, machine-readable description built on linked data, with ownership, lineage, lifecycle, and policy built in. Any organization serious about data products should be using something like it.
But a standard description of the packaging doesn’t tell anyone what’s inside. That’s the part the spine is for: a governed, tested model of what the business means, bound to the real systems where the data lives and kept current as those systems change.
Build them in that order. Start with a question, model the meaning in the spine, describe the product in DPROD, and make conformsTo point at something a machine can actually follow. Then test the meaning, not just the shape. Do that and your products will be findable, understandable, and safe for people and agents to use.
One test before you start: if someone followed every conformsTo link in your catalog today, how many would lead to a definition a machine could actually use?
Sources
- DPROD specification versions (opens in a new tab), Enterprise Knowledge Graph Forum
- DPROD 1.0 specification (opens in a new tab), Enterprise Knowledge Graph Forum
The Knowledge Spine series: Part 1 (the backbone), Part 2 (the blitz), Part 3 (the living spine), Part 4 (the balance sheet), Part 5 (the agentic spine), Part 6 (nobody is coming to curate), Bonus (the field manual). This instalment is applied: what it takes to put a data product on top of the spine.