Technical debt
Technical debt is the future cost of shortcuts taken in a codebase or design. Like a loan, it buys speed now, and you pay interest later as every change takes longer until the shortcuts are cleaned up.
- Also called
- Tech debt, Code debt, Design debt, Cruft
- Category
- Development
- Updated
Ward Cunningham coined the metaphor in a 1992 experience report about a financial software project. He compared shipping first-version code to going into debt: a little debt speeds development, as long as it is paid back promptly by rewriting. If it is never paid back, the cost compounds.
Martin Fowler’s version is the one most teams use today. The shortcuts, or cruft, are the principal. The extra effort they add to every new feature is the interest. You pay the principal down by cleaning up, and the payoff is that future work goes faster. The same idea applies outside code: a product with five button styles and three ways to do the same thing carries design debt that slows designers and confuses users.
Why it matters for a SaaS product
SaaS products change constantly, so debt in the areas you touch most is paid every sprint. It shows up as features that take longer than they should, bugs that reappear, onboarding that nobody wants to touch and developers who are afraid to change certain files. AI coding tools have made this sharper: a vibe-coded MVP can pile up months of debt in a few weekends, because code is produced faster than anyone reads it.
How DesignMe handles it
Our AI MVP cleanup is largely debt work. It starts with an audit of the product, flows, frontend, backend logic, integrations and AI-generated code, which produces a risk list and cleanup priorities. We do not rewrite by default: we decide what to keep, clean up, refactor, redesign or rebuild. Typical fixes are bringing styles and components back into one system, filling backend gaps such as auth, validation and error handling, and organising the parts your team has to maintain after launch. Handoff documentation records what changed, what is still risky and what should happen next, so the remaining debt is known rather than hidden.
Example
Say a SaaS team built its dashboard fast for a seed round. Two years later, adding a new chart type takes three weeks, because each chart was copied and edited by hand and they all format numbers differently. Replacing them with one shared chart component takes a sprint, and the next new chart takes two days.
Common mistakes
- Using “debt” to excuse sloppiness. Deliberate, tracked shortcuts are debt. Careless work is just a mess.
- Never recording it. If shortcuts are not written down, nobody knows what to pay back.
- The big rewrite. Rebuilding everything at once often recreates old problems and stalls the roadmap.
- Ignoring design debt. Inconsistent UI costs as much time as messy code, and users see it.
Questions
- Is technical debt always bad?
- No. Taking on some debt on purpose to ship an MVP or hit a launch date can be the right call, as long as the team knows where it is and pays it back. The damage comes from debt nobody chose or tracked, which keeps growing until simple changes take weeks.
- How do you pay down technical debt?
- Mostly in small steps. Clean up the parts of the codebase you change most often, since that is where the interest is highest, and leave stable code alone. Big rewrites are sometimes justified, but they carry their own risk. A short audit that ranks problems by cost and risk helps decide.
Sources
- Ward Cunningham: The WyCash Portfolio Management System (OOPSLA 1992) (opens in a new tab)c2.com
- Martin Fowler: Technical Debt (opens in a new tab)martinfowler.com
Press Escape to close.