Every business owner I work with eventually asks the same question: why did a feature that used to take two weeks now take two months. The honest answer is almost never "the developers got worse." Technical debt explained in one sentence is this: it's the accumulated cost of shortcuts your software took to ship faster, and like any loan, it charges interest until someone pays it down.
The loan analogy gets used a lot, and it's a fine starting point, but it undersells the problem. A loan has a fixed schedule and a known interest rate. Technical debt compounds unpredictably, and the interest rate goes up the longer you ignore it, because every new feature gets built on top of the shaky part. You don't get a statement in the mail telling you the balance. You find out when a "small" change quietly touches twelve files nobody remembers writing.
You don't get a statement in the mail telling you the balance, said Ervandra Halim, CPTO and principal architect.
I want to walk through how to actually read the symptoms in your own system, because most owners only notice debt when it's already expensive.
What Does Technical Debt Actually Look Like Day to Day?
Technical debt looks like specific, recognizable behavior in a codebase, not an abstract metaphor. When I'm asked to assess a company's system, I check for five concrete tells rather than any single metric, because these behaviors show up consistently before the cost becomes obvious in the numbers:
- Every small change takes weeks. A request that sounds like "just add a filter to this report" turns into a multi-week project because the filter logic is duplicated across six screens with no shared source of truth.
- One developer is irreplaceable. If your team says "only Budi can touch the invoicing module," that's not a compliment to Budi, it's a red flag. It means the system's logic lives in one person's head instead of in documentation or clean structure.
- Bugs come back after being fixed. This usually means the same logic is copy-pasted in multiple places, so a fix in one spot doesn't reach the others.
- New hires take months to become productive. Clean systems can be explained in an afternoon. Debt-heavy systems require tribal knowledge that takes months to absorb.
- Nobody wants to touch certain files. If your engineers avoid a part of the codebase the way you'd avoid a certain relative at a family gathering, that part is expensive to change and everyone knows it.
If you're recognizing more than two of these, you're not looking at a minor inconvenience. You're looking at a tax on every future feature you want to build.
How Do You Tell Healthy Debt From the Kind That Kills Roadmaps?
Healthy debt and roadmap-killing debt are distinguished by intent, not size: not all technical debt is bad, and treating every shortcut as an emergency is its own mistake. The real dividing line sits between debt you took on deliberately, with a plan to repay it, and debt that simply accumulated from neglect.
Healthy debt looks like: you shipped an MVP fast to test a market before over-engineering it, you hardcoded a value because you had three customers and needed to learn from them before building configuration for thousands, or you skipped automated tests on a feature you expected to throw away in a month. This is debt with a plan. You know what you owe and roughly when you'll pay it.
Roadmap-killing debt looks different: nobody decided to take the shortcut, it just happened because there was no time pressure to think it through, or a deadline forced a hack that nobody circled back to fix. Nobody wrote down that it happened, so nobody's tracking the balance. And it's compounding, meaning every new feature added since has built more code on top of the shaky part, making it more expensive to fix every quarter you wait.
The test I use with clients: can your CTO or lead engineer tell you, in plain language, what shortcuts exist and what it would cost to fix them? If yes, you have a managed liability. If the answer is a shrug, you have a fire that hasn't been noticed yet. This is the same distinction I cover in more depth in Technical Debt Explained for Business Owners from a systems-design angle, if you want the deeper technical framing.
What Questions Should You Ask Your Team This Quarter?
The questions that matter most don't require you to read code; they require asking directly and paying attention to when the answers turn vague. This section walks through five questions that expose how much technical debt is actually costing your team, and how honestly your engineers can account for it themselves in plain business language.
- "If I asked for [a specific plausible feature], how long would it take, and why?" A confident, specific answer with a clear reason is healthy. A long pause followed by "it depends" is not.
- "What parts of the system are we afraid to touch?" Every engineering team has an honest answer to this if you ask directly instead of asking "is everything okay."
- "What happens if [key developer] takes a month off?" This tells you how concentrated your risk is.
- "When did we last pay down debt on purpose?" If the answer is "never," you're accumulating interest with zero repayment plan.
- "What's the cost, in weeks, of the three worst shortcuts in the system?" A team that has never quantified this hasn't prioritized it, which means it will keep growing invisibly.
What This Costs in Real Terms
For a mid-sized retail chain I worked with in Tangerang, the pattern was textbook: a point-of-sale system built quickly five years earlier had duplicated pricing logic across the web admin, the mobile app, and a reporting script. A promo campaign that should have taken a week to launch took six, because pricing rules had to be updated in three places by three different people, and testing had to cover all three separately. The fix wasn't a rewrite. It was consolidating pricing logic into one service that all three systems called. That project took about six weeks and paid for itself within two campaign cycles because every future promo dropped back to days instead of weeks.
That's the real cost of unmanaged debt: it's not a single bill, it's a permanent tax on your speed. And speed is usually the thing separating you from a competitor who ships faster. If you want to see how that competitive gap plays out concretely, Traditional Businesses Are Losing to Digital-First Rivals covers it directly.
Takeaway: Manage the Balance, Don't Just Fear It
Technical debt isn't a moral failing and it isn't something you eliminate entirely, any working business has some. What separates companies that stay fast from ones that grind to a halt is whether someone is actively tracking the balance and paying it down on purpose. Ask your team the five questions above this quarter. If the answers are vague, that vagueness is the actual problem, more than any specific piece of code. Get a second opinion if you need one; an outside technical read on your system's real debt load is exactly the kind of conversation worth having before your next big feature push, and it's the kind of engagement I take on through ervandra.com/partner.
