Every integration demo works. The order flows from the website to the ERP, the invoice appears, everyone nods, and the project moves to the next ticket. What nobody watches in the demo is the record that doesn't make it — the one with a malformed address, the one that arrives while the accounting system is restarting, the one that gets submitted twice because a customer double-clicked.
Those records are not edge cases. They are the normal operating condition of any system that talks to another system. The question isn't whether your integration will fail. It's whether the failure shows up as a quiet gap in your data three weeks later, or as a task in someone's queue tomorrow morning.
Error handling is the integration
Most integration work gets scoped as the happy path: pull from here, transform, write to there. That part is often the easy half. The expensive half is deciding what the system does when the write fails, when the target system times out, when a field that was always populated suddenly isn't, when the API returns a shape nobody planned for.
If that logic doesn't exist, the default behavior is almost always the worst one: the job errors out, writes a line to a log file no human reads, and the next scheduled run picks up where it left off — skipping the broken record permanently.
The four ways a sync actually goes wrong
- Duplicates. A request times out after the target system already saved the record. The retry creates a second copy. Now you have two orders, two invoices, or two contacts with slightly different data.
- Partial writes. The order header saves, the line items fail. You're left with a record that looks real but isn't, and reporting treats it as valid.
- Silent drops. A record fails validation, gets skipped, and nothing downstream knows it was supposed to exist. Nobody notices until a customer calls.
- Poison records. One malformed record fails, blocks the queue, and everything behind it stops. The integration looks "down" when really it's stuck on a single bad row.
Each of these has a standard, boring fix. The problem is that boring fixes get cut when a project runs long.
Make retries safe before you make them automatic
Retrying is the right instinct — most failures are transient. But a retry is only safe if sending the same request twice produces the same result as sending it once. In integration work that property is called idempotency, and in practice it usually means attaching a stable identifier to every message: an order number, a transaction ID, something the source system already owns.
The receiving side checks that identifier before it creates anything. Seen it already? Acknowledge and move on. That single design choice turns retries from a risk into a safety net, and it's far cheaper to build on day one than to clean up duplicate invoices on day ninety.
Give failed records somewhere to sit
Failures need a destination, not just a log line. The pattern is simple: when a record can't be processed after a reasonable number of attempts, it moves out of the main flow into a holding area — a quarantine table, a dead-letter queue, a dedicated list in your ERP or Business Hub. The main pipeline keeps running. The bad record waits.
What makes this work isn't the technology, it's the follow-through. Someone has to look at that holding area, understand what went wrong in plain language, fix the data, and resubmit. If the error message says `NullReferenceException`, your ops team can't act on it. If it says "Customer record missing billing country — required by accounting," they can.
Reconcile instead of trusting
The most underrated control in any integration is a daily comparison. Count what the source produced. Count what the target received. If the numbers don't match, somebody gets a message. It doesn't need to be sophisticated — a scheduled query and a short summary email catch an enormous class of problems that monitoring dashboards miss, because dashboards tell you the job ran, not that the data arrived correctly.
The same logic applies to totals, not just counts. Orders in equals orders out is good. Revenue in equals revenue out is better.
Name the human
Every integration should have one person whose name is attached to it and a defined expectation for how fast failures get cleared. Not an IT ticket queue in the abstract — a person who knows the business meaning of the data, checks the quarantine list, and escalates when something looks structural rather than cosmetic.
That person is also your early-warning system. When the same error class appears three weeks running, it's not a data problem anymore. It's a signal that an upstream process, a form, or a field definition needs to change.
Where to start
If you already have integrations running, you can audit them in an afternoon. Pick your highest-volume connection and ask three questions: Where do failed records go? Who looked at them this week? How would we know if a hundred records silently vanished?
If the answers are uncomfortable, that's useful information — and it's fixable without replacing anything. If you'd like help pressure-testing the connections between your ERP, CRM, and website, or designing integrations that fail loudly instead of quietly, reach out to Infraxio. We'll walk your data flows with you and tell you plainly where the gaps are.
