1h 26m read

Centralised Reporting System: A Practical Guide to One Governed Number

A practical guide to centralised reporting systems: why the same KPI shows two values, the six attributes every governed metric needs, how AI agents resolve to governed definitions, an implementation sequence with checkpoints, failure modes, and testable acceptance criteria.

Centralised Reporting System: A Practical Guide to One Governed Number

Introduction

Two dashboards, one KPI, two numbers. The gap is usually small enough to argue about and large enough to matter — a few percent on revenue, a different count of active users — and the argument that follows is rarely about arithmetic. It is about which definition, which source and which filter each dashboard silently chose.

A centralised reporting system is a reporting layer in which each metric is defined once, in a shared and versioned repository, and every consumer resolves to that same definition: BI dashboards, spreadsheets, embedded analytics and AI agents. The number is produced by the platform from a governed definition rather than reconstructed by whoever built the report.

That definition makes the work an architecture and governance problem, not a tool purchase. Buying a semantic layer does not centralise anything if teams can still compute the metric themselves; publishing a glossary does not centralise anything if the calculations are untouched. What has to change is the definition, the query path that forces consumers through it, and the ownership that keeps it accurate.

This guide covers the boundaries of the term, the mechanism behind metric drift, the operational requirements of one metric and one definition, the AI-agent case, an implementation sequence with checkpoints, the failure modes that derail consolidation, and acceptance criteria you can test. It draws on semantic-layer and governance sources, vendor documentation and standards work including Apache Ossie; it does not report a deployment performed by the author.

What a Centralised Reporting System Is — and What It Is Not

A centralised reporting system is the combination of three things: a governed repository of metrics and dimensions, a query path that forces consumers through that repository, and the ownership and change-control process that keeps the repository accurate. Remove any one and the system degrades into a convention that holds until someone is in a hurry.

That definition is easier to apply once you separate it from the three products it is usually confused with.

A BI tool is a presentation and exploration surface. It renders charts, accepts filters and lets analysts drill into detail. It may read from governed definitions or it may contain its own calculations; the tool itself does not decide which.

A data warehouse is storage and compute. It holds the rows and executes the queries, but it does not by itself decide what "revenue" means. A warehouse can host a dozen conflicting definitions of the same word, all of them running correctly.

A semantic layer is the component that encodes business meaning — metrics, dimensions, joins, filters — and exposes it through an interface to multiple consumers. Semantic-layer functionality was historically embedded inside individual BI platforms. In the late 2010s and early 2020s a category of independent products emerged, described variously as a universal semantic layer, a metrics layer or headless BI, which defines metrics and data models in a central repository outside any single analytics tool and exposes them through APIs to BI applications, spreadsheets, embedded analytics and AI assistants (Wikipedia, "Semantic layer"). The reason for the split is the point: definitions had been trapped inside the tool that hosted them, so every additional tool meant another copy of the logic.

The practical consequence is that centralisation is a property of the definition and the query path, not of the number of tools you own. An organisation running four BI tools that all read from one governed repository is more centralised than an organisation running one BI tool in which every team writes its own SQL.

A shared glossary is not a shared metric. When revenue is calculated differently in two reports because each was built by a different team in a different tool, documentation does not reconcile the outputs; the number is what the platform produces, not what the glossary says it should (DigitalHive, executive reporting use case). That source also cites Datalogz (2025) for the claim that more than 67% of enterprises manage active BI sprawl — multiple tools, multiple definitions, no unified governance layer. Treat that as a third-party survey finding attributed to Datalogz, not as a measurement this guide performed.

Why the Same KPI Shows Two Different Values

Metric drift is not mysterious once you list the points where two implementations of the same KPI can diverge. They diverge in a fixed order, and diagnosing a discrepancy means walking that order rather than debating whose number feels right.

Source. Finance computes revenue from the ledger; marketing computes it from a summary table refreshed by a pipeline. Both are "revenue." Only one is reconciled to the books.

