Technical debt: what it means, examples, how to measure it and how to reduce it
Technical debt is the future work a software system carries because of shortcuts, outdated components and design that no longer fits. Every system has some. The question is whether you know where it is, what it costs you each month, and whether it is shrinking or growing. This guide explains where the term technical debt comes from, how it builds up, typical examples from business software, how to measure it, and a practical plan for paying it down without stopping the business.
Sources were read on 12 November 2026: Ward Cunningham's OOPSLA 1992 experience report, the 2024 Stack Overflow survey (professional section), the PHP and Node.js release support pages, and Regulation (EU) 2024/2847 (Cyber Resilience Act).
Where the term comes from
Ward Cunningham introduced the metaphor in his experience report on the WyCash portfolio management system at the OOPSLA '92 conference. He wrote that "a little debt speeds development so long as it is paid back promptly with a rewrite", that "the danger occurs when the debt is not repaid", and that "every minute spent on not-quite-right code counts as interest on that debt". The point was never that shortcuts are wrong. It was that they have a cost that grows over time, and that someone has to decide consciously when to repay.
The cost is felt widely. In the 2024 Stack Overflow survey, the amount of technical debt was the most common frustration at work among professional respondents, named by 62%, whether they were individual contributors or managers.
How technical debt builds up
- Deadline shortcuts. A rule hard-coded instead of configurable, a test skipped, a copy of a function instead of a shared one. Fine if recorded and repaid.
- Ageing components. Frameworks, libraries, runtimes and operating systems all reach end of support. Code that was modern five years ago is now debt without anyone touching it.
- Changed business. The system was designed for one country, one product line, one warehouse. The company grew; the structure did not.
- Lost knowledge. The people who understood the design left, and documentation was never written.
- Many hands, no architecture. Several suppliers, each adding features in their own style. Now also faster with AI coding tools; see our AI in software development guide.
- Missing tests. Without automated tests, every change is risky, so people avoid improving code and work around it instead.
Examples from business software
| Debt | How it shows | Interest paid |
|---|---|---|
| Runtime past end of support | An old PHP, Node.js or .NET version on the server | No security fixes; hosting providers and auditors flag it |
| Hard-coded rules | VAT rates, prices or approval limits in code | A code change and a release for every business change |
| Copy-paste modules | The same logic in four places, slightly different | Bugs fixed in one place stay in three |
| No automated tests | Releases need days of manual checking | Fewer, larger, riskier releases |
| Manual deployment | Only a single engineer knows how to put a version live | Slow fixes, single point of failure |
| Spreadsheet integrations | Exports and imports between systems by hand | Hours each week, errors in reports |
| Outdated mobile SDKs | App targets an old Android or iOS version | Store warnings, then the app disappears for new users |
Support dates turn debt into a deadline
Component support is the most measurable form of technical debt, because every major platform publishes its dates. On 12 November 2026, the PHP project lists PHP 8.2 as receiving security fixes only until 31 December 2026, PHP 8.3 until 31 December 2027, PHP 8.4 until 31 December 2028 and PHP 8.5 until 31 December 2029; after that, a branch receives no security fixes at all. Node.js states that long-term support releases typically receive critical bug fixes for a total of 30 months, and that production applications should only use Active LTS or Maintenance LTS releases. App stores apply the same pressure: Google Play requires existing apps to target a recent Android API level to remain available to new users. Keeping a simple register of every component with its support end date turns vague debt into a dated plan.
How to measure technical debt
- Component age: each framework, library and runtime against its current version and support end date.
- Known vulnerabilities: dependency scanners list published vulnerabilities in the versions you use.
- Test coverage of critical paths: not a percentage target, but whether ordering, invoicing, login and payroll are protected by tests.
- Change lead time: how long a typical small change takes from request to production. Rising lead times are the clearest sign of interest being paid.
- Defect rate: bugs found after each release, and how many are regressions in things that used to work.
- Static analysis: tools estimate duplication, complexity and code smells. Useful for trends, not as a single verdict.
- The team's list: the shortcuts people know about. Often the most accurate measure, if anyone writes it down.
Technical debt in Scrum and agile teams
Agile teams handle technical debt best when it is treated as product work with a reason, not as engineers' hobby. Each item goes in the backlog with its business effect in plain words: "invoices take three days to change because rates are hard-coded" is something a product owner can prioritise; "refactor billing module" is not. Many teams reserve a fixed share of every sprint for debt items, and include tests and documentation in the definition of done so new work does not add more. Large items, such as a framework upgrade, become small projects with their own goal and end date.
A five-step plan to reduce technical debt
- Inventory. List components with support dates, known vulnerabilities, missing tests and the team's known shortcuts. A short code and architecture review by an outside team gives an unbiased starting point.
- Price the interest. For each item: what it costs now in time, risk or lost opportunity. Security and support deadlines go first.
- Protect before changing. Add automated tests around the parts you are about to improve, so improvements do not break what works.
- Repay in slices. Upgrade one component, extract one module, automate one deployment at a time, each delivered to production.
- Stop adding new debt. Code review, automated tests, dependency updates every month and decision records for shortcuts taken on purpose.
Why technical debt is becoming a legal matter
For products with digital elements sold in the EU, the Cyber Resilience Act turns part of technical debt into compliance. It applies from 11 December 2027, with reporting obligations under Article 14 from 11 September 2026. Under Article 13(8), manufacturers must handle vulnerabilities effectively for the support period, which must be at least five years unless the product is expected to be in use for less time. A product built on components that reach end of life during that period cannot meet the obligation without upgrades. Under the GDPR and NIS2, keeping systems patched is part of the security measures controllers and covered entities must take. See our Cyber Resilience Act guide and NIS2 compliance guide.
Repay, rebuild or replace?
Most systems should be repaid step by step. A rebuild is justified when the platform has no upgrade path, when the core cannot be changed safely, or when the business has outgrown the structure entirely. Even then, the safest route is to replace one part at a time behind a stable interface, so the business keeps running on the old system until each new part is proven. Our software architecture guide explains the structures that make this possible.
How we help
We take over systems built by other teams, start with an inventory and a dated plan, and pay down technical debt as part of software maintenance: dependency updates every month, framework upgrades planned ahead of support end dates, tests added around every change. For apps, mobile app maintenance keeps store requirements met. Code stays in your company's repository and documentation grows with it, so the knowledge is never held by one supplier.
Questions people ask
What is technical debt in simple terms?
Technical debt is the extra work a software system will need later because of shortcuts, outdated parts or unfinished design today. Like financial debt, a little can be useful to move fast. Left unpaid, the interest grows: every change takes longer, bugs multiply and some changes become too risky to attempt.
Is all technical debt bad?
No. Deliberate debt taken on to meet a real deadline, written down and paid back soon, can be a sound business decision. The harmful kinds are debt nobody knows about, and debt that is never paid back, such as a framework left years past its end of support.
How do you measure technical debt?
There is no single number. Useful signals are the age of frameworks and libraries against their support dates, known vulnerabilities in dependencies, automated test coverage of critical paths, time to make typical changes, the rate of bugs per release, and the list of known shortcuts kept by the team. Static analysis tools add estimates, but they only see part of the picture.
How do you reduce technical debt in Scrum or agile teams?
Make it visible as items in the backlog with a business reason, reserve a fixed share of every sprint for it, and include clean-up in the definition of done for new work. Large items, such as a framework upgrade, are planned as their own projects with a clear end.
When is it better to rebuild than to repay technical debt?
When the platform itself is at end of life with no upgrade path, when nobody can safely change the core, or when the business has changed so much that the system's structure no longer fits. Even then, rebuild step by step, replacing one part at a time, rather than with a single big switch.
Sources
- Ward Cunningham, The WyCash Portfolio Management System, OOPSLA '92 experience report (read 12 November 2026)
- Stack Overflow, 2024 survey, professional section (read 12 November 2026)
- PHP, Supported Versions (read 12 November 2026)
- Node.js, Releases (read 12 November 2026)
- Google Play Console Help, target API level requirements (read 12 November 2026)
- Regulation (EU) 2024/2847 (Cyber Resilience Act), Articles 13(8), 14 and 71 (read 12 November 2026)