What is tech debt?
Tech debt, or technical debt, is the gap between how a system is built today and how it would need to be built to change easily, safely and cheaply. It builds up two ways. Teams take it on when they choose the faster path now and leave work for later. And it accrues on its own when the world moves on while the system stands still: a framework ships a new major version, a database reaches end of life, a cloud provider retires an API.
Principal and interest
Ward Cunningham coined the metaphor in 1992, in an experience report on a portfolio management system called WyCash[1]. Shipping code that isn’t quite right is like borrowing money: it speeds you up, as long as you pay it back. The principal is the work needed to fix the shortcut. The interest is the extra effort every future change costs while it stays: the workaround everyone has to remember, the upgrade that is now three versions wide instead of one, the incident that takes hours because nobody understands the code.
The metaphor holds in one more way: the interest compounds. A dependency one version behind is a small upgrade. Five versions behind, it is a migration that touches every service built on it.
Tech debt or technical debt?
They mean the same thing. “Tech debt” is the everyday short form of “technical debt.” Some organizations say “technology debt” for the broader, stack-wide version that includes infrastructure, cloud services and end-of-life software, which is how this guide uses the term.
Tech debt starts the day you ship
There is a common assumption that tech debt only comes from shortcuts, and that well-written, up-to-date code is debt-free. It isn’t. The day you ship, you run the latest version of everything. The next day, the world moves on and your code doesn’t. Every new patch release of an open-source library you depend on, every new runtime, framework and Kubernetes version, every cloud API deprecation puts you one step further behind. Nobody did anything wrong. The debt simply accrues with time.
Each step is small, which is why it is easy to ignore. But the steps compound into version drift: one patch behind is a five-minute bump, three minors behind is a sprint, two majors behind is a migration. And the clock runs faster than most teams expect. Kubernetes ships about three minor versions a year and supports each for roughly 14 months. .NET 8, a long-term support release from November 2023, left support on November 10, 2026[11].
When the gap becomes critical: security
Most of the time, drift is a slow cost. When a critical vulnerability lands, it becomes urgent. Log4Shell is the textbook case: disclosed on December 9, 2021, it took four Log4j releases, 2.15.0, 2.16.0, 2.17.0 and 2.17.1, by December 28 to close it and its follow-on flaws[10]. A team that was fully current on December 8 had to upgrade four times in under three weeks. A team that was several versions behind first had to climb the gap.
And the window keeps shrinking. Mandiant measured an average time-to-exploit of five days for vulnerabilities exploited in 2023, down from 32 days in 2021–2022 and 63 days in 2018–2019[9]. Compliance frameworks set their own clocks: PCI DSS requires critical and high-severity security patches to be installed within one month of release[12]. If the fix ships only in a version you are three releases behind, the patch is no longer a patch. It is an upgrade you now have to make under pressure.
That is why tech debt can’t be solved once. It can only be managed continuously: staying close to current, so that when the critical fix arrives, it is a small step instead of a migration.
Tech debt examples
Tech debt is easiest to recognize by the interest it charges. Here are twenty common scenarios, grouped by where they live, and what each one costs you.
| Scenario | The interest you pay |
|---|---|
| Version drift and security | |
| A critical CVE in a library you run four minor versions behind | The fix ships only in the latest version, so a one-line patch becomes an upgrade across breaking changes, under time pressure. |
| A framework two major versions behind | Security patches stop coming, and the upgrade grows from a sprint into a rewrite. |
| Container base images built last quarter | They already contain packages with vulnerabilities that have been patched upstream since. |
| A fork of an open-source project | Every upstream release has to be merged by hand, so the fork falls further behind with each one. |
| Runtimes and frameworks | |
| .NET 8 services | .NET 8 and .NET 9 both left support on November 10, 2026, so they no longer receive security updates. |
| Node.js 20 or Python 3.9 in production | Node.js 20 reached end of life in April 2026 and Python 3.9 in October 2025; new vulnerabilities in them go unpatched. |
| Spring Boot 2 on Java 8 | Open-source support for Spring Boot 2 has ended, and Spring Boot 3 requires Java 17, so the upgrade is a framework and runtime migration at once. |
| An AngularJS front end | AngularJS support ended in 2021. Moving to a modern framework is a rewrite, and it gets bigger with every feature added on top. |
| Infrastructure and cloud | |
| Kubernetes clusters past standard support | Kubernetes ships about three minor versions a year, each supported for roughly 14 months. Past that, providers charge for extended support; Amazon EKS bills $0.60 per cluster-hour instead of $0.10. |
| PostgreSQL 13 on a managed database | Community support ended in November 2025, so the provider forces an upgrade or bills extended support. |
| Hosts on Amazon Linux 2 | It reached end of life on June 30, 2026; the move to a newer OS touches every image, agent and script built for it. |
| Infrastructure as code pinned to an old provider | Every new cloud feature or fix needs a provider upgrade first, often with breaking changes to unrelated resources. |
| Code and architecture | |
| Copy-pasted logic in five services | Every fix has to be made five times, and one copy always gets missed. |
| No automated tests on the payment flow | Every change needs manual QA, so releases slow down and get batched. |
| The same library pinned in 400 repositories | One upgrade becomes 400 pull requests, each with its own tests, owners and review queue. |
| Feature flags that were never removed | Dead branches pile up in the code, and nobody is sure which paths still run in production. |
| Operations, ownership and AI | |
| TLS certificates renewed by hand | Maximum certificate lifetimes shrink to 47 days by 2029, turning manual renewal into constant toil and outage risk. |
| A service with no clear owner | Every alert, upgrade and audit question starts with a hunt for who is responsible. |
| Credentials hardcoded in configuration | Rotating a secret needs a code change and a deploy, so it rarely happens. |
| An AI model on a provider’s retirement schedule | When the provider retires it, calls fail, and every feature built on it breaks. |
Notice how many of these never touch application code, and how many were good decisions when they were made. The runtime, the framework and the cluster were current on the day they shipped. Lifecycle dates are from endoflife.date[11]. For more on certificates and AI models, see the 47-day certificate guide and the AI model end-of-life schedule.
Types of tech debt
Most tech debt falls into one of nine types. Naming the type tells you who owns it and how it gets paid down.
- Code debt
- Duplication, tangled logic and missing abstractions that make every change touch more than it should.
- Architecture debt
- Designs that no longer fit the scale or the product: a shared database every team coordinates around, a monolith that ships at the speed of its slowest team.
- Dependency debt
- Libraries, frameworks and container base images that have fallen behind supported versions.
- Infrastructure and lifecycle debt
- Operating systems, runtimes, databases, Kubernetes versions and managed cloud services nearing or past end of life. The vendor sets this clock, so it grows even when nobody touches the code.
- Security debt
- Known vulnerabilities and misconfigurations left open. Most of it is a symptom of dependency and lifecycle debt.
- Test debt
- Missing, slow or flaky tests that make every change a gamble.
- Knowledge debt
- Systems only one person understands, and documentation that stopped matching reality.
- Ownership and process debt
- Components without an owner, and no budget or process to schedule maintenance at all.
- AI-generated debt
- Code produced faster than it can be reviewed and maintained, plus AI models and prompts that expire on a provider’s schedule.
Infrastructure and lifecycle debt deserves special attention. Gartner finds that, on average, about 40% of infrastructure systems have technical debt concerns[5], and it grows on a schedule you don’t control.
Is tech debt bad? The four kinds of debt
Not always. Martin Fowler’s Technical Debt Quadrant[2] sorts debt by two questions: was it taken on deliberately or inadvertently, and was the decision prudent or reckless?
Reckless and deliberate
“No time to design it. Ship it.”
The debt that hurts most. Nobody plans to repay it.
Prudent and deliberate
“Ship now, clean up right after launch.”
A business decision, with a plan to repay.
Reckless and inadvertent
“We didn’t know better.”
Fixed with skills, reviews and standards.
Prudent and inadvertent
“Now we know how it should have been built.”
Unavoidable. Learning shows what to change.
Prudent, deliberate debt can be the right call: launching a quarter early can be worth a month of cleanup. The debt that does the damage is the debt nobody chose and nobody tracks. That includes a fifth kind the quadrant leaves out: debt that accrues on its own. Code that was well built becomes debt as soon as its dependencies move on, and that starts the day it ships.
What causes tech debt?
- Delivery pressure. Shipping now and cleaning up “later,” with no later on the plan.
- Vendor lifecycles. Every runtime, database, operating system and cloud service ships with an end-of-life date someone else sets.
- Growth. Systems designed for ten engineers and one region end up serving hundreds of engineers and many regions.
- Unclear ownership. Reorgs and turnover leave services, pipelines and cloud accounts without an owner.
- No maintenance budget. Upgrades compete with features for the same sprint, and features usually win.
- AI-assisted output. Teams now ship more code, services and dependencies than they can review and maintain.
What does tech debt cost?
Tech debt rarely appears as a line item, which is why it is easy to underfund. The research that does put a number on it is consistent: it is large, and it is growing.
20–40%
CIOs’ estimate of tech debt as a share of the value of their entire technology estate, before depreciation.
McKinsey survey of 50 CIOs, 2020 [3]
⅓ of the week
Developers report spending 13.5 hours of a 41.1-hour week on technical debt, plus 3.8 hours on bad code.
Stripe, The Developer Coefficient, 2018 [4]
$1.52 trillion
Accumulated technical debt in US software, within a $2.41 trillion annual cost of poor software quality.
CISQ, 2022 [6]
~40%
Share of infrastructure systems with technical debt concerns, on average across asset classes.
Gartner [5]
And it is getting worse. Forrester expected more than half of technology decision-makers to see their tech debt reach moderate or high severity in 2025, rising to 75% in 2026[7]. Inside the business, the interest shows up in six places:
- Speed: features take longer because every change drags the debt along with it.
- Reliability: fragile, poorly understood systems fail more often and take longer to recover.
- Security: software past end of life stops receiving patches, so known vulnerabilities stay open.
- Compliance: auditors flag unsupported software and missed patch windows.
- Cloud cost: extended support fees for old databases and Kubernetes versions, and oversized infrastructure nobody dares to touch.
- People: engineers spend their week on toil instead of the work they were hired to do, and the best ones leave.
How to measure tech debt
You can’t pay down a balance you can’t see. Measure tech debt like a portfolio, not a feeling. Start with an inventory of everything you run: services, repositories, dependencies, runtimes, databases, clusters, cloud services, certificates and AI models, each with its version, environment and owner. Then track a handful of metrics on top of it.
| Metric | What it tells you | How to calculate it |
|---|---|---|
| Lifecycle exposure | How much of your stack is past, or close to, end of life | Share of components past EOL, in extended support, or reaching EOL in the next 6 months |
| Version lag | How far behind each component is | Major and minor versions behind the latest supported release |
| Technical debt ratio | The cost to fix code relative to the cost to build it | Remediation cost ÷ development cost × 100 |
| Ownership coverage | Whether someone is accountable | Share of components mapped to an owning team |
| Proactive share | Whether maintenance is planned or forced | Planned maintenance ÷ all maintenance work |
| Time to remediate | How fast debt turns into a fix | Days from a finding or EOL announcement to a verified fix in production |
| Maintenance capacity | What the debt costs your team | Share of engineering time spent on unplanned and maintenance work |
For code debt specifically, the technical debt ratio compares the estimated effort to fix code issues with the effort it took to build the code; some code-analysis tools rate 5% or less as healthy. For everything else, lifecycle exposure and proactive share say more. One Draftt customer, a Fortune 500 retailer, went from 20% to 90% of its planned maintenance work done proactively once the debt was visible, owned and prioritized. Read the customer stories.
How to prioritize tech debt
You will never pay it all off, and you shouldn’t try. Prioritize by the interest rate, not the size of the balance: a messy component nobody touches costs little, while an outdated dependency in your busiest service charges interest every day.
Schedule it
High impact, slow interest. Plan the work, with a date, before the vendor’s clock or an audit forces it.
Pay it now
High impact, high interest. Past end of life, exposed or blocking the roadmap. This is the top of the queue.
Accept and monitor
Low impact, low interest. Write it down, set an alert, and spend your capacity elsewhere.
Automate it
Low impact, high interest. Frequent, repetitive work like patch upgrades and certificate rotation. Take people out of the loop.
To place each item, answer five questions:
- Risk: is it exposed to known vulnerabilities, past end of life, or in scope for an audit control?
- Clock: when do the vendor’s end-of-support and extended-support dates land, and what will they cost?
- Blast radius: how many services, customers and how much revenue depend on it?
- Drag: how often does it slow down or block changes?
- Effort and order: how big is the fix, and what has to move first?
How to reduce tech debt: a continuous program
Cleanup sprints and “stability quarters” work once, and then the balance grows back. What works is a program that runs all the time, the same way your build pipeline does. It has seven parts.
- 1
Make it visible
Build one live inventory across code, cloud and runtimes: every service, dependency, runtime, database, cluster, certificate and AI model, with versions and environments. Refresh it automatically; a spreadsheet is out of date the day after it is finished.
- 2
Assign owners
Map every component to an accountable team. Unowned components are the first thing to fix, because nothing else on this list happens without an owner.
- 3
Prioritize by impact and the clock
Rank by business impact, risk and the vendor’s end-of-life dates, not by whoever complains loudest. Fix where the interest is highest.
- 4
Reserve capacity
Give maintenance a fixed, protected share of engineering time instead of whatever is left after features. Debt that competes with the roadmap every sprint loses every sprint.
- 5
Automate the repetitive
Patch and minor upgrades, certificate rotation, base image refreshes and dependency bumps should run on every commit and every dependency alert, not wait for a meeting. Increasingly, AI agents open the pull request; give them the context they need and keep approvals where they matter.
- 6
Stop new debt at the source
Golden paths, approved versions, policy checks in CI and a definition of done that includes upgrades keep today’s shortcuts from becoming next year’s migration.
- 7
Verify and report
Count debt as paid only when the fix is running in production, not when a ticket closes. Report the trend to leadership in business terms: risk retired, fees avoided, time returned.
Three sizes of paydown: upgrades, migrations and fleet-wide changes
Paying down tech debt comes in three sizes, and each needs a different approach.
- Upgrades are small and frequent: patch and minor versions, base images, certificates. Do them continuously and automatically, so drift never builds up.
- Migrations are large and rare: .NET Framework to modern .NET, Java 8 to 21, AngularJS to a current framework, a proprietary platform to open source, COBOL to Java. Plan them like projects, break them into verifiable steps, and test each step in a production-like environment.
- Fleet-wide changes are small but everywhere: the same dependency bump or API change across hundreds of repositories. The work is easy; the coordination is not. Owners, review queues, rollout order and verification across the fleet are where these stall.
For well-understood transformations, deterministic, rule-based changes are predictable and safe to apply at scale. AI agents handle the long tail that rules can’t express. Either way, the change is only done when it is verified and running in production, not when the pull request opens.
The hard part isn’t any single step. It is keeping all seven running across hundreds of services and dozens of teams. That is the work a maintenance line does in a modern software factory.
Tech debt in the age of AI
AI changes both sides of the ledger.
It adds debt faster. Coding assistants and agents let teams ship more code, more services and more dependencies, while the team that maintains them stays the same size. GitClear’s analysis of 211 million changed lines of code found an eightfold increase in duplicated blocks of five or more lines during 2024, and the first year in which copy-pasted code exceeded code moved to be reused[8]. AI models are a new kind of debt too: providers retire them within months, and every feature built on a retired model breaks.
It can pay debt down faster. An agent can write the upgrade, the refactor or the dependency bump in minutes. What it can’t do on its own is decide which change matters, in what order, for which owner and under which policy. Give agents that context, and approval where the risk calls for it, and tech debt becomes something you pay continuously instead of in occasional cleanup sprints. Why “just let an agent fix it” keeps failing.
Tech debt vs. bugs, legacy systems and maintenance
| Term | What it is | How it relates to tech debt |
|---|---|---|
| Bug | A defect: the software does the wrong thing. | Tech debt usually works today but makes change slower and riskier. Unpaid debt makes bugs more likely and harder to fix. |
| Legacy system | An older system the business still depends on. | Often the biggest concentration of tech debt, but stable, supported legacy that rarely changes can carry little interest. |
| Maintenance | The ongoing work of keeping software current, secure and compliant. | Maintenance is how tech debt is paid down and prevented. Skipped maintenance is how most of it is created. |
| Technical risk | The chance that something fails or is exploited. | Debt past end of life is risk with a date on it. |
How to explain tech debt to the business
“We need time to refactor” loses to the roadmap every time. Translate tech debt into the three things leadership already manages: speed, risk and cost. Name the component, the date and the price.
“Fourteen services run on a database version that leaves standard support in March. Upgrading now takes three weeks. After March, it costs us extended-support fees every month, leaves us without security patches and puts our next audit at risk.”
A sentence like that gets a decision. A backlog of “refactor X” tickets does not. Report progress the same way: risk retired, fees avoided and engineering time returned to the roadmap.
Tools for managing tech debt
No single tool covers tech debt end to end. Most organizations combine five categories:
- Code analysis: Static analysis that flags complexity, duplication and code smells, and estimates remediation effort for code debt.
- Composition analysis and vulnerability scanning: Finds outdated and vulnerable dependencies and images.
- Lifecycle and end-of-life tracking: Tracks every runtime, database, cluster and cloud service against its vendor’s support dates.
- Issue tracking and engineering metrics: Where debt becomes planned, owned work, and where you see what it costs in capacity.
- A maintenance layer: Connects the rest: one inventory, prioritized by impact, routed to owners and agents under your policies, and verified when it is fixed.
Draftt’s MaintenanceOS is that maintenance layer. It connects to the tools you already run with read-only access, keeps a live inventory of tech debt across code, cloud and runtimes, ranks it by business impact, routes it to the owning teams and AI agents under your policies, and verifies every fix in production. See how teams use it to manage tech debt.