Provisa / An opinionated view

Why data management keeps failing

Forty years of advances in data management share a common failure: each one added a piece of what an organization needs, and none assembled the pieces into one model that fuses governance, meaning, the data itself, and access. The result is estates held together by integration projects that never quite close. AI shows the gap plainly: an agent handed data with no fused meaning, ownership or governance exposes the seams at once. The approach here is a methodology: semantics drives every decision about data management.

Each generation added a piece

  • Data warehouses (Inmon, Kimball): one integrated store with meaning encoded in a schema; access still scattered across tools, and governance added afterwards.
  • Big data and data lakes (Hadoop, object stores): scale without limits; meaning and governance were left behind.
  • Data catalogs and governance tools: meaning documented, policies recorded; neither bound to the data nor enforced at query time.
  • Semantic layers and metrics stores: shared metric definitions for BI; a thin slice of meaning covering only aggregations, with no model of who owns what or what the terms mean.
  • Ontologies and knowledge graphs (the first failure mode): formal meaning, relationships and reasoning, built as an end in themselves; rarely tied to operational records, and valued by assumption rather than measurement.
  • Data mesh: domain ownership and federated computational governance over existing systems, deliberately without a runtime; data products were its more enduring outcome, a packaged dataset with an owner and a contract. Each product carries its own meaning and governance, so a catalog of products repeats the fragmentation one level up instead of fusing meaning, governance, data and access into one model.
  • Operationally focused ontologies (the second failure mode, e.g. Foundry, Fabric): an ontology bound to data, driving applications inside the platform over its own connectors rather than standard protocols; scales technically, not organizationally. Operations as code, not declared primitives; controls without stewardship of meaning, and no method to prove, refine or resolve ambiguity.

The last two entries show two ways an ontology fails: the first built concepts as an end in themselves, never tied to records, valued by assumption; the second tied to data and operational, but with no method to prove a term, refine it, or resolve ambiguity. None of these approaches creates a single model that scales organizationally and technically, reinforces itself, and outlives the technology of the moment (today that is AI). The opinions below answer both failure modes.

The opinions behind the model

A concept without a binding is documentation. A term defined in a glossary tells you what "customer" should mean. Without a link to the column that holds the customer ID, the definition and the data have no relationship to each other. You can read one without the other, and so can an agent. A concept earns its place in the model by reaching data, directly or through other concepts. Until then, it is a draft. What grounding means in practice.

The model governs reality; it does not contain it. Sources stay where they are. Pipelines are not the answer; interfaces are. A platform that processes data to govern it creates a copy and a latency; it also fuses the governance with the platform, so replacing the platform means replacing the governance too.

It pays off on day one. One domain, one steward, one concept, bound to existing records. That is enough to govern one slice of the organization from the first day it is declared, without a rebuild, a migration, or a platform project first. Start there.

Domain boundaries are hypotheses: the five whys of data. When something breaks, most organizations reach for a new system, a new team, or a new layer. Before that, stop at the first question whose answer is no:

  1. Is the meaning right? It may be inaccurate, ambiguous or missing. If not: refine the meaning.
  2. Do the registered relationships explain the gap? If not: refine the relationships.
  3. Does ownership explain it? If not: realign the boundary or reassign the steward.
  4. Is the relevant reality inside the model at all? If not: expand the boundary.
  5. Only then: create a new concept or build something new.

The model compounds. Each new domain binding opens query paths to every relationship that crosses into it; each new relationship multiplies what those paths can traverse. A pipeline estate adds one capability per pipeline; the model connects existing ones.

Its value is measured, not assumed. An ontology that exists as a de facto good gives you no way to know whether it is working. Grounding is measurable: which terms reach data and which are approved but reach nothing. The latter are invisible to agents and queryable as a finding. That is the start of a measurement practice, not the end of one.

Provisa as an attempt

Each opinion above corresponds to something in the model. Grounding is computed from the live model and shown on every term, so a steward can see at a glance whether their concept reaches data. The ontology links concepts to columns, to relationships, and to each other, with domain stewards as the accountable owners. Access control (row-level security, column masking, role inheritance through the domain hierarchy) is compiled into every query plan, so governance is not a layer applied to a copy but a constraint on the query itself. One model is served over pgwire, JDBC, OData, Flight SQL, GraphQL, REST, gRPC, Cypher/Bolt, SPARQL, and MCP, so existing tools connect without being rebuilt inside the platform. Derived views capture their own lineage. Commands declare write operations over governed tables.

The model matters more than the tool

The framework can be applied without Provisa: fuse governance, meaning, data and access into one model, ground concepts to records, and govern reality at the boundary rather than inside a platform. A model built this way absorbs new paradigms predictably and rapidly, in small steps or large ones; quantum computing and heavy AI regulation are two examples on the horizon. If you apply the framework with the tools you have, you get most of the value. Provisa is an attempt to make the whole thing declarative, so you do not have to implement it yourself.