You Can't Buy Your Way Out of Integration Debt

Every company carries a debt it never wrote down. It 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

Integration debt is the accumulated cost of every handoff between business systems that a person or a spreadsheet performs by hand instead of the systems performing it themselves. Like financial debt, it is taken on to move fast, it compounds, and the interest gets paid in hours, errors, and numbers nobody fully trusts.

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. 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, 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 stop believing any of them, and every important meeting starts by 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 at the worst 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.

Signs you are carrying it

If you want a checklist, any three of these means the balance is real.

• A weekly or monthly export that someone set up “temporarily” more than a year ago.
• The same customer, item, or account maintained in two systems by hand.
• A script or connector only one person understands, and that person is busy or gone.
• A month-end close that is mostly reconciliation rather than review.
• Meetings that open by arguing over whose number is right.
• A new hire whose first real job is retyping data from one screen into another.
• Growth plans that quietly assume somebody will just handle the extra volume.

How to size it

You do not need a consultant to put a number on it. Three lines on a page will do.

1. The interest. Hours per week each person spends moving or reconciling data between systems, times what those people cost.
2. The penalty rate. What the last three errors that traced back to a handoff actually cost: the credit memo, the late filing, the decision made on a number that was wrong upstream.
3. The ceiling. The one process that cannot double in volume without doubling the headcount behind it.

Two examples from my own desk. A multi-state excise-tax close that cost accounting hours every month, because the tax engine was right and the ledger still could not say which state was owed what. And the item master of an acquired company, where units of measure and pricing had to be reconciled before the first invoice could go out. Neither showed up on a budget line. Both were interest payments.

Why another app won’t fix it

When it 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 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, and it is only 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 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. Keep the debt small enough that it serves the business instead of quietly running it, and you are ahead of most.

Most of what I actually do for a living is help companies find that debt, total it up, and pay it down in the right order, increasingly with AI taking on the grunt work. If you recognized your own operation in this, it is a very fixable problem. That’s the conversation I’m always happy to have.