Filters. Trial users included or excluded. Internal test orders included or excluded. Refunds netted or not. Each choice is defensible; two different choices produce two different numbers.

Time logic. Fiscal periods versus calendar periods, and timezone cutoffs at period boundaries. A dashboard that closes the month at local midnight and one that closes at UTC midnight will disagree on the last day's orders.

Aggregation. Distinct users versus sessions, average order value computed per order versus per customer. The same underlying rows support several legitimate aggregations, and the label rarely says which one was used.

Refresh timing. One dashboard rebuilds nightly; another streams. Asked at 09:00, they describe different states of the world.

The compounding is what turns a small choice into a board-level discrepancy. Suppose a marketing dashboard includes trial users in its active-user count and a product dashboard excludes them. If trials are a meaningful share of signups, the two numbers differ by that share every month, and the gap widens as trial volume grows. Nobody made an error; two unstated decisions simply stacked.

The governed alternative is to make those decisions explicit before a query is generated. As Databricks describes it, a governed semantic layer underneath the language model tells the agent what "revenue" means for this team, which table is the certified source, how fiscal years are defined and which filters should always apply — so that before a single line of SQL is written, the agent already knows that net revenue uses a specific approved calculation, that it comes from a certified finance table rather than a marketing summary, that fiscal quarters start in February, and that free-trial users are excluded from retention metrics (Databricks).

Agents make the mechanism sharper because they re-derive logic rather than reuse it. Pointed at raw tables, a model re-derives business logic on every prompt, so answers drift; pointed at a semantic layer, it selects from governed definitions, queries the warehouse through the right interfaces, and returns answers that are consistent and explainable (Cube).

There is an organisational layer underneath the technical one. When no one is clearly accountable for keeping an executive dashboard current and authoritative, it drifts: filters go unchecked, calculations change without documentation, and executives keep using a report that has not reflected current business logic for months. The same source notes, attributing the finding to Forrester (2024), that most organisations have no formal process for certifying or deprecating executive-facing analytics content (DigitalHive). That is a third-party finding, not a measurement in this guide.

What "One Metric, One Definition" Requires Operationally

"One metric, one definition" is a slogan until you write down what a definition contains. Six attributes are enough to make a metric reproducible and auditable. For each governed metric, record all six.

KPI alignment and accountability, self-reported "to a high degree" (TDWI survey, 271 respondents, fielded Sept 2008) Horizontal bar chart of nine self-reported statements about KPI programmes. The highest share is 53% for KPIs aligning with strategic objectives; 31% for KPIs aligning with each other; 30% for someone being held accountable for each KPI's outcome; 27% for employees being unable to game the KPIs; 26% for measuring KPIs in an optimal time frame; 26% for employees understanding the KPIs; 21% for managers using KPIs to coach rather than penalise; 20% for having monetary incentives attached to KPIs; and 18% for employees knowing what actions to take to affect KPIs. KPI alignment and accountability, self-reported "to a high degree" (TDWI survey, 271 respondents, fielded Sept 2008). horizontal bar data: KPIs align with strategic objectives 53; KPIs align with each other 31; Someone is held accountable for each KPI's outcome 30; Employees can't "game" the KPIs 27; KPIs measured in an optimal time frame 26; Employees understand the KPIs 26; Managers use KPIs to coach, not penalise 21; Monetary incentives attached to KPIs 20; Employees know what actions affect KPIs 18.Source: Wayne Eckerson, How to Create and Deploy Effective Metrics (TDWI report), Figure 14 Survey fielded September 2008; published Q1 2009. KPI alignment andaccountability,self-reported "to a highdegree" (TDWI survey, 271respondents, fielded Sept2008) KPIs align withstrategicobjectives 53 KPIs align witheach other 31 Someone is heldaccountable foreach KPI's... 30 Employees can't"game" the KPIs 27 KPIs measured inan optimal timeframe 26 Employeesunderstand theKPIs 26 Managers useKPIs to coach,not penalise 21 Monetaryincentivesattached to KPIs 20 Employees knowwhat actionsaffect KPIs 18 Source: Wayne Eckerson, How to Create and DeployEffective Metrics (TDWI report), Figure 14 (Surveyfielded September 2008; published Q1 2009)

