Technical debt is a credit card, not a crime.
Every team borrows against the future to ship faster. That's fine. The problem starts when nobody checks the statement. Here's how to tell good debt from bad, what the interest really costs, and how to pay it down without stopping the business.
By Anvexis Stack Engineering8 min read
What technical debt actually is
Technical debt is the gap between the code you have and the code you'd write with more time and knowledge. Like a credit card, it lets you buy something now, a launch date or a demo, and pay later.
The metaphor is older than most of the code it describes. Ward Cunningham introduced it in a 1992 experience report: shipping first-time code is like going into debt, a little debt speeds development as long as it's paid back promptly, and the danger occurs when the debt is not repaidSource [1]. His definition of interest is still the best one: every minute spent on not-quite-right code counts as interest on that debtSource [1].
The interest you don't see on the statement
Technical debt rarely shows up as a line item. It shows up as features that take three weeks instead of three days, releases nobody dares make on a Friday, and new developers who need months before they feel safe changing anything. The principal is the shortcut taken long ago; the interest is the slowdown you pay every day since.
It's a big number in aggregate. In Stripe's Developer Coefficient survey of executives and developers across six countries, developers estimated an average work week of 41.1 hours, of which 17.3 went on maintenance such as debugging and refactoring, and 13.5 on technical debt specificallySource [3]. Maintenance of legacy systems and technical debt was also the most-cited drag on productivity, named by 52% of developersSource [3]. These are self-estimates from 2018, so treat the exact figures with care, but the direction matches what every engineering team feels.
Good debt and bad debt
Martin Fowler's technical debt quadrant is a useful way to sort it. Debt can be deliberate or inadvertent, and prudent or recklessSource [2]. Prudent, deliberate debt is a team knowingly taking a shortcut to ship earlier and weighing that against the cost of repaying itSource [2]. Reckless, deliberate debt is choosing “quick and dirty” because clean code feels unaffordableSource [2].
The inadvertent kinds are subtler. Reckless, inadvertent debt comes from a team that doesn't know good design practices and doesn't realise how much it's borrowing. Prudent, inadvertent debt is the interesting one: Fowler argues it's inevitable even for excellent teams, because you often only learn the better design by building the first oneSource [2]. That debt isn't a failure. Not repaying it is.
Good debt vs. bad debt
| Good debt | Bad debt |
|---|---|
| Deliberate and written down | Accidental and undocumented |
| Taken to learn from real users | Taken because “we'll fix it later” |
| Isolated behind a clean interface | Spread across the codebase |
| Has a repayment ticket | Has a legend |
Making debt visible
You can't manage what nobody can see. Keep a short, honest register of known debt: what it is, where it lives, what it costs today, and what it would take to fix. Engineers usually know where the worst problems are; the register turns that knowledge into something product owners can weigh against new features.
Express the cost in business terms wherever possible: slower delivery in part of the product, recurring incidents, upgrade work blocked, or onboarding time. That makes repayment a business decision rather than an engineering wish.
A repayment plan that works
Make it visible
Keep a debt register: what, where, why, and the cost of leaving it. Review it when you plan work.
Pay interest first
Fix debt in the areas you change most. Ignore the quiet corners nobody touches.
Budget it
Reserve a steady slice of each iteration instead of a “refactor quarter” that never comes.
Stop new bad debt
Code review and tests at the door are far cheaper than cleanup later.
Paying it down without stopping the business
Big rewrite projects rarely succeed. They take longer than planned, compete with urgent features, and often recreate the old problems in new code. Steady repayment works better: improve the code you touch for each feature, and set aside a consistent share of each iteration for the worst items on the register.
Prioritize debt that sits in code you change often or that causes incidents. Messy code in a corner nobody touches can wait; messy code on the path of every new feature can't. Where a rewrite really is necessary, replace the old system piece by piece behind a stable interface, so value ships continuously instead of in one terrifying launch.
Debt in ERP projects
ERP systems accumulate a particular kind of debt: customizations that patch core behaviour, modules copied and modified instead of extended, and integrations built without retries or logging. The interest is paid at every version upgrade, when each shortcut has to be found, understood, and redone.
Before each upgrade, review customizations against the new version's standard features. Some can simply be removed; others can be rebuilt as clean extensions that will survive the next upgrade too. Our guide to planning an ERP migration shows how to fold this review into the upgrade itself, and why Odoo implementations fail covers how to avoid taking on the worst of it in the first place.
Debt lives in data and infrastructure too
Code isn't the only place debt hides. Data debt is duplicate customers, free-text fields used as structured data, and spreadsheets that quietly became a system of record. Infrastructure debt is the server configured by hand that nobody dares reboot, the backup that has never been restored, and the deployment that only works from one laptop.
Both charge interest the same way: every report takes longer to build, every incident takes longer to diagnose, and every migration gets more expensive. Put them on the same register as code debt, with the same honest cost estimates. Automating infrastructure as code and restoring backups on a schedule are two of the cheapest repayments available.
Who owns the register?
A register nobody owns becomes a graveyard of good intentions. Give it a named owner on the engineering side who keeps it current, and review it with the product owner whenever work is planned, alongside new features rather than after them. Debt competes for the same time as features, so it should be prioritized in the same conversation.
Keep entries short and comparable: the area affected, the symptom people feel, a rough fix size, and the cost of waiting another quarter. Close entries when they're repaid. A shrinking register is one of the most motivating charts an engineering team can look at.
Signs your debt is getting expensive
- Simple changes take much longer than they used to
- The same kind of bug keeps coming back
- Only one person understands a critical part
- Upgrades are repeatedly postponed
- Releases need manual steps and luck
- New developers take months to make a safe change
Dependencies are debt too
Outdated libraries, frameworks, and runtimes accumulate quietly. Each year a dependency is left behind, the eventual upgrade gets harder and security fixes become harder to apply. Treat dependency updates as routine maintenance, done in small steps every month, rather than a project that waits until something forces it.
Automated tools can propose updates and run the test suite against them, which turns most minor updates into a quick review and merge.
Measure whether repayment is working
Debt repayment should show up in delivery numbers. DORA, the research programme behind the best-known software delivery metrics, now tracks five: change lead time, deployment frequency, failed deployment recovery time, change fail rate, and deployment rework rateSource [4]. Change lead time is the time from a commit to running in production; change fail rate is the share of deployments that need immediate interventionSource [4].
You don't need a dashboard empire to start. Track lead time and change fail rate for the parts of the system you're repaying, and check them monthly. If repayment is targeted well, both improve within a few months. If they don't, revisit which debt you're paying down and whether it really sits on the critical path.
Prevent new debt cheaply
The cheapest debt is the debt you never take on. Code review, automated tests on critical paths, a consistent project structure, and clear conventions catch many shortcuts before they become permanent. None of these need heroics; they need habits.
When a shortcut is genuinely worth taking, record it in the register with the reason and a rough plan to repay it. Deliberate debt with a plan is a tool; forgotten debt is a trap.
Talk about it in business language
Executives rarely fund “refactoring”. They do fund faster delivery, fewer incidents, and cheaper upgrades. Describe each repayment by the outcome it buys: the checkout change that will take days instead of weeks, or the upgrade that becomes possible this year instead of next.
If you start from nothing, spend the first month on visibility rather than fixes: build the register, agree the top five items with the product owner, and measure lead time for the areas they affect. Then start paying, a slice every iteration. If you'd like an outside view first, a short architecture review is often the fastest way to find the expensive debt.
Frequently asked questions
Is all technical debt bad?
How much time should we spend paying down technical debt?
Should we rewrite the system from scratch?
How do we explain technical debt to executives?
Sources
- [1]The WyCash Portfolio Management System (OOPSLA '92 experience report) (opens in a new tab)Ward Cunningham, 1992
- [2]Technical Debt Quadrant (opens in a new tab)Martin Fowler, 14 October 2009
- [3]The Developer Coefficient (opens in a new tab)Stripe, September 2018
- [4]DORA's software delivery performance metrics (opens in a new tab)DORA, updated 5 January 2026
Written by Anvexis Stack
We build Odoo, AI, web, and cloud systems for growing companies, and we write about the patterns we use. This is engineering guidance, not a product guarantee: check vendor details for your version before you decide. Last reviewed .
Keep exploring
Tech stack & standards
The technologies we use across ERP, web, mobile, AI, and infrastructure, and the engineering standards every project follows.
InsightsWhy Odoo projects fail
ERP failures are rarely technical. The organizational patterns behind failed Odoo projects, and the process changes that prevent them.
OdooCustom Odoo modules
Upgrade-safe custom Odoo modules in Python and OWL: inheritance only, tested, documented, and OCA-style. No core patches, ever.
Next step
Got a tangled system? Let's untangle it together.
Thirty minutes with an engineer, no slide deck required. You'll leave with a clearer picture, whether or not we work together.
