Data Integrity Explained: More Than Just Correct Values
|
7
min read
Poor data quality has been estimated to cost organizations an average of $12.9 million per year, and broader summaries put the range at $12.9 million to $15 million annually. Data integrity is about maintaining correct and reliable relationships between data elements and datasets, not just whether individual values are right.
That distinction matters because a field can look clean and still be part of a broken relationship. An order can have a valid amount, a proper date, and a real-looking customer ID, yet still fail if that customer no longer exists in the master data, or if the row breaks a business rule that keeps the dataset trustworthy.
Table of Contents
What Data Integrity Really Means
Why “correct values” is an incomplete test
Where Integrity Fits in Data Quality
Why integrity needs its own track
What Data Integrity Covers in Practice
How Integrity Differs from Accuracy, Validity, and Consistency
Side-by-side distinctions
How to Measure Data Integrity
A simple integrity score
Practical metrics teams track
What Is Referential Integrity?
Why orphan records are a real problem
How Can Data Integrity Be Monitored Continuously?
What continuous monitoring looks like
An Orders and Customers Example for Integrity Monitoring
Three checks catch different signals
How the incident should be handled
How Can digna Support Data Integrity?
What each module does for integrity
What Data Integrity Really Means
Data integrity is the preservation of valid relationships, structural conditions, and business constraints across data elements and datasets. It's broader than checking whether one cell contains the right value, because a value can be well-formed and still sit inside a broken relationship.
Why “correct values” is an incomplete test
A customer ID can look valid, an invoice total can be numeric, and a status field can use the right label. None of that guarantees the record still fits the system's rules. If an invoice points to a missing account, or an order references a customer that was deleted upstream, the data has lost integrity even though each individual field may look acceptable.
That's why integrity failures are so dangerous in analytics and AI pipelines. The records arrive, the job completes, and the dashboard renders. The system looks healthy, but the relationships that make the data meaningful are gone. In practice, this is the difference between a number that exists and a number you can trust.
Practical rule: treat integrity as a property of connections and structure, not of any single cell.
For teams that also track provenance and lineage, the relationship is closely related, but not identical. Integrity asks whether the dataset still holds together as intended, while lineage and provenance describe how the data got there. A useful reference point is this comparison of provenance and lineage, which helps separate origin tracking from structural trust.
The board-level reason to care is straightforward. IBM and Harvard Business Review have long cited an estimated $3.1 trillion annual cost of bad data to the U.S. economy, and MIT Sloan Management Review has also reported earlier research estimating bad data can consume 15% to 25% of revenue for many companies, which explains why data integrity keeps moving out of the database team's lane and into governance and leadership discussions. The financial risk isn't only from wrong values, it's from broken relationships that distort downstream decisions.
Where Integrity Fits in Data Quality
Integrity is one of the recognized data quality dimensions in DAMA-DMBOK® 2.0 Revised Edition, alongside accuracy, completeness, timeliness, consistency, uniqueness, validity, and related quality dimensions. That placement matters because it confirms integrity isn't a niche database idea, it's a core part of DAMA data quality and DMBOK data quality thinking.
Why integrity needs its own track
A team can have strong accuracy checks and still miss integrity failures. That happens because accuracy looks at whether a value reflects reality, while integrity looks at whether the structure and relationships around the value still hold. A customer address can be accurate, but if the customer record no longer links to the right account, integrity has already failed.
The same issue shows up in operations. Many groups rely on manual checks or SQL-based validation, while fewer use dedicated observability tooling, and governance ownership is often shared across teams. Recent survey data shows 44% say data quality ownership is shared across multiple teams, 61% still rely on manual checks or SQL-based validation, 27% use a dedicated observability platform, 39% track SLAs for key pipelines, and 14% enforce them organization-wide. Those numbers point to a common operational gap, teams watch quality values, but they don't always monitor relationship health end to end. Internal consistency across data quality dimensions is what keeps integrity from being mistaken for another dimension.
What Data Integrity Covers in Practice
Data integrity includes several related checks, each catching a different kind of failure. The four primary subtypes and what they look like in practice:
Subtype | What it checks | Example failure | digna feature |
|---|---|---|---|
Referential integrity | Valid links between related records | A hospital visit points to a patient ID that no longer exists | Data Validation |
Relational integrity | Logical consistency between records and datasets | A lab result is attached to the wrong patient encounter | Data Validation |
Structural integrity | Schema shape, types, and required fields | A required field drops out of a claims feed | Schema Tracker |
Business-rule integrity | Rules that govern related values | A settled payment is marked active again | Data Validation |
The table matters because each subtype breaks trust in a different way. A record can look perfectly valid on its own and still fail the larger integrity check if its links, shape, or rule context no longer hold.
A claims system is a good example. A claim line may contain a valid code, a valid amount, and a valid date. If that line is attached to the wrong patient account, or if the encounter it depends on has been closed out of sequence, the data is still broken. The value is fine. The relationship is not.
That distinction is why teams often miss integrity problems when they only inspect individual fields. Structural checks catch missing columns or type shifts. Referential checks catch broken links. Business-rule checks catch combinations that should never occur together. Together, they show whether the dataset still behaves like a connected system instead of a pile of correct-looking values.
A platform can support these checks in different ways. Database integrity testing is one practical lens, because it forces teams to classify each rule as a reference issue, a structure issue, or a business rule issue. If the failure is a missing parent row, the fix is different from a schema change or a rule violation.
How Integrity Differs from Accuracy, Validity, and Consistency
Integrity is not the same as accuracy, validity, or consistency. The easiest way to separate them is to ask what kind of failure each one catches.
Side-by-side distinctions
Dimension | What it checks | Failure mode it catches | Example detection |
|---|---|---|---|
Integrity | Relationships and dependencies | Orphan records, broken parent-child links, violated business rules | A foreign key points to a missing customer |
Accuracy | Whether a value matches reality | Wrong names, wrong amounts, wrong dates | A customer's email address is outdated |
Validity | Whether a value fits the allowed format or domain | Bad types, invalid ranges, malformed codes | A status is outside the approved list |
Consistency | Whether data agrees across systems or representations | Conflicting values in different tables or reports | Two systems show different customer counts |
A record can be valid, accurate, and even consistent, yet still fail integrity. A customer email might be in the right format, match the CRM, and reflect the actual person. If that customer ID no longer exists in the order system, the relationship is broken and the dataset is no longer trustworthy.
Rule of thumb: use accuracy checks for value correctness, validity checks for format and domain rules, consistency checks for cross-system agreement, and integrity checks for the relationships that tie the data together.
Accuracy in data quality is a helpful comparison point because it shows why value correctness alone doesn't protect the model, report, or ledger. Data teams need each check in the right place, not one catch-all test pretending to do everything.
How to Measure Data Integrity
Data integrity becomes measurable when you define the relationships and business rules that must hold for a given dataset. The formula is simple, but the rule set behind it has to be explicit.
A simple integrity score
Integrity rate = records satisfying required integrity conditions / records assessed × 100
That formula works only if the team agrees on which conditions count. For one pipeline, the condition may be a valid foreign key. For another, it may be a schema rule plus a parent record plus a business constraint. Measurement depends on the relationship being assessed.
Practical metrics teams track
Referential integrity violation rate, how often links point to missing parents.
Orphan record count, the number of child rows with no valid parent.
Failed relationship checks, the total number of broken joins or dependency rules.
Percentage of records with valid references, a simple pass-rate view.
Broken relationship counts, useful for trend tracking across releases.
Business-rule violation rate, the share of rows that fail a defined rule.
Data quality metrics become far more useful when they separate structure from value quality. A clean dashboard should show relationship health, not just null rates and completeness. If schema drift, foreign key checks, and rule checks all fail in the same window, the integrity score drops even if the values look normal on the surface.
What Is Referential Integrity?
Referential integrity means relationships between related entities remain valid. Every order should reference an existing customer, every invoice should reference an existing account, and every product ID should exist in the product master.
Why orphan records are a real problem
A broken reference creates an orphan record. The row still exists, but its meaning has been damaged because it no longer points to a valid parent. Microsoft's SQL Server documentation describes this plainly, a foreign key depends on the primary key it references, and references to nonexistent values aren't allowed.
That's why referential integrity is often enforced through primary key and foreign key constraints, with CHECK constraints also helping preserve valid relationships across tables. If a key changes, all dependent references have to change consistently too, or the dataset loses meaning.
When a child row can't find its parent, the data may still load, but the relationship is no longer trustworthy.
The macro picture is sobering. The Identity Theft Resource Center reported 3,322 data compromises in the U.S. in 2025, up 79% over five years, and 471.2 million victim notices in just the first half of 2026. Those figures show why teams can't treat relationship failures as minor cleanup tasks, because integrity problems are part of a broader operational and risk environment. Referential-integrity guidance provides a plain operational definition, valid relationships between linked records are the core mechanic.
How Can Data Integrity Be Monitored Continuously?
Data integrity monitoring works best as an ongoing control, not a quarterly audit. Scheduled checks catch problems after the fact, while continuous monitoring spots broken relationships, schema changes, and rule failures as they happen.
What continuous monitoring looks like
Start with thresholds. Define what counts as normal for relationship checks, orphan counts, schema changes, and business-rule failures. Then alert when the data drifts outside the expected range, and route the incident to the right owner with enough context to fix the root cause.
A useful operating rhythm is simple:
Define KPIs, such as relationship pass rates and failed constraint counts.
Set baselines, so the team knows what normal looks like.
Alert on drift, rather than waiting for a report to break.
Review monthly, so recurring issues become visible and fixable.
Schema drift deserves special attention because structural changes can corrupt downstream meaning even when the row values still look fine. Type changes, renamed columns, removed fields, and uncoordinated additions can break compatibility or invalidate transformations before anyone notices.
An Orders and Customers Example for Integrity Monitoring
An order row with customer_id = 4821 can look perfect and still be broken if customer 4821 was deleted from the customer master last quarter. The order amount can be correct, the order ID can be unique, and the email format can pass validation, while integrity has already failed.
Three checks catch different signals
Data Validation flags the invalid reference when the order points to a customer that no longer exists.
Data Reconciliation compares the related source and target datasets and surfaces the mismatch between what the order table expects and what the customer master holds.
Schema Tracker notices the structural change that may have contributed to the problem, such as a deleted or renamed field upstream.
The pipeline itself may still complete successfully. That's the trap. A green job status doesn't mean data integrity survived the run.
How the incident should be handled
The team should group the three signals into one incident, not three separate tickets. That keeps people focused on the root cause, which might be a missing delete rule, a broken sync, or a schema change that wasn't coordinated with downstream systems. The right fix is usually upstream, because patching the orphan row alone doesn't restore the broken relationship.
How Can digna Support Data Integrity?
digna Data Validation supports explicit relationship and business-rule checks, which is the core requirement for catching broken references, orphan rows, and rule violations. digna Data Reconciliation helps compare related source and target datasets where integrity depends on the two systems agreeing. digna Schema Tracker identifies structural or schema changes that may affect integrity over time.
What each module does for integrity
Data Validation is the direct fit for record-level checks. Reconciliation is the right fit when integrity depends on consistency between systems. Schema Tracker is the early warning layer for structural changes that can break downstream assumptions.
Schema monitoring can identify structural changes that may affect Integrity; it does not by itself prove that the data is structurally or referentially correct.
That distinction matters because teams sometimes confuse detection with proof. A schema alert tells you the shape changed. It doesn't confirm that every relationship still works or that every rule still holds.
If your team is trying to separate clean-looking data from trustworthy data, dig into the relationship rules, schema changes, and validation signals that sit underneath the dashboard. Visit digna to see how its validation, reconciliation, and schema-tracking capabilities can support data integrity monitoring in the systems you already run.