Self-reported survey results from 271 respondents who had partially or fully deployed a KPI initiative. Shares answering that each statement applies to their KPIs "to a high degree." The survey was fielded in September 2008 and published in 2009; these figures measure KPI alignment and accountability within that sample, not cross-tool value conflicts or current conditions.

1. A named business owner. A person accountable for the number, with the authority to approve changes and to deprecate the metric. An owner without authority to deprecate is a contact, not an owner; the metric will keep two lives because nobody can end one of them.

2. The exact formula. Numerator, denominator and aggregation, written precisely enough that two engineers implement the same thing. "Average order value" is not a formula; total net revenue divided by count of completed orders, refunds netted, is.

3. The certified source. The specific table or model the metric reads from, designated as the source of record. A formula without a source is not reproducible, because the same formula over a different table is a different metric.

4. Mandatory filters and exclusions. Trial users, internal orders, test accounts, refunds, duplicate records — each stated explicitly rather than left to the report builder's judgment.

5. Refresh cadence and data latency. How often the metric is recomputed and how far behind real time it can legitimately be. This attribute is what lets a consumer interpret a discrepancy as timing rather than error.

6. Permitted values or valid ranges. The bounds inside which the metric is plausible. This is the attribute teams skip and later regret: a pipeline that silently returns zero, or a join that multiplies rows by three, produces a number that looks like a number. A range check flags it before it reaches a board deck.

The survey evidence on accountability is sobering. In a TDWI survey of 271 respondents who had partially or fully deployed a KPI initiative, 30% said the statement "someone is held accountable for the outcome of each KPI" applied to their KPIs to a high degree; 31% said their KPIs align with each other; 27% said employees cannot game the KPIs (Eckerson, How to Create and Deploy Effective Metrics). Those are results from that sample, reported by TDWI, not a description of your organisation — but they set a realistic expectation for how much ownership work remains after the tooling is in place.

The same report addresses presentation consistency: organisations stratify targets into ranges and then encode those ranges into dashboard displays, and it stresses that a consistent encoding or scoring system should apply no matter which target type is used, so that conditional formatting connotes the same performance values across every KPI display. That is the visual counterpart of attribute six — the same discipline applied to colour that you apply to the formula.

Standards work is beginning to address portability. Apache Ossie (Incubating) is an open specification for semantic layer and ontology that defines a vendor-neutral, YAML-based format for expressing business metrics, dimensions and their relationships, so that BI platforms, query engines and AI agents can consume and produce semantic definitions without loss of meaning. It entered the Apache Incubator in June 2026 under ASF governance, with public mailing lists and a formal discussion-and-vote process for spec changes (Apache Incubator). The problem it targets is exactly the one in this section: the same business concept, such as monthly active users, is often defined inconsistently across an organisation's CRM, data warehouse and BI tools. A neutral format reduces lock-in and eases interoperability. It does not replace internal ownership, and it does not enforce a single query path — those remain yours.

Structuring the Reporting Layer So AI Agents Resolve to Governed Metrics

The agent case is usually framed as a model-quality question. It is better framed as an architecture requirement, because the failure mode is structural: an agent with SQL access to raw tables will produce a different answer to the same business question depending on how the prompt is phrased.

The design rule is short. The agent selects from governed definitions and queries through the semantic layer; it does not generate SQL against raw tables for business metrics. Everything else follows from that constraint.

