How to Build Data Governance Controls You Can Test and Prove
Build testable data governance controls: ownership, metric definitions, access, quality, lineage and agent consumption, each with a test and evidence.
The controls that survive an audit are the ones enforced at a named point on the data path and backed by an artifact an auditor can read. This guide works through six of them: ownership, metric definitions, access, quality and freshness, lineage, and agent consumption. Each is described in four parts: the control, where it is enforced, how to test it, and what evidence it leaves behind. The standards referenced throughout are ISO/IEC 38505-1:2026, the EU AI Act's Article 10, NIST AI RMF 1.0 and SP 800-53 Release 5.2.0, and OWASP's LLM06:2025. Expect a working session per control rather than a project: the prerequisites are a data platform with query-time policy support, a contract or catalog tool, and read access to your own audit views.
The urgency is measurable. In a 2026 survey of data and analytics leaders fielded in the second half of 2025, 48% said they had not yet implemented programs to govern the data used for AI, and 43% named data readiness as the most significant barrier to aligning AI with business objectives (Drexel LeBow/Precisely 2026 State of Data Integrity and AI Readiness, retrieved 2026-02-10). The survey was commissioned by Precisely, a data-integrity vendor, so treat the figures as vendor-commissioned findings rather than neutral industry data.
What does data governance have to mean if the controls must be testable?

A testable control is a rule with an enforcement point, a pass/fail test, and an evidence artifact, and frameworks supply the acceptance criteria rather than the deliverable. ISO/IEC 38505-1:2026, the second edition of the governance-of-data standard, applies the ISO/IEC 38500 governance model to data and replaced the 2017 edition in August 2026 (ISO/IEC 38505-1:2026 edition summary, retrieved 2026-02-10). Its scope clause covers the current and future use of data created, collected, stored or controlled by IT systems, for organisations of all sizes (ISO/IEC 38505-1:2017 scope, retrieved 2026-02-10).
That framing matters because it names who the control set serves: governing bodies, executive managers, service providers and auditors. NIST's AI RMF organises this into four functions, GOVERN, MAP, MEASURE and MANAGE, with GOVERN applied throughout the lifecycle rather than as a phase (NIST AI 100-1, retrieved 2026-02-10). Article 10's list of data-governance practices adds the regulatory test: design choices, data origin, preparation operations, assumptions, suitability, bias examination and mitigation, and identified data gaps (EU AI Act Service Desk, Article 10, retrieved 2026-02-10).
Use a data governance framework as a source of acceptance criteria, not as the artifact you deliver. The matrix below is the deliverable; each row is filled in by the sections that follow.
Control | Enforcement point | Test | Evidence artifact |
|---|---|---|---|
Ownership | Named owner on the contract or catalog record | Trace who can change a disputed metric | Owner field plus approval history |
Metric definition | Single contract file consumed by the semantic layer | Search for a second copy of the definition | Contract version and check output |
Access | Query-time policy in the engine or identity layer | Query as a restricted role and as an authorised role | Per-statement access record |
Quality and freshness | Executable service-level check | Run the check against the live table | Dated pass/fail result |
Lineage | Event emission from the job that writes the data | Walk from an output column back to its inputs | Column-level lineage event |
Agent consumption | Scoped credential with its own identity | Inspect the token claims and the audit trail | Delegation chain per request |
Who owns which data decision, and how is ownership recorded?
Ownership is testable only when a named person can be traced to a specific decision, and the record lives next to the data rather than in an org chart. OpenMetadata's data contract model formalises this: a contract is a producer/consumer agreement across schema, quality, freshness and availability, each with a named contract owner and consumer approvers (OpenMetadata Standards, Data Contracts, retrieved 2026-02-10). Mapping AI RMF controls onto platform metadata produces the same shape: a named risk lead per AI project and a governance committee that approves AI products before production (Databricks, A Modern AI Risk Management Framework, retrieved 2026-02-10).
Record four fields per asset: the accountable owner, the approvers who must sign off on breaking changes, the review cycle, and the date of the last review. Segregation of duties belongs here too, because an owner who can both change a definition and approve the change has no control at all.
To verify, pick a disputed metric and trace who can change it. If the answer is "whoever has write access to the dashboard," ownership is a title, not a control.
Warning: a catalog entry recording a policy that nothing enforces is the failure mode this step exists to prevent. If the owner field has no corresponding approval history, the record documents intent only.
How is a metric definition made single-source and enforced?
A metric definition is single-source when exactly one system holds it and every consumer reads from that system, so the test is simple: search the estate for a second copy. If a dashboard, a notebook and a spreadsheet each carry their own version, the metric is documented, not governed. The semantic-layer pattern and the "one metric, one definition" rule work because they remove the second copy rather than reconcile it, and that is what makes data quality and lineage controls testable at the definition layer.
The Open Data Contract Standard turns the promise into an artifact a pipeline can check. It declares service levels in a top-level slaProperties block, with property, value, unit and element, for example freshness, 24, h, orders.order_timestamp:
slaProperties:
- property: freshness
value: 24
unit: h
element: orders.order_timestamp
The reference implementation turns freshness and retention into executable checks, so a CI job can fail the build when the promise breaks:
datacontract test --checks slaProperties datacontract.yaml
The same documentation states plainly that properties other than freshness and retention are documentation only, so a latency promise in the contract is not tested by this command.
Verification checkpoint: change the definition in one place, then confirm every downstream consumer reflects the change without a second edit. Who may change the definition and who may read it are separate grants, and the second question leads into least-privilege agent access.
Key Takeaway: a documented definition tells readers what a metric means; an enforced definition fails a build when the promise breaks. Only the second survives staff turnover.
How is access actually enforced, including for AI agents?

