▶How much technical debt is acceptable?
There's no universal threshold, but teams typically track debt ratio (lines of legacy code / total lines). Industry research suggests 30-40% is normal; over 50% starts impacting velocity. The key metric is impact on developer productivity, not percentage alone. Some strategic debt is healthy if consciously decided and tracked.
▶What's the '20% rule' for debt reduction?
Allocate 20% of sprint capacity (1 day per week) to debt reduction, testing, and quality work. This prevents debt accumulation while maintaining feature velocity. Teams that skip this often face 30-40% velocity drops when debt finally compounds.
▶How do I communicate debt impact to non-technical stakeholders?
Translate technical debt to business metrics: developer time lost to context-switching (e.g., 'adding a feature takes 3 weeks instead of 1 week because of legacy architecture'), incident frequency ('30% of outages traced to this module'), or onboarding time ('new engineers take 6 weeks to be productive in this codebase vs 2 weeks in modern sections').
▶When should I do a rewrite vs incremental refactoring?
Incremental refactoring is almost always better. Rewrites are high-risk, take 3-4x longer, and introduce new bugs. Rewrite only if: (1) the module is truly isolated, (2) you have excellent tests, (3) business impact is quantified and worth the risk. Otherwise, refactor incrementally over 2-3 sprints.
▶What tools help detect technical debt?
SonarQube (code quality, security, maintainability), Code Climate (coverage + metrics), ESLint (code standards), dependency audits (npm audit, Snyk), and architecture linters. The best tool is code review, humans spot architectural debt that tools miss.
▶How do I prioritize which debt to fix first?
Use a 2×2 matrix: (impact on velocity × cost to fix). High impact + low cost = fix first. High impact + high cost = plan a multi-sprint initiative. Low impact = monitor or skip. Always prioritize debt that blocks new features over 'nice to have' cleanups.
▶Can technical debt ever be 'paid off'?
Not fully, new debt accumulates naturally as systems evolve. The goal is steady-state management: balance new feature work (creates debt) with refactoring (reduces debt) so the ratio stays sustainable. Think 'gardening' not 'clearing the weeds once.'