Where does the $1.52T figure come from?

CISQ (Consortium for Information & Software Quality) published 'The Cost of Poor Software Quality in the US: A 2022 Report'. The headline figure was $2.41T total cost of poor software quality, with technical debt specifically estimated at $1.52T per year. The figure aggregates operational and rework costs of legacy systems, the productivity drag of unaddressed defects, and cyber-incident costs traceable to underlying code quality issues. It is a US-only estimate based on the published economic activity of the software-engineering workforce and industry productivity data.

How does the national figure convert to per-developer cost?

Divide $1.52T by the approximately 4.5 million professional software developers in the US (Bureau of Labor Statistics 2022 figure). The result is roughly $338,000 per developer per year, which on its face is implausibly high. The discrepancy is because the CISQ figure includes downstream business cost (incidents, lost revenue, opportunity cost), not just developer productivity drag. Applying just the productivity drag component (~33% of developer time, Stripe Developer Coefficient) against a ~$165K fully-loaded salary lands at roughly $54K per developer per year, a much more defensible per-person figure that maps cleanly to engineering-budget conversations.

Is 33% developer time spent on tech debt really accurate?

Stripe's 'Developer Coefficient' study surveyed 1,000 developers across the US and Europe in 2018 and found an average of 33% of developer time spent on maintenance, fixing bad code, and working around technical issues. The figure has been broadly corroborated by subsequent industry surveys (StackOverflow Developer Survey, GitClear's 'AI-Generated Code Quality' report, McKinsey's 'Developer Productivity' series). Real teams typically land between 20% and 50% depending on codebase age, test coverage, and the discipline of refactoring as features are built.

Why use 18% as the compound growth rate?

CAST Software's structural-quality research (published as the Application Software Quality Index) found unaddressed technical debt grows 15-25% per year in most codebases, with 18% as a representative midpoint. Drivers include: coupling growth as new features depend on existing code, dependency drift as libraries deprecate or break, team-scaling friction as more contributors create more places for inconsistency, and workaround accumulation as quick fixes get re-applied rather than replaced. The 18% rate is the conservative midpoint and the calculator uses it for the 5-year compound projection.

How does the team-size cost table help when our team can't act on the national figure?

Two ways. First, it converts the abstract national figure into a number that maps to your specific headcount and salary, a 25-developer team at $165K fully-loaded with 33% debt drag is losing approximately $1.36M per year. That number is sized to your engineering budget rather than the US economy, which is the difference between a slide that lands and a slide that gets dismissed. Second, the 5-year compound column shows the cost of doing nothing, $9.8M for that same 25-developer team, which materially shifts the maths on whether to fund a remediation programme this year or defer.

CISQ 2022 national figure

The US loses $1.52 trillion a year to technical debt.

That number, from CISQ's 2022 report, is the most-cited statistic in the technical-debt conversation. It is also too big to be useful, “1.52 trillion” doesn't fit in any budget meeting. This page converts the national figure into something that does: cost per developer, cost per team, cost over five years if you ignore it.

the conversion ladder

01 · US national

$1.52T

CISQ 2022, all sectors

02 · Per developer

~$54K

33% × $165K fully-loaded

03 · 25-dev team

~$1.36M

annual productivity drag

04 · 5-year team

~$9.77M

18% compound growth

The national figure breaks down across operational, rework, and incident cost. The per-developer figure isolates just the productivity drag, the 33% of time Stripe found developers spend on debt rather than building new features.

Team-size cost table

Adjust salary and debt-drag percentage to match your reality. Click a row to highlight it. The 5-year compound column applies CAST's 18% annual debt-growth rate, the cost of doing nothing.

Fully-loaded salary per developer

$165K

Base × 1.3-1.5 incl. benefits, equipment, office.

% of dev time spent on debt

33%

Stripe Developer Coefficient: 33% average.

Team size	Annual debt cost	FTE-equivalent waste	5-year compound (18% gr.)
1 developer	$54,450	0.33 FTE	$389,547
5 developers	$272,250	1.65 FTE	$1,947,734
10 developers	$544,500	3.30 FTE	$3,895,467
▶25 developers	$1,361,250	8.25 FTE	$9,738,668
50 developers	$2,722,500	16.50 FTE	$19,477,336
100 developers	$5,445,000	33.00 FTE	$38,954,672
250 developers	$13,612,500	82.50 FTE	$97,386,680
500 developers	$27,225,000	165.00 FTE	$194,773,361

If your team is 25 developers

Technical debt is costing you $1,361,250 this year, equivalent to 8.25 FTE of wasted capacity. If left unaddressed at the typical 18% compound growth, the 5-year total reaches $9,738,668.

Annual cost = team_size × fully-loaded salary × debt fraction. FTE waste = team_size × debt fraction. 5-year compound applies 18% annual debt growth (CAST Software research range: 15-25%).

What CISQ actually measured

The $1.52 trillion figure is not “developer salary wasted on debt”. It aggregates three components of poor software quality, of which technical debt is one:

Operating and maintaining legacy systems

The cost of keeping old systems running, support contracts, vendor lock-in, the engineering time to patch and integrate with code that no one wants to rewrite. CISQ estimated this at roughly $520B.

Productivity drag from existing debt

What Stripe measured as ~33% of developer time on workarounds, fixes, and fighting legacy code. CISQ estimated this at roughly $620B. This is the component the per-developer figure isolates.

Cyber incidents traceable to code quality

Breaches, outages, and security incidents with root cause in code-quality issues. CISQ estimated this at roughly $380B. Hard to attribute precisely but the largest individual incidents (Equifax, Capital One, SolarWinds) all had software-quality components.

Source: CISQ “The Cost of Poor Software Quality in the US: A 2022 Report”, published December 2022 by the Consortium for Information & Software Quality. The full report is downloadable from the CISQ website. Component breakdowns above are illustrative apportionments of the headline figure, the report provides the methodology and source data in detail. Verify the latest published edition before citing specific sub-figures.

What this number actually unlocks

The national figure is a positioning statistic, it gets quoted in board decks because it sounds large. The team-size figure is an operating statistic, it gets a refactoring budget approved.

Use the national figure for context

Open with CISQ to establish that technical debt is an economic problem, not a culture one. This positions the conversation as a financial decision rather than an engineering preference.

Use the team figure for the ask

Then pivot to your specific team-size annual cost from the table. A $1.36M annual drag on a 25-dev team frames the cost of any refactoring programme as cost-of-doing-nothing avoidance, not cost-of-doing-something incurral.

Use the 5-year compound for urgency

The 5-year compound number is the punchline. It shows that ignoring debt for a year costs the 18% growth, not zero, and compounds over the time horizon executives actually plan for.

Avoid the false-precision trap

All three numbers (national, team, compound) are directional. They are for framing a decision, not pricing a contract. Anyone challenging the precision is missing the point; the order of magnitude is what matters.

Tech debt calculator (main tool)Build the business case Industry benchmarks Tech debt interest rate When to pay off debt Refactoring ROI