Why integrations fail in production (not theory, what actually breaks)

Jayesh Pamnani — Mon, 27 Apr 2026 13:35:24 +0000

On paper, integrations look simple.

ERP connects to CRM. CRM connects to external tools. APIs handle the rest.

Everything looks clean.

Then you go live - and things slowly start breaking.

Not immediately. But enough to cause real problems.

Here’s what actually goes wrong.

1. Systems don’t agree on what data means

A “customer” is not the same everywhere.

In CRM - it’s a lead with activity
In ERP - it’s a billing entity
In other tools - it might just be an email

You map fields and think you're done.

Then you get:

duplicates
missing data
updates overriding each other

The issue is not mapping. It’s the data model.

2. No clear source of truth

Multiple systems updating the same fields is where things fall apart.

CRM updates phone number
ERP updates it later
Another tool syncs an older value back

Now you have conflicting data and no clarity.

If ownership is not defined, consistency is impossible.

3. APIs work, workflows don’t

APIs returning 200 does not mean your system works.

Example:

CRM creates a deal
ERP needs validated customer data
External tool triggers actions

If timing and sequence are not defined:

things happen too early
required data is missing
processes silently fail

APIs move data. Workflows define behavior.

4. No handling for failure

Production always fails at some point.

API timeouts
network issues
third-party downtime

If your system assumes everything works:

data gets lost
retries create duplicates
processes break halfway

You need:

retries
idempotency
proper logging

Otherwise, failures stay hidden until users notice.

5. Real-time everywhere (when it shouldn’t be)

Real-time sounds good. It’s often a mistake.

It creates:

race conditions
higher load
harder debugging

Not everything needs to be instant.

Some flows should be queued or batched.

6. No visibility across systems

When something breaks, no one knows where.

Each system has its own logs.

There is no single place to see:

what triggered
what failed
what is pending

Without visibility, debugging becomes guesswork.

What changed for us

We stopped treating integration as just connecting APIs.

Instead:

defined ownership of data
controlled workflows centrally
handled failure as a default case
made everything traceable

Final thought

Most integrations don’t fail because of bad code.

They fail because no one designed how systems should behave together.

DEV Community: Jayesh Pamnani