The resolution path has six steps, and each one is a place to attach a control:

  1. Question. The user asks in natural language.

  2. Metric lookup. The agent resolves the question to a governed metric in the repository, or reports that no governed metric matches.

  3. Certified source and joins. The metric carries its source table and join logic, so the agent does not choose them.

  4. Permission check. The agent evaluates the requesting user's entitlements before querying.

  5. Query. The semantic layer generates and executes the query.

  6. Answer with the definition attached. The response includes the metric definition, source and filters, so the consumer can see what was measured.

Step six is not decoration. An answer that arrives without its definition is indistinguishable from a plausible guess, and the whole point of the governed path is that the consumer can check.

The same layer has to serve every surface. Cube's formulation is that the requirements are identical whether the user is an internal operator asking about pipeline or a customer asking about their account inside your product: the surface changes, the governed model should not. If BI reads from the semantic layer and the agent reads from raw tables, you have not centralised reporting; you have centralised one of two reporting paths, and the agent will drift away from the dashboard.

Permissions deserve separate attention because agents change the threat model. An agent acting on behalf of a user must inherit that user's access, which means row-level and column-level rules belong in the semantic layer and the query engine, not in prompt instructions. A prompt that says "do not show other regions' data" is a suggestion; a row-level policy is an enforcement. NIST Cybersecurity Framework 2.0 frames the underlying requirement in PR.AA-05: access permissions, entitlements and authorizations are defined in a policy, managed, enforced and reviewed, and incorporate the principles of least privilege and separation of duties. Applying that to agent entitlements means the agent's effective permissions are a reviewed policy artefact, not an emergent property of how it was prompted.

Vendors are beginning to describe their products in these terms. Singdata, for example, describes its Analytics Agent as turning business questions into verifiable SQL, tables and charts using analysis domains, semantic context and permission boundaries, with insights preserved as reusable dashboards (Singdata). That is the vendor's own description of its capability, not an independent verification, and it should be evaluated against the acceptance criteria later in this guide rather than accepted on the strength of the description.

An Implementation Sequence with Checkpoints

The sequence below is practical advice for a data team, not a report of a specific engagement. Its logic is to reduce the number of things that can go wrong at each stage and to make progress measurable at a checkpoint rather than at a calendar date.

Step 1 — Inventory and rank. List the metrics that appear in executive-facing content: board decks, investor updates, the executive dashboard, the weekly business review. Rank them by how often they are disputed and how much a decision depends on them. The output is a ranked list, not a metric catalogue.

Step 2 — Pick one narrow domain. Choose one business unit or one metric family. The practitioner guidance in the TDWI report is explicit: start small, take time to define the most important KPIs, and keep the set small enough that you can evaluate the impact of each and refine it (Eckerson). Scope inflation is the most common way these projects stall, and it is usually introduced at step two.

Step 3 — Define against the six attributes and get written sign-off. For each metric in scope, complete owner, formula, certified source, mandatory filters, refresh cadence and permitted range. Written sign-off from the named owner is the checkpoint: no build starts on an unsigned definition.

Step 4 — Implement and reconcile. Build the metric in the semantic layer, then run it against the existing dashboards and document every difference and its cause. Some differences will be errors in the new implementation, some will be errors in the old one, and some will be legitimate definitional choices that were never written down. The checkpoint is a reconciliation report that accounts for every discrepancy; an unexplained difference is an open defect, not a rounding issue.

Step 5 — Migrate consumers one at a time and retire the old calculation. Move a consumer to the governed metric, confirm it resolves correctly, then remove the old calculation. Leaving both live "just in case" preserves the drift you set out to eliminate, and it guarantees that the next discrepancy argument will be between the old path and the new one.

Step 6 — Add certification, deprecation and change log. Define who can certify a metric, how a metric is deprecated, and where changes are recorded with dates and reasons. This is the process that keeps the repository accurate after the project team disperses.

Step 7 — Extend to agent access. Only after human consumers resolve cleanly through the governed path should agents be pointed at it. The checkpoint before expansion is zero unresolved dual-path metrics: every metric in scope has exactly one live calculation.

