Integration Mistakes That Cause Data Problems

The five most common integration mistakes that lead to bad data, and how to prevent each one. Perth, Melbourne, Sydney and Brisbane.

Best for: IT leaders, operations managers Practical guide for business decision-makers

Who this is for

IT leaders and operations managers who've experienced data quality problems from system integrations or want to avoid them.

Question this answers

What are the most common integration mistakes that cause data problems, and how do we prevent them?

What you will leave with

  • The five integration mistakes that cause the most data issues
  • Why each mistake happens and how to detect it
  • Specific prevention strategies for each
  • A prevention checklist for new integration projects

Why integrations cause data problems

Integrations are the most common source of data quality issues in business systems. Not because the technology is unreliable, but because the planning is often incomplete. Data flows between systems silently, and problems accumulate before anyone notices.

Here are the five mistakes we see most often, and how to prevent each one.

Mistake 1: Duplicate records

What happens: The same customer, order, or transaction appears multiple times in the target system because the integration creates new records instead of updating existing ones.

Why it happens: The integration does not properly match incoming records against existing ones. The matching logic relies on fields that are not unique (like name) instead of unique identifiers (like email or account number).

How to prevent it:

  • Define a unique identifier for matching before building the integration
  • Use upsert logic (update if exists, create if new) rather than always creating
  • Build duplicate detection rules in the target system as a safety net

Mistake 2: No source of truth

What happens: The same data (e.g., customer address) exists in multiple systems and conflicts. Nobody knows which version is correct.

Why it happens: Both systems allow editing the same data, and there is no rule for which one "wins" when they disagree.

How to prevent it:

  • Designate one system as the master for each data element
  • Make the data read-only in non-master systems (or sync changes back to the master)
  • Document the ownership model so everyone understands where to edit what

Mistake 3: No error handling

What happens: A record fails to sync (API error, validation failure, timeout) and nobody notices. The data gap grows silently over days or weeks.

Why it happens: The integration was built to handle the happy path only. Errors are logged somewhere but not monitored or acted on.

How to prevent it:

  • Design error handling as part of the integration, not an afterthought
  • Implement a dead-letter queue for failed records
  • Set up alerts that notify the right person when failures occur
  • Build a retry mechanism with exponential backoff for transient errors

Mistake 4: Data format mismatches

What happens: Data arrives in the wrong format. Dates break (DD/MM/YYYY vs MM/DD/YYYY), phone numbers lose their leading zero, currency amounts lose decimal places.

Why it happens: Data mapping did not account for format differences between systems. Testing used clean sample data that did not reveal edge cases.

How to prevent it:

  • Document format requirements for every field in both systems
  • Build explicit transformation rules (never assume formats match)
  • Test with real production data (anonymised), including edge cases
  • Add validation at the point of ingestion. Reject bad data rather than ingesting it.

Mistake 5: No monitoring

What happens: The integration works fine for months, then gradually degrades. Volume changes, API updates, data format shifts. Problems accumulate without detection.

Why it happens: The integration was built and forgotten. There's no dashboard, no health checks, no regular review.

How to prevent it:

  • Build a monitoring dashboard showing success rates, volumes, and error counts
  • Set up automated health checks that verify data consistency between systems
  • Schedule quarterly integration reviews
  • Track sync latency. Data getting slower to sync often precedes failures.

Prevention checklist

Check these before your integration goes live

  • Unique matching identifiers defined for all entity types
  • Source of truth designated for every shared data element
  • Error handling designed, built, and tested
  • Data format transformations documented and tested with real data
  • Monitoring dashboard and alerts configured
  • Parallel run completed, old and new data compared
  • Rollback plan documented and tested

Key takeaways

  • Most data problems from integrations are preventable with proper planning
  • The number one cause of integration data issues is having no clear "source of truth" for each data element
  • Error handling isn't optional. Every integration will fail at some point.
  • Data format mismatches are the most tedious but most common source of bugs
  • Monitoring should be built from day one, not added after problems emerge
IntegrationsDataAPIsQuality

Integration data problems: common questions

What are the most common integration mistakes that cause bad data?

The five most common integration mistakes are duplicate records, no source of truth, no error handling, data format mismatches and no monitoring. Integrations cause data problems less because the technology is unreliable and more because the planning is incomplete. Data flows between systems silently, so problems build up before anyone notices. Most of these problems are preventable with proper planning.

Why does an integration create duplicate customer records?

An integration creates duplicate records when it makes new records instead of updating existing ones. This usually happens because matching relies on fields that are not unique, such as a name, rather than unique identifiers such as an email or account number. Prevent it by defining a unique identifier before the build, using upsert logic that updates a record if it exists and creates it if new, and adding duplicate detection rules.

What does source of truth mean when two business systems share data?

A source of truth is the one system designated as the master for each shared data element, such as customer addresses. Without one, both systems allow editing the same data and nobody knows which version is correct when they disagree. Make the data read-only in the other systems, or sync changes back to the master, and document where to edit what. Having no clear source of truth is the number one cause of integration data issues.

How should an integration handle records that fail to sync?

Integration error handling should be designed as part of the build, not added afterwards, because every integration will fail at some point. Failed records should go to a dead-letter queue, alerts should notify the right person when failures occur, and transient errors should be retried with exponential backoff. Without this, a record that fails through a validation failure or timeout goes unnoticed and the data gap grows silently for days or weeks.

How do I stop dates and phone numbers breaking when data moves between systems?

Data format mismatches are prevented with explicit transformation rules, because formats should never be assumed to match. Document the format requirements for every field in both systems, test with anonymised production data that includes edge cases, and validate data at the point of ingestion so bad data is rejected. Typical breaks are DD/MM/YYYY dates read as MM/DD/YYYY, phone numbers losing their leading zero and amounts losing decimal places.

Ask the author

Still have a question?

Ask it here and it comes straight to the founder. No sales call, no obligation, and a real answer even if the answer is that you do not need us.

Kasun Wijayamanna, Founder Kasun Wijayamanna
Founder, replies within one business day

Get Started

Want help choosing the right next step?

Tell us what you are comparing, replacing, or trying to improve. We will come back with a practical recommendation and realistic scope.

Australian owned and operated

Built here. Your data stays here.

  • No offshore development. Everything is written by our own team in Australia. Nothing is subcontracted overseas.
  • Your data stays onshore. Hosted in Australia, on infrastructure you own, under Australian law.
  • Every state, not just ours. Perth, Melbourne, Sydney, Brisbane, Adelaide and everywhere between.