The catalog is full. Eleven thousand assets, harvested from every warehouse, every BI tool, and most of the transformation code. The project took nine months and it worked.
And the revenue number in the executive dashboard still disagrees with the one in the finance model.
This is the most common shape of a metadata program that stalled. The harvest succeeded and nothing downstream of it did, so the organization now has a complete inventory of things it still can't reason about.
The five stages of the MetadataOps lifecycle look like a checklist. They behave like a dependency chain, and each stage that gets skipped fails in its own recognizable way, usually months later and usually blamed on something else.
Harvest without Model gives you an inventory
Harvesting produces a record of what exists. Modeling produces agreement about what it means.
Skip the second and you get the failure above. Eleven thousand assets, four columns plausibly named revenue, and no statement anywhere about which one the finance close runs on. The catalog answers "what do we have," which was never the question people were asking. They asked "what is revenue," and an inventory has no opinion.
The signature of this skip is a well-adopted catalog that people search and then leave to go ask a person.
Modeling means each business concept is defined once, has a named owner, and is bound to the specific physical assets that implement it. The binding is the part that gets dropped, because it's the slow part. A definition written in prose and attached to nothing is a glossary entry, and glossary entries don't survive contact with a disagreement.
Model without Version gives you a current answer and no history
Once definitions exist and are owned, they start changing, because business definitions always change.
Without version history, the estate can tell you what a metric means today and nothing about what it meant when the number in question was produced. Every retrospective question becomes an investigation.
The recognizable result is the reconstruction project. Two engineers, a week, and an answer eventually recovered from a Slack thread. Auditors trigger it, and so does any executive asking why a trend moved.
Version without Compile gives you a governed definition no system consumes
This is the skip that surprises teams, because everything upstream looks healthy.
Definitions are modeled, owned, and versioned in the metadata layer. Meanwhile the BI tools have their own semantic models, the transformation code has its own logic, and the AI application has its own retrieval configuration. Each one re-implements the definition independently, because that's what those systems require to run.
So the governed definition stays correct while the shipped definitions drift, each on its own schedule, and nothing watches the gap between them. At that point the governed version documents the estate. It stops controlling it.
Compile closes that gap. Governed definitions get written into the native formats of the systems that consume them, so each tool inherits the definition it consumes. The distinction is whether the metadata layer describes the estate or configures it.
The signature of this skip is an organization with strong governance artifacts and persistent number disagreements. Those two facts look contradictory and they're the expected result.
Compile without Verify gives you a system that was right once
Every stage above produces state, and state goes stale.
Schemas change. Pipelines get rewritten. Source systems get replaced. A definition compiled into six tools last quarter may now be compiled into six tools where three of the underlying columns moved.
Verification means drift detection running continuously, impact analysis before schema changes ship, and an evidence trail available when someone asks where a number came from. Without it, the organization has confidence and no expiry date on it, which is worse than doubt because it stops anyone from checking.
The signature is a governance program that passed its last review and has no mechanism to notice that it no longer holds.
Where most teams actually are
In practice, most organizations are somewhere between Harvest and Model, with a partial version history and no compilation at all.
That's a reasonable place to be. It's also worth knowing that it's the place where the AI conversation stops, because the stages that would make governed definitions reach an agent are the two that come last.
The order follows from the dependencies. Harvest determines what can be modeled. Modeling determines what can be meaningfully versioned. Versioning determines whether compilation is safe to automate. Compilation determines whether verification has anything to check.
Teams that attempt compilation before modeling end up shipping four definitions of revenue into six tools very efficiently.
Where to start
Find your last completed stage. Completed means done across the whole estate, and a stage finished for one domain sits in the roadmap column.
Then look at the failure signatures above for the stage after it. If you recognize the one that follows your last completed stage, the diagnosis is confirmed and the roadmap writes itself: finish that stage before starting anything further downstream.
Most metadata programs fail by working on stage four while stage two is incomplete. The work looks productive the whole time, the artifacts accumulate, and the results never arrive, because each stage can only be as good as the one feeding it.
Finishing in order is slower for two quarters and faster after that.