Access is enforced at the query engine or the identity layer, not in the catalog, and the evidence is the per-statement record. Snowflake masking policies are evaluated at query time as schema-level objects, so the stored data is not modified, and the feature requires Enterprise Edition (Snowflake, Understanding column-level security, retrieved 2026-02-10). The same page documents segregation of duties for masking policies: by default the object owner cannot unset the policy and cannot view the masked column data.
Databricks implements the same pattern differently. Row filters and column masks in Unity Catalog are SQL user-defined functions evaluated at query time, bound to a table with ALTER TABLE ... SET ROW FILTER or to a column with ALTER TABLE ... ALTER COLUMN ... SET MASK, and managed by the table owner (Databricks, Row filters and column masks, retrieved 2026-02-10). Each column carries at most one mask, and the engine prefers the secure choice over an optimisation that could leak values. The same page documents a failure worth testing for: with ANSI mode disabled, a type mismatch in a filter can silently return every row instead of filtering.
For agents, OWASP's guide to excessive agency in agentic systems ranks the risk as LLM06:2025, defined as the vulnerability that enables damaging actions in response to unexpected, ambiguous or manipulated model output, with root causes of excessive functionality, excessive permissions and excessive autonomy (OWASP LLM06:2025, retrieved 2026-02-10). OWASP's least-privilege mitigation is concrete: an agent using a product database for recommendations needs read access to one products table, with no access to other tables and no insert, update or delete.
To verify, run the same query as a restricted role and as an authorised role and compare results, then read the access record for both statements. Snowflake's ACCESS_HISTORY view records one row per SQL statement, with the source columns accessed directly and indirectly, the projected columns the user sees, and a policies_referenced column naming the row access and masking policies the query relied on (Snowflake, Access History, retrieved 2026-02-10).
Pro Tip: show a failing check, not only a passing one. A mask that returns the wrong values under a type mismatch is the finding an auditor will ask about, and demonstrating you test for it is stronger evidence than a green dashboard.
How do I prove data quality and freshness rather than assert it?
Quality and freshness are proven by a dated check result attached to the dataset, not by a score in a catalog. The ODCS freshness check is one such proof: it passes when now − MAX(orders.order_timestamp) < 24 hours, and it fails with a named error when the referenced column is empty or entirely null (Data Contract CLI service-level mechanics, retrieved 2026-02-10). The retention check reads the oldest value with MIN and passes when data older than the retention period has been deleted.
Freshness is not representativeness. The check proves the data is recent; it says nothing about whether the rows cover the population the model will meet. Article 10(3) requires datasets that are relevant, sufficiently representative and, to the best extent possible, free of errors, with appropriate statistical properties (EU AI Act Service Desk, Article 10, retrieved 2026-02-10). No excerpted tooling in this guide tests that property, so state the gap rather than implying the freshness check covers it.
The applicability dates matter for planning. Article 10 applies from 2 December 2027 for Annex III high-risk systems and 2 August 2028 for Annex I systems, and Article 10(6) limits paragraphs 2 to 4 to testing datasets for systems that do not train models (EU AI Act Service Desk, Article 10 applicability, retrieved 2026-02-10).
To verify, run the check against the live table and keep the dated output. A check that has never failed is worth questioning; a check whose failure history is visible is evidence.
How is lineage captured well enough to audit an AI answer?
Lineage is auditable when a column in an AI answer can be traced back to its input columns and the transformation between them, and that requires events emitted by the job that wrote the data. The OpenLineage object model defines three event types: RunEvent for runtime job-run state, JobEvent for design-time job metadata, and DatasetEvent for design-time dataset metadata such as schema, ownership and documentation (OpenLineage, Object Model, retrieved 2026-02-10). A Job is identified by namespace and name, and a Run by a client-generated runId that persists across state updates.
Column-level detail lives in the columnLineage facet. Each output field lists its inputFields with namespace, dataset name and field, plus transformations typed DIRECT or INDIRECT with subtypes such as IDENTITY, TRANSFORMATION, JOIN, FILTER and SORT, and a masking boolean indicating the value was obfuscated (OpenLineage, Column Level Lineage Dataset Facet, retrieved 2026-02-10).
The two evidence layers complement each other. The lineage facet records which input columns produced an output column and whether masking applied; Snowflake's policies_referenced records which policy the query relied on, including on intermediate objects. Together they let you trace a masked column from source to target with the policy that applied. The AI Act text does not name lineage, so present this as a mapping that supports Article 10(2)(b) and (c) on origin and preparation, not as compliance.
To verify, pick a column in a production answer and walk it back to its inputs. If the walk stops at a view with no event behind it, the chain has a hole.
What changes when AI agents consume the data?

