How Much is Your Tech Debt Actually Costing You?

“We have some tech debt” is the most common lie in software engineering. Every team says it. No team quantifies it. And when the board asks “how much?”, the CTO waves their hands and says “a few sprints to clean up.”

That's not an answer. It's a guess. And it's almost always wrong.

Thuban calculates the actual cost of your tech debt in pounds and dollars. Not a vague “high/medium/low” rating. Not a unitless score. A number with a currency symbol in front of it.

Here's how.

The Formula

Tech debt cost is calculated from three inputs:

Each component is measurable:

1. Complexity Score

Every issue Thuban detects gets a complexity score from 1 to 10. This isn't arbitrary — it's calculated from the issue type, the file's centrality in the dependency graph, and the blast radius of a fix.

A phantom import in a utility file scores 2. A hallucinated API call in your Stripe payment handler scores 6. A hardcoded API key committed to git history scores 10. The complexity score reflects the real-world effort required to fix the issue safely.

2. Estimated Hours

Each complexity point maps to an estimated number of engineer-hours to fix. This isn't just the time to write the fix — it includes investigation, testing, code review, and deployment.

A complexity-2 phantom import takes 30 minutes to fix: find the correct import path, update it, run the build. A complexity-8 hardcoded secret takes two full days: rotate the credential, audit git history, check for exposure, update all environments, notify affected users if required.

3. Hourly Rate

Thuban uses a configurable hourly rate that defaults to £75/hour (approximately $95/hour). This represents the fully-loaded cost of a mid-senior engineer in the UK, including salary, benefits, equipment, and overhead.

# Use default rate (£75/hour)
npx thuban@latest scan . --cost

# Use custom rate
npx thuban@latest scan . --cost --hourly-rate 120

# Use USD
npx thuban@latest scan . --cost --hourly-rate 95 --currency USD

Case Study: NovaPay — A 50K LOC SaaS App

# Thuban scan output — NovaPay
Codebase: 50,247 lines across 312 files
AI Slop Index: 47 (Concerning)

Issues found:
  Phantom imports:        23  (avg complexity: 2.4)
  Hallucinated APIs:       8  (avg complexity: 4.8)
  Deprecated APIs:        14  (avg complexity: 3.2)
  Dead code blocks:       67  (avg complexity: 1.3)
  Duplicate code:         31  (avg complexity: 2.6)
  Missing error handling: 19  (avg complexity: 3.8)
  Hardcoded secrets:       2  (avg complexity: 9.0)
  No test coverage:       42  (avg complexity: 2.8)

Total issues: 206

Now let's calculate the cost:

But that's just the direct cost. The indirect costs are harder to measure but often larger:

• Velocity drag: Engineers working around tech debt move 20–40% slower. For a 4-person team at £75/hour, that's £4,800–£9,600/month in lost productivity.
• Incident cost: Each production incident caused by a hallucinated API or missing error handler costs 4–8 hours of firefighting. NovaPay had 3 incidents in the last quarter traced to AI-generated code issues.
• Onboarding cost: New engineers take 2–3 weeks longer to become productive in a codebase with high tech debt. At £75/hour, that's £6,000–£9,000 per new hire.

When you add indirect costs, NovaPay's real tech debt burden is closer to £40,000–£45,000.

What the Investor Sees

NovaPay is raising a Series A. Their technical advisor runs a Thuban scan as part of due diligence. Here's what the report looks like:

# Thuban Due Diligence Report — NovaPay

EXECUTIVE SUMMARY
  Codebase size:        50,247 LOC (312 files)
  AI Slop Index:        47/100 (Concerning)
  Tech Debt Cost:       £24,394 (direct) / £42,000 (estimated total)
  Critical Issues:      2 hardcoded secrets, 8 hallucinated APIs
  Remediation Estimate: 8 engineer-weeks

RISK ASSESSMENT
  Security:     HIGH — 2 API keys in git history
  Stability:    MEDIUM — 8 hallucinated API calls in production paths
  Scalability:  MEDIUM — 14 deprecated APIs will break on next upgrade
  Maintainability: MEDIUM — 67 dead code blocks, 31 duplicates

RECOMMENDATION
  Proceed with investment, conditional on 4-week remediation sprint
  addressing security issues and hallucinated APIs before Series A close.

This is the report that changes valuations. Not because the tech debt exists — every startup has tech debt — but because it's now quantified. The investor knows exactly what they're buying into and what it costs to fix.

Why Boards Care About the Number

Board members don't understand cyclomatic complexity. They don't care about your test coverage percentage. But they understand money.

When you tell a board “we have tech debt”, they hear noise. When you tell them “we have £24,394 of tech debt that's costing us £7,200/month in velocity drag, and we can reduce it to £8,000 with a 4-week sprint”, they hear a business case.

The tech debt cost calculator turns an engineering problem into a financial one. And financial problems get budget.

The Conversation That Gets Budget

// Before Thuban
CTO: "We need to spend 2 sprints on tech debt."
Board: "Can it wait? We need to ship the Q3 roadmap."
CTO: "It's important."
Board: "Everything is important. Ship the roadmap."

// After Thuban
CTO: "Our tech debt is costing us £7,200/month in lost velocity.
      A 4-week sprint costs £24,000 and saves £86,400/year.
      ROI is 3.6x in the first year."