The checkpoints matter more than the sequence. Signed definitions before build, a reconciliation report before migration, and zero dual paths before expansion give you three points at which to stop a project that is drifting, instead of discovering the problem in a board meeting.

Failure Modes That Derail Reporting Consolidation

The patterns below are practical judgment drawn from the cited sources and from ordinary project experience patterns. They are not measured frequencies, and no single one of them is fatal on its own; the risk is that two or three combine.

Glossary without enforcement. A business glossary is published, reviewed and announced. The calculations are untouched. Diagnostic: pick a governed metric and ask two teams to produce it from their own tools. If the numbers differ, the glossary is documentation, not governance. The DigitalHive use case makes the point directly — a shared metric glossary is not the same as a shared metric, and documentation does not reconcile outputs when each team computes the number differently.

Unclear ownership. No one is empowered to certify or deprecate. Diagnostic: ask who can retire the current definition of a disputed metric. If the answer is a committee, or a name followed by a caveat, ownership is unclear. The TDWI finding that only 30% of surveyed respondents said someone is held accountable for each KPI to a high degree suggests this is common rather than exceptional.

Parallel paths left open. The old dashboard is kept "just in case," so both calculations stay live and drift persists. Diagnostic: count the live implementations of your top five metrics. More than one per metric means the consolidation has not happened, regardless of what the architecture diagram shows.

Scope inflation. Every metric in every domain is attempted at once. Diagnostic: check whether the first domain has reached its reconciliation checkpoint. If not, additional domains are adding risk rather than value. The TDWI guidance to keep the KPI set small enough to evaluate impact applies with more force, not less, when the set spans business units.

Metric gaming. Once numbers carry incentives, behaviour adapts to the measure. The TDWI report states that the tendency to game KPIs increases dramatically once organisations attach monetary incentives to KPIs, and it recommends particular care when KPIs are used for compensation. Diagnostic: for any incentivised metric, ask what action would improve the number without improving the business, and check whether the definition permits it.

Discovery in the meeting. Divergence surfaces first in a board discussion because no monitoring exists. Diagnostic: is there any automated check that compares the governed metric against its permitted range, or against the legacy calculation during migration? If not, the first person to notice a break will be the person most inconvenienced by it. The DigitalHive use case describes exactly this pattern: filters go unchecked, calculations change without documentation, and executives continue using a report that has not reflected current business logic for months.

Acceptance Criteria You Can Test Before You Commit

The criteria below are proposed by this guide for evaluation. They are not a published standard, and they are deliberately written as observable pass/fail checks rather than capability descriptions, so that a vendor demonstration or a current-state audit can be scored against them.

#

Criterion

How to test

1

Traceability

Pick a number on an executive dashboard and trace it to its owner, formula, source and filters. Pass if this takes a few minutes with the tools at hand; fail if it requires an email.

2

Propagation

Change a definition in the repository and check whether every consumer reflects the change without editing individual dashboards.

3

Bypass control

Attempt a query that computes a governed metric outside the governed path. Pass if the system blocks it or flags it; fail if it silently returns a number.

4

Version diff

Produce a diff of what changed between two versions of a metric, with dates and authorship.

5

Agent parity

Ask an agent and the dashboard for the same KPI under the same conditions. Pass if the values match and the agent returns the definition alongside the answer.

6

Permission parity

Compare what a human user and an agent acting for that user can see. Pass if row-level and column-level rules produce identical results.

7

Lifecycle

Confirm a documented certification and deprecation path with a named approver for each governed metric.

8

Range monitoring

Confirm that permitted values or ranges are configured and that a breach raises an alert rather than waiting to be noticed.

Two cautions apply when running this checklist against a vendor. First, a demonstration environment is usually configured to pass; ask for the tests to be run against your own metric definitions and your own permission model. Second, vendor-published performance and cost figures should be validated in your own environment before they inform a purchasing decision — they describe the vendor's benchmark conditions, not your workload.

