You Can't Buy Your Way Out of Integration Debt
Every company carries debt it never wrote down. Not the loan kind. The kind that builds up in the seams between your software, where one system hands off to the next and a person, or a spreadsheet, is standing in the gap doing the handoff by hand. I call it integration debt, and in years of this work I’ve never walked into a growing company that wasn’t carrying some.
The name fits because it behaves like the financial kind. You take it on to move fast. A new tool solves today’s problem, so you wire it in with a quick export here and a copy-paste there, and you promise yourself you’ll do it properly later. Later has a way of not coming. The balance sits there and compounds, and you pay interest on it every week, usually without noticing. Software people already have a name for the code version of this, technical debt. Integration debt is the same idea one level up, living in the wiring between your systems instead of inside any one of them.
What it actually is
When people picture systems integration, they picture software talking to software. Integration debt is what you have when it doesn’t. Your CRM knows a customer by one name, your ERP knows them by another, and the billing system has a third version with a typo someone made in 2019. None of it reconciles on its own, so somebody reconciles it by hand.
That somebody is usually a sharp, well-paid person who spends a piece of every day being the integration. They pull a report out of one system, clean it up in Excel, and key it into the next one. The work gets done, the orders ship, the invoices go out. From the outside it looks fine. That is exactly why it’s dangerous. The cost is real but it hides inside salaries and late afternoons, so nobody ever sees a line item that says “systems don’t talk.”
How it piles up
Nobody decides to take on integration debt. It accrues one reasonable shortcut at a time. A “temporary” weekly CSV export that’s still running three years later. A field someone maintains in two places because connecting them felt like overkill at the time. A hand-built script that only one person understands, and that person left in 2022.
Each shortcut looks small on its own, and each one is defensible the day you make it. The problem is that they become load-bearing. Other processes get built on top of the workaround, so now you can’t change it without breaking three things downstream. No single hack is the debt. The debt is the tangle they form once there are enough of them, and the fact that the tangle now holds up the business.
What it really costs
The obvious cost is hours. Add up the time your team spends moving data between systems that should move it themselves and the number gets uncomfortable fast. But the hours are the cheap part.
The expensive part is trust. When the same number lives in four systems, you eventually stop believing any of them, and you start every important meeting arguing about whose figure is right instead of deciding what to do. Month-end close drags because half of it is reconciliation. Mistakes slip through because a human retyping a thousand rows will miss a few, and you find out which ones at the worst possible moment. Worst of all, you make real decisions on data that was quietly wrong three steps upstream.
And there’s a ceiling. A process that depends on a person retyping it does not scale. Double the volume and you don’t double the software, you double the swivel-chair labor, until the thing that worked fine at your old size becomes the reason you can’t grow into your new one.
Why another app won’t fix it
When this finally hurts enough, the instinct is to go buy something. A better tool, a shinier platform, the one a peer swears by. I understand the urge, and it almost never works, because the problem was never a missing app. The problem is that the apps you already have don’t talk. Adding another one just adds one more island that doesn’t talk either, one more data silo. You’ve increased the principal and called it a solution.
This is the one place I’ll be blunt: buying more software to fix systems that don’t communicate is like paying off a credit card with another credit card. It feels like motion. It’s just more debt. What actually clears the balance is getting your existing systems to hand off cleanly, with one agreed source of truth for each piece of data, so the same customer, the same order, and the same number mean one thing everywhere.
How to start paying it down
Treat it like debt, because that’s what it is.
First, stop adding to the principal. No new point-to-point hack without a plan for how it gets retired. That single rule slows the bleeding more than any tool.
Then pay the high-interest balances first. You don’t boil the ocean. You find the one handoff that breaks the most, or eats the most hours, or feeds the report leadership actually trusts, and you fix that one properly. Real integration, whether that’s middleware, an integration platform, or a few well-defined APIs, so the data flows once and flows automatically. Then you pick the next one.
What “good” looks like is quieter than people expect. Data moves between systems without anyone touching it. Each important number has one home and everything else reads from it. Your smart, expensive people go back to doing the judgment work you hired them for, instead of being the glue. You stop arguing about whose spreadsheet is right because there’s only one answer.
You will probably never get the balance to zero, and that’s fine. The goal isn’t perfection. It’s keeping the debt small enough that it’s serving the business instead of quietly running it.
Most of what I actually do for a living is help companies find that debt, total it up honestly, and pay it down in the right order, increasingly with AI taking on the grunt work. If you read this and recognized your own operation in it, you’re not in unusual company, and it’s a very fixable problem. That’s the conversation I’m always happy to have.