Board: "Approved. Start next sprint."

Numbers win arguments. Especially numbers with pound signs.

The Inputs Thuban Uses

Thuban's cost calculation isn't a black box. Every input is transparent and configurable:

From the Scan

• Issue count by type: How many phantom imports, hallucinated APIs, deprecated calls, etc.
• File centrality: How many other files depend on the affected file (from the import graph).
• Blast radius: How many files would need to change if this issue is fixed.
• Code path criticality: Is this in auth, payments, or data handling? Higher weight.

Configurable by You

• Hourly rate: Default £75. Set to your team's actual fully-loaded cost.
• Currency: GBP, USD, EUR. The formula is the same; only the symbol changes.
• Velocity drag factor: Default 30%. How much slower your team moves due to tech debt. Adjust based on your sprint velocity data.
• Incident cost: Default £600/incident. The average cost of a production incident caused by code quality issues.

# Full cost calculation with custom inputs
npx thuban@latest scan . --cost \
  --hourly-rate 95 \
  --currency USD \
  --velocity-drag 0.35 \
  --incident-cost 800

Tracking Cost Over Time

A single scan gives you a snapshot. Weekly scans give you a trend. And trends tell the real story.

# NovaPay — weekly tech debt cost tracking
Week 1:  £24,394  (baseline scan)
Week 2:  £22,800  (fixed 2 hardcoded secrets, 5 phantom imports)
Week 3:  £18,200  (fixed all hallucinated APIs, removed 30 dead code blocks)
Week 4:  £14,600  (deduplicated 20 code blocks, added error handling)
Week 5:  £11,200  (deprecated API migration, test coverage push)
Week 6:  £8,400   (continued cleanup, new code reviewed properly)

Total reduction: £15,994 (65%)
Sprint cost: £24,000 (4 engineers × 2 weeks × £75/hour × 40 hours)
Monthly savings: £4,800 in velocity drag
Payback period: 5 months

The trend line is what you show the board. A declining tech debt cost proves that the remediation sprint is working. A flat or rising line proves that new tech debt is being created faster than old debt is being paid down.

The Hidden Cost: What Happens If You Don't Fix It

Tech debt compounds. Like financial debt, the interest payments grow over time. Here's what happens to NovaPay if they ignore the £24,394:

The original £24,394 of tech debt costs £57,600 over 12 months if left unfixed. That's a 2.4x multiplier. And it doesn't include the reputational cost of a security incident or the opportunity cost of features that were never built because the team was fighting fires.

How to Reduce Your Tech Debt Cost

The playbook is straightforward. Thuban's cost report includes a prioritised fix roadmap that maximises cost reduction per hour of engineering effort.

Priority 1: Security Issues (ROI: Immediate)

Hardcoded secrets and exposed credentials have the highest complexity score and the highest potential cost. Fix these first. Rotate every exposed credential. Audit git history. Set up secret scanning in CI.

Priority 2: Hallucinated APIs (ROI: 1–2 weeks)

These are runtime crashes waiting to happen. Each one is a production incident that hasn't occurred yet. Fix them before they cost you an incident response.

Priority 3: Deprecated APIs (ROI: 1–3 months)

These work today but will break on the next major version upgrade. Fix them proactively during a planned sprint rather than reactively during an emergency migration.

Priority 4: Dead Code + Duplicates (ROI: Ongoing)

These have the lowest per-issue cost but the highest volume. Removing them reduces cognitive load, speeds up onboarding, and makes the codebase easier to navigate. Schedule these as part of regular maintenance.

Priority 5: Test Coverage (ROI: 3–6 months)

Adding tests to untested high-complexity files prevents future tech debt from accumulating. This is the investment that pays dividends over the longest time horizon.

# Thuban prioritised fix roadmap
npx thuban@latest scan . --cost --roadmap

# Output:
PRIORITY 1 — Security (fix this week)
  [S1] src/config/stripe.ts:14     Hardcoded Stripe secret key
  [S2] src/services/email.ts:8     Hardcoded SendGrid API key

PRIORITY 2 — Runtime Risk (fix this sprint)
  [H1] src/handlers/payment.ts:42  stripe.invoices.createAndFinalize() doesn't exist
  [H2] src/utils/auth.ts:18       jwt.verifyAsync() — method is verify()
  ... 6 more

PRIORITY 3 — Upgrade Blockers (fix this month)
  [D1] src/pages/dashboard.tsx:5   getServerSideProps — deprecated in Next.js 13+
  ... 13 more

PRIORITY 4 — Maintenance (ongoing)
  [C1] 67 dead code blocks across 34 files
  [C2] 31 duplicate code blocks across 22 files

PRIORITY 5 — Coverage (next quarter)
  [T1] 42 files with zero test coverage (12 high-complexity)

The Bottom Line

Tech debt isn't a vague engineering concern. It's a financial liability with a measurable cost. Every phantom import, every hallucinated API, every hardcoded secret has a price tag — in engineer-hours, in velocity drag, in incident response, and in opportunity cost.

The teams that quantify their tech debt get budget to fix it. The teams that don't get told to “ship the roadmap.”

Craig is the founder of Thuban. He's seen tech debt reports that made investors walk away and remediation sprints that saved Series A rounds. The difference is always the same: a number.