McKinsey published a number that should scare every CTO: technical debt represents 20-40% of an organization's total technology estate value. Not 20-40% of the IT budget. Of the entire technology estate — the accumulated value of every system, platform, and tool the company has built or bought.
CAST Software analyzed 2.3 billion lines of code across 2,200 applications and estimated 61 billion person-days of global repair time for accumulated technical debt. That is not a typo. Billion.
I have run an engineering studio for 11 years. We inherit codebases with technical debt. We also create technical debt, because every engineering team does. The question is not whether you have debt. It is whether you manage it or let it compound.
What Technical Debt Actually Is
Technical debt is not bad code. Bad code is just bad code.
Technical debt is the accumulation of shortcuts, deferred decisions, and aging dependencies that slow down future development. It is the decision to skip writing tests because the deadline was tight. The framework you chose in 2017 that reached end-of-life in 2021. The database schema that made sense for 100 users but breaks at 10,000. The API design that worked for one client but cannot support three.
Every one of these decisions was rational at the time. Ship fast, fix later. The problem is that "later" compounds. Each shortcut makes the next feature take longer. Each deferred upgrade makes the eventual migration more expensive. Each missing test makes every deployment riskier.
The Numbers
McKinsey (2022, updated 2024): 20-40% of technology estate value is technical debt. They also found that companies with high technical debt spend 10-20% more on software delivery and experience 2x the defect rate compared to low-debt peers.
Gartner (2025 forecast): Through 2026, accumulated technical debt will cause over 40% of large enterprises to experience "significant service degradation." Not inconvenience. Degradation.
CAST Software (2024 CRASH Report): Analyzed 2,200 applications across 2.3 billion lines of code. Average technical debt: $3.61 per line of code. For a 500,000-line application (medium SaaS product), that is $1.8 million in embedded debt.
Stripe Developer Coefficient (2023): Developers spend an average of 42% of their time dealing with technical debt and maintenance. That means for every 2 developers you hire, you effectively lose almost 1 to debt servicing.
How It Happens
I have seen the same pattern across dozens of client engagements:
Year 1: Ship fast. Framework choice is good. Architecture is simple and appropriate. Tests are sparse but the team knows the code. Debt is low.
Year 2-3: Team grows. New engineers do not understand the original decisions. Features are bolted on. The test suite is inconsistent. The original framework releases a major version but nobody has time to upgrade. Debt accumulates.
Year 4-5: The framework is now 2 major versions behind. Dependencies have security vulnerabilities. The database schema has been patched 50 times. New features take 3x longer than they should because every change touches fragile code. Hiring is hard because good engineers do not want to work in legacy stacks.
Year 6+: The CTO starts talking about a rewrite. The CEO asks why the team is slow. The answer is technical debt, but it is invisible to everyone except the engineers.
PropertyRate hit year 5 with a Kohana codebase. Kohana reached end-of-life in 2017. No security patches. No community. No new hires who knew the framework. We migrated to Laravel without downtime while the platform continued processing thousands of daily appraisal orders across all 50 US states.
What To Do About It
Allocate 15-20% of every sprint
Not a "tech debt sprint" once a quarter. A consistent allocation every cycle. 15-20% of engineering capacity goes to debt reduction: upgrading dependencies, improving test coverage, refactoring the ugliest module, migrating off deprecated APIs.
This is not a tax on velocity. It protects velocity. The teams that skip debt reduction for 6 months to "ship faster" end up slower by month 9 because every feature fights the accumulated shortcuts.
Prioritize by business impact
Not all debt is equal. A deprecated logging library is annoying but not blocking. A database query that scans 10 million rows on every page load is an emergency. An authentication module with a known vulnerability is a liability.
Rank debt by: business impact (does it affect users, revenue, or security?), blast radius (how many features touch this code?), and migration difficulty (is this a 2-hour fix or a 2-month project?). Fix the high-impact, low-difficulty items first.
Migrate incrementally
The full rewrite is almost always a mistake. You spend 12 months rebuilding a system that already works, during which no new features ship, and when you launch the rewrite, you discover it has its own bugs.
PropertyRate did not get a rewrite. It got an incremental migration. We refactored module by module, replaced Kohana patterns with Laravel equivalents, and shipped each module to production independently. The platform never went down. Features continued shipping during the migration.
Greek House followed the same pattern. The previous team had a large codebase with accumulated debt. We did not rewrite it. We refactored it to Laravel and React best practices, set up CI/CD, and started shipping same-day releases. The platform went from stalled releases every few months to daily deployments.
Measure it
You cannot manage what you cannot see. Track: deployment frequency (are you shipping faster or slower over time?), lead time for changes (how long from commit to production?), defect rate (are bugs increasing?), and developer survey scores (is the team frustrated with the codebase?).
If deployment frequency is declining and lead time is increasing, you have a debt problem. The numbers do not lie.
The Business Case
Technical debt is invisible to the business until it is not. The moment a competitor ships a feature in 2 weeks that takes your team 3 months, the debt becomes visible. The moment a security breach happens because a dependency was not updated, the debt becomes expensive. The moment your best engineer quits because they are tired of fighting legacy code, the debt becomes a retention problem.
McKinsey's 20-40% is not an abstract number. It is real money being spent on maintaining systems instead of building new ones. Stripe's 42% is not a vague estimate. It is real developer time being lost to work that does not create value.
The fix is not dramatic. It is disciplined: 15-20% allocation every sprint, prioritized by business impact, measured over time. The teams that do this ship faster, retain engineers longer, and pass technical due diligence when the exit comes.
We build software that lasts. HeyTutor: 9 years, no major rewrites. MyFlyRight: 10 years, architecture decisions from year 1 still holding. That is what managing technical debt looks like in practice.
Last updated April 12, 2026
Older
How to Choose a Software Development Partner: A Framework from the Other Side of the Table Newer
How Much Does Custom Software Development Cost in 2026? Real Numbers, Not Ranges