An agent is a principal with its own identity, scoped credential and audit trail, and it should never inherit a user's full permissions. AWS's guidance on authorising agents against a semantic layer requires least-privilege IAM roles, group-based authorisation from JWT groups claims mapping to roles such as data-reader and agent-operator, an act claim that identifies the agent acting on behalf of a user for audit and delegation-chain tracking, and a sub claim used for row-level security, audit logging and provenance (AWS Prescriptive Guidance, Governance and Security, retrieved 2026-02-10).
That claim structure is what makes data governance for AI testable. The act claim records the delegation chain per request, so an auditor can see which user, which agent and which credential produced an answer. OWASP's root causes map onto the same design: excessive functionality is an agent with tools it does not need, excessive permissions is a credential broader than the task, and excessive autonomy is an action taken without an approval gate (OWASP LLM06:2025, retrieved 2026-02-10).
To verify, inspect the token claims on a live agent request and confirm the audit record names both the user and the agent. A request that carries only a service account has no delegation chain to audit.
Common mistakes to avoid
The recurring failures in data governance best practices are structural, and each has a test that catches it. The first is the catalog entry without enforcement: a policy is recorded, nothing evaluates it, and the record gives false assurance. The test is to break the policy deliberately and confirm something fails.
The second is a definition with more than one home. If the semantic layer, a notebook and a report each carry their own version of a metric, the contract is documentation. The test is a search for duplicate definitions.
The third is treating a vendor claim as a measured capability. Databricks advertises end-to-end automated column-level lineage for data and AI assets "to simplify impact analysis, troubleshooting, governance and AI audits" (Databricks, Data governance with Unity Catalog, retrieved 2026-02-10). That is a vendor claim on a product page; test it against your own pipelines before relying on it.
The fourth is confusing freshness with quality, covered above. The fifth is governing agents as if they were users, which leaves no delegation chain. The sixth is letting the owner of an object also approve the policy that restricts it, which removes segregation of duties. The seventh is treating NIST AI RMF adoption as a requirement: the framework states it is intended to be voluntary, rights-preserving, non-sector-specific and use-case agnostic (NIST AI 100-1, retrieved 2026-02-10). The current SP 800-53 release is 5.2.0, issued 27 August 2025, which added three controls including Logging Syntax (SA-15) and Root Cause Analysis (SI-02(07)) (NIST release announcement, retrieved 2026-02-10); cite the release, not an older revision.
Conclusion
The takeaway is that a control set earns its name only when each control has an enforcement point, a test and an evidence artifact, and the evidence survives the person who built it. The survey data points the same way: organisations that expanded data governance to include AI report the strongest outcomes, while those that reduced data governance to focus on AI are the weakest performers (Drexel LeBow/Precisely 2026, retrieved 2026-02-10), a vendor-commissioned finding that aligns with NIST's treatment of governance as cross-cutting.
Run the control table against your own risk register before you buy anything. For each row, name the enforcement point, run the test once, and keep the output. Where a row has no enforcement point, that is the gap to close first.
Acceptance checklist:
Every control has a named enforcement point on the data path.
Every control has a test that has been run at least once, with a dated result kept.
Ownership records include approvers and a last-review date, with segregation of duties intact.
Metric definitions exist in exactly one file, and a check fails when the promise breaks.
Access is enforced at query time and the per-statement record names the policies referenced.
Lineage events cover the jobs that write the data an AI answer depends on.
Agent requests carry a delegation chain naming both user and agent.
Known gaps, including representativeness and bias testing, are written down rather than implied covered.
FAQs
What makes a data governance control testable?
A control is testable when it names where it is enforced, what condition counts as a pass, and what artifact records the result. A policy that exists only in a document fails all three.
How do I prove a metric definition is enforced and not just documented?
Search for a second copy of the definition. If one file holds it and a check like datacontract test --checks slaProperties fails when the promise breaks, it is enforced (Data Contract CLI, retrieved 2026-02-10).
Can AI agents be governed the same way as users?
No. An agent needs its own scoped credential and an act claim recording the user it acts for, so the audit trail shows the delegation chain (AWS Prescriptive Guidance, retrieved 2026-02-10).
Does the EU AI Act require data lineage?
The Act does not name lineage. Article 10(2) requires documented practices covering data origin and preparation, which lineage evidence supports, but no excerpted source states that lineage satisfies Article 10 (EU AI Act Service Desk, retrieved 2026-02-10).
When does Article 10 apply?
From 2 December 2027 for Annex III high-risk systems and 2 August 2028 for Annex I systems, with Article 10(6) narrowing paragraphs 2 to 4 to testing datasets for systems that do not train models (EU AI Act Service Desk, retrieved 2026-02-10).
Is a freshness check enough to prove data quality?
No. A freshness check proves the data is recent. Article 10(3) also requires datasets that are representative and free of errors, and no excerpted tooling in this guide tests representativeness.
What evidence does an auditor actually read?
Per-statement access records naming the policies referenced, dated check results, column-level lineage events, and ownership records with approval history. Each is produced by the system, not written after the fact.
About the publisher. Singdata is a Singapore-headquartered company that builds an AI-native lakehouse platform for enterprise data teams, including data management and governance tooling. It has a commercial interest in how organisations choose data infrastructure, so weigh its perspective with that in mind. The guidance above does not depend on Singdata's products.