Meet Kavitha, an engineering lead at a mid-sized logistics company in Pune. Her team has eight developers. The billing module they own was written in a hurry four years ago, and it shows. Every month there are invoice mismatches, a few late-night patches, and a general fear of touching anything near the rate calculation code.
She keeps a rough log for a quarter and finds that about 40% of her team’s time goes to this one area: investigating discrepancies, hotfixing, re-running batch jobs, and answering support escalations. She walks into the quarterly review and says, “We have a lot of technical debt in billing. We need two sprints to refactor it.”
The head of product asks what the customer gets from that. The CFO asks whether it can wait until after the festive season. The request is politely parked. Kavitha is frustrated, and she is also, honestly, a bit at fault. She has asked for money to fix something in a language the room does not speak.
Why the word “debt” helps, and where it misleads
Ward Cunningham coined the debt metaphor in the early 1990s. His point was specific: shipping code that reflects an incomplete understanding is like borrowing; you get speed now, and you pay interest until you repay by improving the code. Borrowing is not shameful. A startup that ships a rough version to learn whether anyone wants it is borrowing wisely.
The metaphor misleads when it is stretched to mean “any code I dislike”. Messy code in a module nobody changes costs nothing. It has no interest. Debt matters only where you keep paying: code you change often, or code that keeps failing. Kavitha’s billing module qualifies. A rarely touched report generator that is ugly but correct does not.
Turning the interest into numbers
Back to the review room. A better version of Kavitha’s pitch starts with her log. Eight developers at 40% is 3.2 developers’ worth of capacity. If a fully loaded developer costs the company about ₹30 lakh a year, that is roughly ₹96 lakh a year spent on firefighting one module. That figure is an estimate, and she should say so, but it is the sort of number a CFO can react to.
Cost is only one column. Two others tend to persuade more:
- Delay. If the new rate-card feature that sales wants has been quoted at six weeks because everything must be tested around fragile billing code, and a clean version would take three, that is a business outcome. “Billing is why the enterprise pricing launch is slipping” lands differently from “billing is messy”.
- Risk. Invoice errors have a customer and, with GST, a compliance dimension. Mention the actual incident count from the last two quarters and what each cost in credit notes and support hours. Do not exaggerate; a measured claim is more trusted.
Notice that none of these requires the audience to understand the code. That is the skill: translate the interest payments into capacity, speed and risk.
Do not ask for a rewrite
The second mistake in the original pitch was the size of the ask. “Two sprints to refactor billing” sounds like a project with no visible end. Leadership has seen those. A more approvable plan is incremental and tied to something they already want.
Kavitha might propose this instead. Spend the first two weeks on the cheapest high-return step: adding automated tests around the rate calculation, so changes become safe, plus an alert that catches mismatches the day they occur rather than when a customer complains. Then reserve about 20% of each sprint for the next quarter for billing clean-up, aimed at the specific parts that her incident log shows are most painful. At the end of the quarter, report the same metrics she started with: hours spent on firefighting, incident count, and the lead time for the rate-card feature.
That plan has a start, a measure of success and an exit. If the numbers do not improve, leadership has lost a small, bounded amount of time. This is much easier to say yes to than an open-ended refactor. The 20% figure is a common rule of thumb, not a law; the right share depends on how bad the interest is and how much else is committed.
Pair it with features, not against them
The most successful way to repay debt is often to repay it where you are already working. When the rate-card feature is built, the team improves the code around it as part of the same work, and states that honestly in the estimate: “six weeks including making this area safe to change.” This is sometimes called the boy-scout approach, leave the campsite cleaner than you found it. It avoids the awkward conversation of a separate budget line and keeps the clean-up tied to value.
There is a limit. When the debt is structural, say the whole module is built on a wrong assumption, small clean-ups will not fix it, and a planned larger piece of work is justified. Even then, the incremental approach and the measurement apply.
Keeping the argument honest
Engineers sometimes weaken their case by overclaiming. Not every outage is debt, and not every slow feature is caused by old code. Some of it is unclear requirements, or a small team. If Kavitha blames everything on billing and leadership later finds the real causes elsewhere, her credibility suffers for the next request.
Also, some debt is the right call. Before a trade show in three weeks, shipping a rougher version can be exactly what the business needs, provided the shortcut is written down, with an owner and an approximate date to revisit. Deliberate, recorded debt is a decision. Accidental, invisible debt is just a problem that has not announced itself yet.
Figures and names in the examples are illustrative.
Leave a Reply