Every founder who has run a software product for a few years has heard some version of this from their developers: "That change will take three weeks because of how the old code is written." The first time it sounds like an excuse. By the fifth time, the pattern is clear: everything is getting slower, bugs keep returning, and the team keeps asking for a rewrite.
That pattern has a name: technical debt. This article explains it in rupees and delays rather than code, shows how to measure it without being a programmer, and argues for a repayment budget instead of the full rewrite your team may be asking for.
What is technical debt, in business terms?
The metaphor comes from programmer Ward Cunningham, and Martin Fowler's explanation is the clearest. Shortcuts and poor internal quality in a system, which Fowler calls cruft, make every future change harder. That extra effort is the interest. The effort needed to clean the cruft up is the principal.
Fowler's example: a feature that should take four days takes six because of messy code. The two extra days are interest, paid on every feature that touches that part of the system. Like financial debt, it is not automatically bad. Taking a shortcut to hit a launch date can be a sound decision. The trouble starts when nobody tracks the debt and the interest quietly consumes the team's capacity.
What does technical debt cost a business?
You will not see technical debt on a balance sheet, but you will see it in these places:
- Slower delivery. If half of each sprint goes to working around old problems, you are paying full salaries for half the output.
- Recurring bugs. The same areas break after every release, and customers notice.
- Onboarding time. New developers take months to become productive because nothing is documented and the code surprises them.
- Key-person risk. Only one developer understands the billing module. If they leave, so does your ability to change it.
- Security exposure. Outdated frameworks and libraries that cannot be upgraded without breaking things.
- Lost deals. An enterprise client asks for SSO, an API or an audit log, and the honest answer is "not in this architecture".
Turn it into rupees with a simple calculation
You can estimate interest without reading code. Ask your tech lead to classify the last two or three months of work:
| Work category | Example | Share of hours |
|---|---|---|
| New features customers asked for | New report, payment option | __ % |
| Bug fixes in recently built code | Normal defects | __ % |
| Rework and firefighting in old code | Same module breaks again, manual deploy fixes | __ % |
| Workarounds | "We had to copy this logic because the old function can't be changed" | __ % |
Multiply the share spent on rework and workarounds by your monthly engineering cost (salaries plus vendor bills). That is your approximate monthly interest payment. When founders see it as a monthly rupee figure, the conversation changes from "the developers want to refactor" to "we are paying this much every month for past shortcuts".
A cautionary case: when debt comes due all at once
Technical debt is usually a slow leak, but sometimes it fails catastrophically. In late December 2022, during a severe winter storm, Southwest Airlines cancelled more than 15,000 flights over about ten days. Its crew-scheduling tools, internally maintained systems including one called SkySolver, could not cope with the volume of schedule changes, and crews were left phoning overloaded schedulers. The pilots' union had picketed over the scheduling system in the summer of 2022 and warned in November that the airline was "one IT router failure away from a complete meltdown". Southwest reported losses of roughly $1.1 to 1.2 billion from the disruption and paid about $600 million in passenger reimbursements, and in December 2023 the US Department of Transportation fined it $140 million.
The lesson for a founder is not "airlines are complicated". It is that a system which works on normal days can hide years of accumulated debt until an unusual day arrives: a festive-season sales spike, a GST rule change, a large new client. Ask your team which system you would least like to depend on during your busiest week of the year. That is where your debt is.
How do you audit technical debt without being technical?
Run a two-week debt audit. You need your tech lead and, ideally, one outside senior engineer for an unbiased view.
- List the modules of your product: login, catalogue, orders, billing, reports, integrations.
- Rate each module 1 to 5 on four questions: How often do we change it? How often does it break? How many people understand it? How outdated are its frameworks and libraries?
- Check the basics: Are there automated tests? Is deployment automated or manual? Are dependencies up to date and supported? Is there monitoring?
- Plot a simple grid: change frequency on one axis, pain on the other.
| Rarely changed | Changed often | |
|---|---|---|
| Painful | Leave mostly alone; fix security issues only | Pay down first, this is where interest is highest |
| Healthy | Ignore | Protect with tests |
This matches Fowler's advice: interest is only paid when you work in the crufty code, so stable, rarely touched code can often be left as it is.
Why not just rewrite everything?
A full rewrite is the most tempting and often the most expensive answer. While the team rebuilds, the old product still needs fixes, the business still needs new features, and the new system must rediscover every undocumented rule the old one handled. Rewrites frequently run long and arrive with new debt of their own.
A rewrite does make sense in narrow cases: a module built on a platform that is no longer supported, or a component that blocks a critical business requirement. Even then, replace it piece by piece behind a stable interface rather than all at once. That incremental approach is the core of sound legacy application modernization.
How should you budget for paying down debt?
- Reserve a fixed share of every sprint for debt work, agreed with the tech lead, rather than waiting for a "clean-up quarter" that never comes.
- Attach debt work to features. When a feature touches the billing module, include tidying that module in the estimate.
- Start with safety nets: automated tests and automated deployment make every later improvement cheaper and safer. A QA automation suite is a sensible first investment.
- Track it visibly. Keep a debt register with each item's estimated interest and principal, reviewed monthly like any other liability.
- Take on new debt deliberately. Shortcuts for a launch are fine if they are written down with a repayment date.
How Cehpoint can help
We run independent code and architecture reviews, set up automated testing and deployment, and refactor or replace the modules where debt costs the most, without stopping your releases. See our software engineering service. If you want a second opinion on a rewrite proposal or a stuck project first, book a consultation with a senior engineer.