Conclusion

A centralised reporting system is a governed definition plus an enforced query path plus ownership. The tooling matters only insofar as it makes those three things testable; a semantic layer that anyone can bypass is a convention, and a glossary that nobody enforces is documentation.

The mechanism behind the two-number problem is worth remembering because it is diagnosable: source, filters, time logic, aggregation and refresh timing, each a legitimate choice, compounding into a discrepancy that looks like an error. The six attributes — owner, formula, certified source, mandatory filters, cadence and latency, permitted range — are the specification that prevents the compounding. The agent rule is the same specification applied to a new consumer: resolve to governed definitions, never re-derive business logic per prompt, and enforce permissions in the layer rather than in the prompt. The sequence, with its three checkpoints, is how a team gets there without attempting the whole enterprise at once.

Two developments make the definition layer more important rather than less. Standards work such as Apache Ossie is creating a vendor-neutral format for metrics, dimensions and relationships, which lowers the cost of moving definitions between tools and raises the cost of having no definitions to move. And agent consumption is increasing the volume of queries against business metrics, from surfaces that do not have a human reviewing each result. Both trends reward organisations that can state precisely what their numbers mean.

The next action is small and does not require a purchase. Pick the one KPI that is most disputed in your organisation, write down its six attributes, and name the owner who can approve and deprecate it. That document is the first governed metric, and it is the test of whether the rest of the programme is possible.

Frequently Asked Questions

Is a centralised reporting system the same as a data warehouse?

No. A warehouse stores and computes data; a centralised reporting system adds governed definitions, an enforced query path and ownership on top. A warehouse can host many conflicting definitions of the same metric, all of them executing correctly. A reporting system can also sit over more than one warehouse, which is often the reason for building one.

Do we need a standalone semantic layer, or can our BI tool's built-in one work?

A built-in semantic layer centralises definitions for that tool's consumers. A standalone layer extends the same definitions to other BI tools, spreadsheets, embedded analytics and AI agents. The choice depends on how many consumer surfaces must agree, not on which architecture is inherently better. If one BI tool is genuinely the only consumer, a built-in layer may be sufficient; if agents or embedded analytics are on the roadmap, the constraint will arrive later and cost more to retrofit.

How long does consolidation take?

Duration depends on the number of disputed metrics, the number of consumer surfaces that must agree, and how much authority the named owners actually have. Rather than plan to a calendar estimate, scope to one domain and use the reconciliation checkpoint as the progress measure: the project is done with a domain when every difference between the new metric and the old dashboards is explained and the old calculation is retired.

Will a semantic layer stop AI agents from producing wrong numbers?

It removes one major cause — re-deriving business logic on every prompt — but it does not guarantee correctness. Accuracy still depends on source data quality, on permission configuration and on validation. A governed layer makes an agent's answers consistent and explainable; it does not make the underlying data true, and governance and testing remain necessary.

How do we handle metrics that legitimately differ by team?

Define them as distinct metrics with distinct names and owners rather than one name with two formulas. The failure is ambiguity, not variation. A regional revenue metric and a group revenue metric can both be governed, provided each is labelled and sourced explicitly and a consumer can tell which one they are looking at.

What does "certified" mean for a dashboard or metric?

It means a named owner has approved the definition, source and filters, and the item is subject to change control and periodic review. Certification is a process commitment, not a badge a tool applies automatically. The test is whether the certification can be revoked and whether a change requires the owner's approval.

Where do open standards like Apache Ossie fit?

They provide a vendor-neutral format for expressing metrics, dimensions and relationships so definitions can move between tools without loss of meaning. That reduces lock-in and eases interoperability between BI platforms, query engines and agents. It does not replace internal ownership, and it does not enforce a single query path; those remain organisational commitments that no specification can make for you.