Skip to content
Meet us at Microsoft Ignite, booth #638Book a meeting

The tech debt guide

What is tech debt?

The complete guide to technical debt: types, examples, what it costs, and how to measure, prioritize and pay it down.

Tal Kimhi, Co-founder & CEO, Draftt Updated 20 min read

Definition

Tech debt (short for technical debt) is the future cost of work a team defers today: shortcuts in code, outdated dependencies, infrastructure past end of life and maintenance that never got scheduled. Like financial debt, it charges interest. Every change gets slower, riskier and more expensive until the debt is paid down.

Key takeaways

  • Tech debt starts the day you ship. Even state-of-the-art code falls behind as every new patch, release and security fix lands upstream, and for a critical vulnerability, falling behind becomes urgent within days.
  • Tech debt isn’t only messy code. A large share of the balance sits in dependencies, runtimes, databases, Kubernetes versions and cloud services aging out of support.
  • Some debt is a smart trade-off. The damage comes from debt nobody tracks, owns or plans to repay.
  • The interest is real: CIOs estimate tech debt at 20–40% of the value of their technology estate, and developers report spending about a third of their week on it.
  • Measure it as an inventory with owners and dates, not a feeling: what you run, how far behind it is, what it blocks and who fixes it.
  • Pay it down continuously, highest interest first, and automate the repetitive work so the balance stops growing back.
On this page

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.

How tech debt compounds The cost of each change rises steeply over time when tech debt goes unmanaged, and stays roughly flat when it is paid down continuously. HighLow TodayTime Cost of each change Debt left to compound Paid down continuously
Unmanaged, tech debt makes every change more expensive than the last. Paid down continuously, the cost of change stays flat.

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].

Version drift after shipping On ship day the service runs the latest version. Upstream releases patch, minor and major versions while the service stays on the version it shipped with, and the gap widens. A critical vulnerability is fixed only in a newer version. Upstream releases What you run v2.4.1 Ship day: latest 2.4.2 2.4.3 Critical CVE fix 2.5.0 2.6.0 3.0.0 Breaking changes still v2.4.1 Months later The gap is the debt
Nothing changed in your code. Everything changed around it.

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.

ScenarioThe interest you pay
Version drift and security
A critical CVE in a library you run four minor versions behindThe 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 behindSecurity patches stop coming, and the upgrade grows from a sprint into a rewrite.
Container base images built last quarterThey already contain packages with vulnerabilities that have been patched upstream since.
A fork of an open-source projectEvery 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 productionNode.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 8Open-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 endAngularJS 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 supportKubernetes 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 databaseCommunity support ended in November 2025, so the provider forces an upgrade or bills extended support.
Hosts on Amazon Linux 2It 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 providerEvery 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 servicesEvery fix has to be made five times, and one copy always gets missed.
No automated tests on the payment flowEvery change needs manual QA, so releases slow down and get batched.
The same library pinned in 400 repositoriesOne upgrade becomes 400 pull requests, each with its own tests, owners and review queue.
Feature flags that were never removedDead branches pile up in the code, and nobody is sure which paths still run in production.
Operations, ownership and AI
TLS certificates renewed by handMaximum certificate lifetimes shrink to 47 days by 2029, turning manual renewal into constant toil and outage risk.
A service with no clear ownerEvery alert, upgrade and audit question starts with a hunt for who is responsible.
Credentials hardcoded in configurationRotating a secret needs a code change and a deploy, so it rarely happens.
An AI model on a provider’s retirement scheduleWhen 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?

After Martin Fowler’s Technical Debt Quadrant (2009). Wording is ours.

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.

MetricWhat it tells youHow to calculate it
Lifecycle exposureHow much of your stack is past, or close to, end of lifeShare of components past EOL, in extended support, or reaching EOL in the next 6 months
Version lagHow far behind each component isMajor and minor versions behind the latest supported release
Technical debt ratioThe cost to fix code relative to the cost to build itRemediation cost ÷ development cost × 100
Ownership coverageWhether someone is accountableShare of components mapped to an owning team
Proactive shareWhether maintenance is planned or forcedPlanned maintenance ÷ all maintenance work
Time to remediateHow fast debt turns into a fixDays from a finding or EOL announcement to a verified fix in production
Maintenance capacityWhat the debt costs your teamShare 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.

