Semantic Layer Series Part 1 of 6: Why Governed Metrics Become Non-Negotiable

A quarterly review opens with three teams arriving with three “active subscribers” numbers off the same source data. Two slightly different definitions: trial users in or out, profile-level or account-level. Twenty minutes of the meeting spent reconciling. The actual decision the room walked in to make goes unspoken.

That is the moment most teams stop choosing to build a semantic layer and get pushed there. The fix that comes out of that meeting is not a tool selection or a new dashboard. It is a governed semantic layer that every downstream consumer can trust. But the failure mode hiding in that sentence is the assumption that “build the semantic layer” means “pick the platform and start modelling.” It does not.

A semantic-layer team is either running a conflict-mapping exercise or running a modelling project that mistakes itself for one. Once it runs the modelling project first, the first six months are spent buying back trust against a dataset nobody uses; once it runs the conflict-mapping first, the modelling project that comes after ships against a scope the business already agreed on. The way you get there is not picking a platform first. It is the Conflict-First Rollout: four moves in order that turn the program from a technical migration into a governance product.

Why this matters now

The symptoms of a missing semantic layer are consistent across organisations: metric drift (one KPI, multiple formulas), slow delivery (every new report rebuilds measure logic), repeated reconciliation (analysts spend time proving numbers instead of analysing them), and low confidence (business users stop trusting dashboards). The biggest cost is hidden in decision latency: every leadership conversation starts with “which number is correct?” instead of “what should we do next?” By the second quarter that is happening, every analyst on the team is doing reconciliation work, and no one is doing analysis work.

A semantic layer centralises business logic in one governed model that every report consumes via live connections instead of authoring formulas locally. KPI definitions are authored once, time logic is standardised once, lifecycle filters are reusable across reports, and role-based access is managed centrally. The effort shifts from repeated report authoring to model stewardship, which is the precondition for any AI workflow that needs to consume governed metrics later.

When KPI logic is duplicated across report files, drift is unavoidable. A semantic layer consolidates logic into one governed source.

The Conflict-First Rollout

Four moves, in order. Each one is unglamorous. Skipping any of them undoes the rest.

Move 1: Start with high-conflict KPIs

What it is. Start with the 20 to 30 KPIs that trigger the most reconciliation effort. In a streaming context these typically cluster across four domains: subscriber base movement (churn rate, net adds, active base), engagement (playtime, completion rate, watch hours), monetisation (ad fill rate, AVOD impressions), and content performance.

Why it matters. The discipline here is honesty. The most painful KPIs are usually the ones the most political teams own. Migrating them first is not a comfortable conversation. It is the conversation that proves the program is real, and it produces the trust dividend in the first quarter rather than the second year.

What goes wrong without it. Teams scope the program to “migrate everything” and ship eighteen months later with nothing the business can point at. Sponsorship fades. The least controversial KPIs migrate first, the high-conflict ones never do, and the reconciliation conversations that funded the program keep happening untouched.

Move 2: Define ownership per KPI domain

What it is. Assign explicit owners for metric families. Subscriber lifecycle gets an owner. Engagement gets an owner. Ad operations gets an owner. Content performance gets an owner.

Why it matters. Domain ownership is what stops the orphan-KPI problem: without per-domain ownership, unreviewed measure edits drift back in within three months, and trust degrades silently as the model ages. A KPI without a named owner is a maintenance liability waiting to surface.

What goes wrong without it. The model ships, ownership for individual KPIs is implicit, and within three months unreviewed measure edits start drifting back in. Someone tweaks the churn formula to fix a finance request, no one writes it down, and the engagement team’s dashboard now reads differently for reasons nobody can explain in five minutes.

Move 3: Publish definitions with implementation notes

What it is. Publish a contract per KPI with seven fields: business meaning, DAX expression, data grain (daily, hourly, event), included segments, excluded segments, validation query, and last approved date. The contract turns a measure from a dataset entry into a product.

Why it matters. A measure with a contract is one the next consumer can pick up without asking. A measure without one is a phone call. The contract is also the artefact that lets a change request be reviewed against published definitions rather than against tribal knowledge, which is the difference between a governance process and a meeting culture.

What goes wrong without it. New consumers cannot tell which measure to use, two analysts produce different numbers from the same model because their assumptions about grain or excluded segments diverge, and the team that owns the model spends its time fielding “what does this measure actually mean?” requests instead of shipping.

Move 4: Move report teams to consumption mode

What it is. Report developers consume the model instead of recreating logic locally. The semantic layer is the only authorised source for KPI logic. Local measures in report files are not a violation in the policy sense; they are a tradeoff teams can make, but governance, validation, and refresh support stop at the model boundary.

Why it matters. This is where the delivery-speed gain shows up. It is also where the political work happens. Report developers have been authoring measures locally for years. The switch to consumption mode is a behaviour change, not a tool change, and the enforcement mechanism (authorised source plus support boundary) is what makes the behaviour change stick.

What goes wrong without it. Reports stay individually authored, drift continues, and the program has spent its political budget on a model nobody consumes. Both the old and new approaches coexist indefinitely, and the governance benefit erodes within a quarter.

Where I would start

If you can only do one of the four moves in your first month, do Move 1. The conflict matrix produces every downstream decision: which domains need owners, which contracts to publish first, which dashboards become the pilot. Without the matrix the other three moves are speculation. With it, the rest of the program is execution.

Move 2 (ownership) comes next, because the conflict matrix surfaces natural owners for each KPI family: the person already running the team that argues hardest about that number. Move 3 (contracts) ships once two or three pilot measures are authored, since the contract template only makes sense in the context of a real measure. Move 4 (consumption mode) is last, because behaviour change in report teams requires a model worth consuming, not a promise of one.

One MENA-flavored note

The Ramadan content cycle makes Move 3 (publish definitions with implementation notes) non-negotiable in Arabic-OTT. “Active subscribers in Ramadan” and “active subscribers across Ramadan” mean two different things depending on how the contract is written. Without an explicit grain and filter contract per KPI, every team writes its own Ramadan logic, and the post-Ramadan retrospective becomes a reconciliation meeting instead of a learning meeting.

Closing

Which of the twenty KPIs in your business are the ones nobody trusts?

If the list comes to mind in under a minute, you have your conflict-matrix scope already, and the rest of the program is execution. If it does not, the next quarterly review will produce the list for you, in a format that costs the team more than a week of analyst time. Start the matrix before the meeting starts it for you.