Skip to content

Discover What Vertex Can Build for Your Business

Engineering3 min read

The real cost of “we'll add tests later”

Skipping tests doesn't save time, it borrows it. The interest gets charged daily, and the loan comes due in whichever part of the codebase you're most afraid to touch.

Nobody saves time by skipping tests. They borrow it — from a future version of the team with less context, more code, and no leverage to refuse.

On This Page

“We'll add tests later” is one of the few phrases in software that means roughly the opposite of what it says. It sounds like a sequencing decision: tests are work, work takes time, we'll do that work in a different week. It isn't. Tests aren't a layer applied to finished code — they're a constraint on how code gets shaped in the first place, and code written without that constraint tends to come out in a form that can't easily accept them.

Testability is a property of the design

A function that reaches out and grabs the current time, opens its own database connection and calls a payment provider directly is not hard to test because nobody has got round to it. It's hard to test because it has four responsibilities and no seams. Writing the test forces you to ask what this thing actually needs from the outside world, and answering that is what produces the injection point, the interface, the pure function with the real logic inside it. Skip the test and you skip the question, and what you get is a codebase where the business rules are welded to the I/O.

That's why retrofitting tests six months in costs so much more than the original estimate implied. The work isn't writing tests. It's untangling code until tests are possible — and doing that untangling without tests, which is the exact activity everybody agrees you shouldn't attempt.

What you lose in the meantime

The compounding cost isn't the eventual catch-up bill; it's every day before it. Without tests, changes are reviewed by reasoning rather than evidence, so review gets slower and more anxious. Refactoring stops, because nobody restructures code they can't verify, which means the mess only ever grows. Onboarding gets harder, because a test suite is the one form of documentation that can't quietly drift — it states what the system is supposed to do in a form that fails loudly when it stops being true.

The most expensive consequence is the quiet one: the team starts routing around whole regions of the codebase. Features get implemented in the wrong place because the right place is frightening. That decision never appears in a ticket or a retro, and it is the main mechanism by which an untested system becomes an unchangeable one.

This is not an argument for testing everything

The honest counter-argument is that an enormous number of tests are worthless, and it's true. A suite that asserts a component rendered, mocks every collaborator until nothing real is exercised, and breaks on every rename is worse than nothing: it costs maintenance and catches no defects, and it's why so many teams concluded that testing doesn't pay. Coverage percentage is a particularly bad target, since the cheapest way to move it is to test the code least likely to be wrong.

What earns its keep is narrow and predictable. Test the logic that encodes a rule the business would notice being broken — pricing, permissions, eligibility, anything with arithmetic or an edge case in it. Test the boundaries where your system meets someone else's, including how it behaves when the other side fails. And keep a small number of tests that walk the two or three paths that must never break, end to end, through real infrastructure. That set is a fraction of a maximal suite and catches most of what would otherwise reach production.

Digging out without stopping the roadmap

The move that works isn't a testing sprint. It's a rule: nothing gets tested retroactively, and nothing changes without a test. When a bug is found, the first commit reproduces it as a failing test. When a module gets a new feature, that module gets pulled apart far enough to be testable first. Coverage then grows along the exact contours of where the code is actually being touched, which is where the risk lives, and it never requires a quarter in which no features ship.

The uncomfortable part is being honest about what the original decision was. Skipping tests doesn't save time. It borrows it, from a version of the team that will have less context, more code, and no standing to refuse the loan.

Share

Get More Practical Insights.

Receive new articles and guides on AI, software, operations, and digital growth.

Let’s build what’s next

Ready to Build a Smarter Future for Your Business?

Whether you’re launching a new product, modernizing systems, automating operations, or exploring AI, Vertex can help turn your next idea into a practical, scalable solution.