Rank tech debt by business impact and by how much interest it charges, then act differently on each quadrant.

To place each item, answer five questions:

  1. Risk: is it exposed to known vulnerabilities, past end of life, or in scope for an audit control?
  2. Clock: when do the vendor’s end-of-support and extended-support dates land, and what will they cost?
  3. Blast radius: how many services, customers and how much revenue depend on it?
  4. Drag: how often does it slow down or block changes?
  5. 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. 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. 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. 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. 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. 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. 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. 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

TermWhat it isHow it relates to tech debt
BugA 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 systemAn 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.
MaintenanceThe 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 riskThe 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.

FAQ

Tech debt, answered.

When does tech debt start?

The day you ship. Even code that is state of the art at release starts falling behind as soon as the libraries, frameworks, runtimes and platforms it depends on publish new versions. Every patch you don’t adopt widens the gap, and when one of those patches fixes a critical security vulnerability, the gap becomes urgent.

How fast do you need to patch a critical vulnerability?

Faster every year. 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. PCI DSS requires critical and high-severity security patches to be installed within one month of release. If a dependency is several versions behind, the patch can turn into an upgrade across breaking changes, which is why staying close to current matters before the vulnerability is announced.

What is tech debt in simple terms?

Tech debt is work you put off that makes every future change cost more. Taking a shortcut, skipping an upgrade or leaving a system without an owner saves time now, but you pay it back later as slower releases, outages, security gaps and expensive migrations, and the cost grows the longer you wait.

Is tech debt always bad?

No. Taking on debt deliberately, for example to launch sooner, can be a sound business decision if you know the cost and plan to repay it. Tech debt becomes harmful when nobody tracks it, nobody owns it and the interest compounds: a dependency one version behind is a small upgrade, five versions behind is a migration.

What are examples of tech debt?

Common examples include duplicated code across services, missing automated tests, frameworks several major versions behind, runtimes and databases past end of life, Kubernetes clusters in paid extended support, certificates renewed by hand, services with no clear owner and AI models on a provider’s retirement schedule.

How do you measure tech debt?

Start with an inventory of everything you run, with versions and owners. Then track lifecycle exposure (how much of the stack is past or near end of life), version lag, ownership coverage, mean time to remediate, the share of engineering capacity spent on unplanned work and, for code, the technical debt ratio: remediation cost divided by development cost.

How much time should engineering teams spend on tech debt?

There is no universal number, but the share should be planned rather than left to whatever is left over. Many teams reserve a fixed slice of every sprint, and the most effective organizations run maintenance continuously with automation, so engineers spend their time on the decisions and changes that need judgment.

Who is responsible for tech debt?

Every component needs an accountable owner, usually the team that runs it. Platform engineering typically owns the shared foundations and the process, security and compliance set the requirements, and engineering leadership owns the budget and priorities. Debt without an owner is the debt that never gets fixed.

What is infrastructure tech debt?

Infrastructure tech debt is the gap between the infrastructure you run and what is current and supported: operating systems, runtimes, databases, Kubernetes versions, managed cloud services and certificates that are outdated or past end of life. It grows on the vendor’s schedule even when nobody touches the code, and it often shows up as security exposure, audit findings and extended-support fees.

Can AI fix tech debt?

AI coding agents can write a lot of the fix: upgrades, refactors and dependency bumps. What they lack on their own is context: what you run, what depends on what, who owns it, the order changes must ship in and what your policy allows. With that context and human approval where it matters, agents can pay down tech debt continuously instead of in occasional cleanup sprints.

What is the difference between tech debt and a bug?

A bug is a defect: the software does the wrong thing. Tech debt usually works correctly today but makes the system harder, slower and riskier to change. The two are related, since unpaid debt makes bugs more likely and harder to fix.

See your tech debt on one screen.

Book a 30-minute call. We’ll show you how MaintenanceOS finds, prioritizes and pays down tech debt across your code, cloud and runtimes.