I once watched a VP of Engineering apologize to the CEO for "allowing" technical debt to accumulate. He stood in front of a room of executives looking like a kid who'd been caught cheating. The CEO nodded gravely, like a serious problem had been identified.
That meeting was the worst thing that happened to that engineering org for a year. It set up a false narrative: technical debt equals engineering incompetence. The team started hiding debt instead of managing it. They gold-plated everything to avoid criticism. Feature velocity dropped 40% because every ticket had to be done "the right way."
Let me be blunt: treating technical debt as a failure is organizational malpractice. It's like treating business loans as financial failure. Debt is a tool. The question is never "do we have debt?" It's "are we taking on debt deliberately, and is the return worth the interest?"
Ward Cunningham didn't create the debt metaphor to describe bad code. He described the deliberate choice to ship with an incomplete understanding of the problem, knowing you'd need to come back and revise the code as your understanding matured.[1]
That's not failure. That's learning.
A startup can accept a limited design compromise to learn from users or reach a market window. The decision needs an estimate of the benefit, the carrying cost and the risk of revisiting the design later.
Here's a decision I made in 2023 that I'd make again: we hardcoded a configuration table directly into our application because building a proper admin UI would have taken 6 weeks. That "debt" let us ship 5 weeks earlier, close our first enterprise customer, and fund the next 6 months of development. Was it debt? Absolutely. Was it the right call? Without question.
This simplified calculation compares two estimated terms in a technical debt business decision:
Expected Return = (Value of Shipping Sooner) - (Cost of Carrying the Debt)
A positive estimate supports the trade only if the assumptions, risks and constraints are acceptable. Compare the carrying cost across the period the team expects to hold the debt.[2]
Here's the framework I use for every significant technical decision:
You know the solution isn't ideal. You're making a calculated trade. This is the healthiest form of debt.
Example: using polling instead of WebSockets for real-time updates. Suppose a load test establishes a limit of 5,000 concurrent users and the service has 200 today. Document that measured limitation and define a trigger for revisiting it.
Key requirement: Written documentation of what was deferred, why, and when to revisit.
Debt that accumulates because the world changed, not because you made a bad decision. Your framework released a major version. A dependency was deprecated. Your user base grew 10x.
Figure 2. The contract records the decision and the conditions under which the team should revisit it.
I was wrong about a lot of things early in my career, but the biggest mistake was taking on debt without documenting it. Undocumented debt is the kind that kills projects.
A decision record can retain the context, decision and consequences for future engineers.[4]
Now I use a simple "debt contract" for every deliberate debt decision:
markdown
## Debt Contract #DC-2026-014**Decision:** Use flat-file JSON storage instead of database for user preferences**Date:** 2026-01-20**Decided by:** Vaibhav, Sarah (Product), Mike (Eng Lead)**Rationale:**Database schema changes require a migration cycle (~1 week).Launching preferences behind feature flag for 50 beta users.JSON file is sufficient for this scale and lets us ship in 2 days.**Carrying Cost:**- No query capability on preferences- Manual file management- Won't scale past ~500 users- No audit trail on changes**Remediation Trigger:**- Beta exits to general availability, OR- User count exceeds 200, OR- We need to query preferences for analytics**Estimated Remediation Effort:** 1 engineer, 3 days**Accepted by:** Product + Engineering
This takes 10 minutes to write. It saves weeks of confusion later when someone asks "why is this a JSON file?"
Debt isn't the problem. Unmanaged debt is. Here are the warning signs:
You can't estimate anymore. When every feature estimate comes with a caveat like "unless we hit issues in the payments module," your debt is too high.
New hires are unproductive for months. If your codebase takes longer than 2-3 weeks for a competent engineer to contribute to, complexity has outpaced comprehensibility.
You're afraid to deploy on Fridays. Not because of policy, but because you genuinely don't trust the system.
The same areas cause repeated incidents. If your last three outages all trace back to the same module, that's not bad luck.
Senior engineers are leaving. Good engineers won't stay in a codebase that fights them every day. If exit interviews mention "technical frustration," you're past the tipping point.
Add a "Technical Debt" section to your monthly business review. Show the current cost, the trend, and the top 3 items. Not technical details, just business impact.
When Product proposes a feature, Engineering should present two estimates: one building on the current architecture, and one that includes necessary remediation. Let leadership make the trade explicitly rather than burying the cost.
I've seen too many organizations where shipping features gets you promoted and paying down debt gets you nothing. Change the incentives. If an engineer reduces deploy failure rate from 25% to 5%, that's at least as valuable as shipping a new feature.
Technical debt is not something to minimize. It's something to optimize.
Decide how much remediation to fund by considering the work the business needs next and the maintenance costs the team encounters. A low debt estimate alone does not establish over-engineering, and a high estimate needs investigation of the specific impediments to delivery.
The optimal level of debt is somewhere in the middle, and it changes based on your company stage, market position, and growth rate. Early-stage startups should carry more debt. Mature products serving regulated industries should carry less.
The goal isn't a clean codebase. The goal is a codebase that lets you ship what the business needs, when the business needs it, at a cost the business can sustain. Sometimes that means taking on debt. Sometimes that means paying it down. The skill is knowing which one, and when.
Stop apologizing for technical debt. Start managing it like the business tool it is.
Frequently asked questions
When can taking on technical debt be reasonable?
A limited compromise can help a team learn or reach a market opportunity sooner. Estimate the carrying cost and risk, agree who accepts the decision and define the condition that should prompt the team to revisit it.
What belongs in a debt contract?
Record the decision, date, participants, rationale and carrying costs. Add a remediation trigger, an effort estimate and the people accepting the trade so future work can be evaluated against the original assumptions.
Is an expected-return calculation enough to approve a shortcut?
The calculation is a simplified comparison of estimated terms. Discuss uncertainty and constraints alongside it, particularly when a change affects a revenue-critical path, team growth or a regulated system.
How can leadership keep debt visible?
Include the cost, trend and most consequential items in business reviews. During product planning, compare the work using the current architecture with a version that includes remediation, then make the trade explicitly.
A 3-tier succession planning framework for engineering orgs, with a 90-day sprint for accelerating candidates from potential to ready. Based on succession plans built at 4 companies.
The CTO's real job in product development isn't attending every meeting or making every technical call. It's connecting feasibility, viability, and capacity while letting EMs handle the day-to-day.
Four years of data from a fully remote engineering team across 4 time zones. Specific metrics on productivity, retention, and onboarding with the frameworks that actually worked.
Small frictions cost more than big blockers. 47 micro-frictions consume 96 minutes per engineer per day. Here's the TAX Return framework for finding and eliminating the developer productivity tax.
A structured 30-60-90 day framework for handling engineering underperformance. Based on 14 real cases with a 64% success rate, starting with diagnosis before intervention.
Engineers spend 38% of their time on repetitive, automatable work. Here's a toil audit process that identifies where time disappears and a framework for systematic elimination with measurable ROI.