build decisions

Why "Cheap Software" Is the Most Expensive Decision You'll Ever Make

Imran GardeziFebruary 19, 202614 min read

Last year a founder showed me his invoices. $15K to build. $30K to fix. $50K to rebuild. Same product. Three different teams. Two years. $95K gone. And he's back to square one.

He's not the exception. He's the average.

I've rebuilt all of them. The pattern is always the same.

Today I'm walking you through the full spectrum of "cheap." The math nobody shows you. And five questions that would have saved him every dollar.

Cheap isn't one thing. It's a spectrum. Five price points. Five different failure modes. But they all end up in the same place: expensive rubbish.

The $5K No-Code Build

Option one. The $5K no-code build. Bubble. Webflow. Glide. Whatever the tool du jour is.

Someone builds you a demo. It looks incredible. Buttons click. Data flows. Animations are smooth. Your investor deck has screenshots. Everyone's excited.

For a while.

100 users? Fine. 500? Getting slow. 1,000? The platform can't handle it. And you're stuck.

But here's the part that actually kills you. You don't own anything. Your data sits on someone else's platform. Your logic lives in their visual editor. Your business runs on their pricing decisions. Their uptime. Their roadmap. Their priorities. Not yours.

Customization beyond what the tool allows? Not possible. Integration with your CRM in a way that actually works? Good luck. A custom workflow specific to your business, the thing that actually makes you different? The platform wasn't built for that.

And migration off the platform? $30K minimum. Just to get YOUR data into a system you actually control. That's not an estimate I'm making up. That's the real number I've quoted to founders who came to me locked into platforms that changed pricing overnight. 30%, 40% increases. No negotiation. And there's nothing you can do because migrating means rebuilding everything from scratch. Every screen. Every workflow. Every integration.

The $5K build becomes a $35K rebuild. Plus months of downtime during migration. Plus the customers who leave during those months.

The no-code pitch is "anyone can build software." That's true. The part they leave out is: anyone can build software that breaks at the exact moment it starts to matter. No-code tools are excellent for prototyping and validating ideas. They become a liability when you confuse the prototype with the product.

The $15K Offshore Agency

Option two. The $15K offshore agency.

The communication gap starts on day one and never closes. An eight-hour time zone difference means meetings at 6am or 11pm. Requirements lost in translation, not because anyone's bad at their job, but because nuance doesn't survive a 12-hour turnaround on Slack. "The button should feel snappy" becomes "the button loads." "The dashboard should prioritize recent activity" becomes "the dashboard shows data." Close enough to demo. Not close enough to ship.

The code arrives. It "works." Pull back the curtain and it's a horror show. No tests. No documentation. No error handling. Copy-paste from Stack Overflow with the comments still in. Functions that are 500 lines long. Variable names like temp1, temp2, temp3. This isn't a stereotype. This is what I find in audit after audit when I open the hood on offshore builds.

I've audited offshore builds where the same bug was fixed and re-introduced four times. Four times. Because there was no test to catch it. No CI pipeline to enforce it. No code review to flag it. The developer who fixed it last week isn't the developer who's working on it this week. Without automated safeguards, each handoff is an opportunity for regression.

When the agency finishes, they're gone. Contract done. Maintenance? Your problem. But your in-house team takes one look at the codebase and says, "We can't work with this."

So you pay someone new $30K to understand it. Then $20K to fix the critical stuff. Then you're staring at a $50K rebuild because the foundation is rotten.

The $25K Freelancer

Those first two are obvious traps once you see them. This next one is more dangerous. Because it actually feels right.

Option three. The $25K freelancer. One person. Direct communication. Faster iteration. You're thinking, "This is the sweet spot."

But one person means one bus factor. They get sick: two weeks lost. They land a better gig: they ghost entirely. More often than you'd think. The whole project lives in one person's head. No process. No handoff plan. No documentation.

I've seen founders six months into a freelancer build when the freelancer disappears, and now they're sitting on 60% of a codebase nobody else understands. No docs. No architecture diagram. Just code and silence. The founder doesn't even know what "done" looks like because the only person who could explain the system is unreachable.

Hire another freelancer. They spend the first month figuring out what the last person built. If the code is clean, maybe they can work with it. If it's not? They tell you to start over. And they're right, because building on a rotten foundation just means you inherit someone else's technical debt plus your own.

The $50K Mid-Range Agency

Option four. The $50K mid-range agency.

Better code. Real process. Standups, sprints, a project manager sending you polished weekly updates with progress charts and burn-down graphs. Sounds professional.

Except half your budget goes to people who don't write code. Project managers. Account managers. QA leads. Design directors. Scrum masters. You're paying for their overhead. Their office in a trendy neighborhood. Their sales team's commission. Their CEO's thought leadership budget.

$50K budget? Maybe $25K of that touches actual development. The other $25K is the machine that surrounds the developers. Not the developers themselves. You're funding an organizational chart, not a product.

And the process is their process. Designed for their efficiency, not your product. Three-week discovery phase. Two-week design sprint. Six-week development cycle. Two-week QA pass. Four weeks of revisions. That's 17 weeks before you have something usable.

The agency isn't lying to you. They're just built to be expensive. Big teams. Big overhead. Big invoices. The code is decent. But "decent" at $50K is a terrible deal when "excellent" at $30K exists. The question isn't whether agencies deliver. It's whether the delivery structure matches the value you're actually receiving.

The Right Tool

Let me pause here and tell you a story.

I worked on a museum exhibit once. 3D scanning rooms for an interactive experience. We needed a scanner. Three options.

$200 iPhone LiDAR app. Impressive on paper. Looked great in the Apple keynote. But in practice? A toy. Inconsistent scans. No API. No way to integrate it with our system.

$40,000 industrial Leica scanner. Millimeter precision. Incredible piece of hardware. Total overkill for what we needed. Like buying a Formula 1 car to pick up groceries.

$4,000 Matterport. Purpose-built for spatial scanning. Accurate enough for our use case. Had the API we needed. Reliable. Documented.

We went with the $4,000 option. Not because it was in the middle. Because it matched the constraints of the actual project.

Software is the exact same. You're not choosing cheap versus expensive. You're choosing the right system for your environment. And the right system is the one that still works in year two.

The $5K no-code is the iPhone app. Looks cool. Can't do the job when it matters. The $50K agency is the Leica. Over-engineered. Over-priced. More capability than you need, packaged with overhead you don't.

I had another client. Three agencies before me. Three. Over $100K spent. They had mockups. They had code. They had invoices. They had nothing usable. Each agency inherited the last one's mess. Each agency made it worse. The founder told me, "Imran, I feel stupid. Everyone else seems to get this." He wasn't stupid. He was shopping on price. And price was the wrong filter.

The Math

Now let me show you the math. Because numbers don't lie and feelings don't scale.

The cheap path. Pick any option from that spectrum. Let's use the $15K offshore build because I see it most often.

$15K initial build. Ship fast. Everyone's happy. It works. For a while.

Six months later the cracks show up. Database can't handle the load: $15K to restructure. Auth was built from scratch because the developer thought it was "easy": $15K to rip it out and replace with Clerk. No monitoring. No tests. No idea what's breaking until a customer tells you: $10K minimum to retrofit. Tight coupling everywhere, where you can't add features without something else breaking: $20K to untangle.

And eventually? The accumulation of all these fixes on top of a bad foundation? Full rebuild. $50K.

Total: $15K initial. Plus $30K in emergency fixes. Plus $50K rebuild. Equals $95K.

And that's just the invoices. Add the lost revenue while things were broken. The lost users who churned and never came back. The 6 months you spent fixing instead of growing. The developer who quit because the codebase was a nightmare.

Now. The production-grade path. $20K to $30K initial build. Takes a few weeks longer. Costs more upfront. Feels expensive in the moment.

But it has real auth. Clerk, not custom. Real data model with proper indexes and relationships. Caching strategy from day one. Error handling that catches problems before your users do. Observability so you know what's happening in production. Clean deploys. Automated testing. Documentation. Handoff-ready. Someone else can pick this up and work on it without wanting to set it on fire.

Year one maintenance: $5K. Mostly minor updates and small feature additions.

Total over the same period: $25K to $35K. Still working. Still scaling. Still shipping features without rewrites.

The "expensive" option was a third of the price. And you got two years of momentum instead of six months of hope followed by twelve months of crisis.

Now think about the opportunity cost. Six months rebuilding is six months not growing. Your competitors are shipping features while you're rewriting code that should have worked the first time. Six months of lost momentum in a startup can be the difference between raising your next round and running out of runway. I've watched it happen. Founder has traction. Users. Revenue growing. Then the rebuild hits. Everything stalls. Investors start asking questions. Team morale drops. And the founder's back to square one except now they've burned through half their runway.

Why This Always Happens

Why does cheap always cost more? Three reasons. Same reasons. Every time.

First: incentive misalignment. Who benefits from a fast, cheap build? Everyone. Founder gets the product. Developer gets paid. Agency moves on to the next client. The no-code platform gets another success story for their marketing page. Everyone's happy. Handshakes all around.

Who suffers from that same build six months later? Just the founder. The agency has been paid. The freelancer has moved on. The no-code platform doesn't care. You're left holding the bag. And nobody had any incentive to say "let's slow down and do this right." The incentive structure rewards shipping fast, not shipping right. Until someone restructures that incentive, the outcome is predictable.

Second: invisible quality. You can see if the button works. You can see if the page loads. You can see the design. You can't see if the authentication is secure. You can't see if the database will handle 10x users. You can't see if the code is maintainable.

Think about a house. Thin foundation. Cheap framing. Skip the drainage. House stands. Looks fine. You move in. Six months later: foundation cracks. Basement floods every rain. Breakers trip when you run the AC. Can't add a second floor because the structure won't hold it. Contractor takes one look. "We can fix the symptoms. But the foundation? That's a different conversation." Fix costs 3x what building it right would have cost.

Third: technical debt compounds. Technical debt is financial debt. You're paying interest whether you see the invoice or not. Every feature that takes two weeks when it should take three days? Interest. Every bug you fixed last month that's back? Interest. Every developer who quits because the codebase is a nightmare? Interest. Every time you're scared to deploy on a Friday? Interest.

It compounds. Year over year. Until the only option left is a full rewrite. Back to zero. And with software, while you're rebuilding, your users don't wait. They leave.

Five Questions

Five questions. Ask every single one before you write the check. I don't care if it's a $5K build or a $75K build. These apply.

"Show me the test suite." Not "do you test?" Everyone says yes. Show me. Pull it up. Right now. Let me see it run.

No tests? Fragile. Every change is a gamble. Every deploy is a prayer. You're shipping and hoping.

"What happens at 10x our current users?" Not "can you handle growth?" Walk me through it specifically. What's the database strategy? Where are the bottlenecks? What breaks first and what's the plan when it does? A vague answer is a red flag. "We'll optimize when we get there" is not a plan. That's a hope. And hope is not a strategy.

"If you disappear tomorrow, can someone else maintain this?" Documentation. Architecture diagrams. Inline comments. README files. Handoff guide. No docs means hostage situation. You're locked to this person or this team forever. Or you're paying someone else $30K to reverse-engineer everything.

"How are passwords stored?" This one is a litmus test. If they're building auth from scratch, ask why. The answer better be extraordinary. "We use Clerk" or "Auth0" or "Supabase Auth." Good. $25 a month for battle-tested security maintained by dedicated security teams. That's the right answer. If they say anything about building it themselves because "it's not that hard," that's your sign. Auth is security. Security is liability. Liability has no ceiling.

"Show me the deploy process." Automated? Push a button and ship? Or is it manual, multi-step, ssh into the server, run these three scripts, pray nothing breaks? Manual deploys equal broken process. Broken process equals slow iteration. Slow iteration means you're paying more to move slower.

Pass all five? You're in good hands. Fail three or more? Walk away. Doesn't matter how cheap the quote is.

These five questions don't test skill. They test judgment. Anyone can build a login screen. Not everyone thinks about what happens when it breaks at 2am.

Code runs. Software survives.

The Close

Here's the reality.

You don't need the cheapest option. You don't need the most expensive option. You need the right option.

The difference between a $15K build and a $30K build isn't the typing. It's what doesn't break. What scales. What you can hand off. What still works in year two without a rewrite.

If you're about to build for the first time, run the five questions on every option. Let the answers do the talking.

If you've already built and something feels off, here's a quick diagnostic. Features take twice as long as they should? That's a facelift situation. UI tweaks, slow queries, surface fixes. Four weeks. Manageable. Scared to deploy on a Friday? That's a heart transplant. Core architecture is broken. Full rebuild. Six-plus months. The distinction matters because the fix for a facelift is targeted improvement. The fix for a heart transplant is a structured rebuild. Applying the wrong fix wastes the budget and makes the problem worse.

Don't know which one you're dealing with? That's what the Strategy Session is for. Ninety minutes. I'll tell you exactly where you stand.

Key Takeaways

Cheap software is a spectrum with five distinct price points, each with its own failure mode, but they all converge on the same outcome: a rebuild that costs 3x to 6x the original investment. Understanding which trap you're walking into is the first step toward avoiding it. The $5K no-code, $15K offshore, $25K freelancer, and $50K agency each break differently but break inevitably.
You're buying judgment, not code, and the difference shows up 6 to 12 months after launch. The experienced partner who costs more per hour makes decisions that save you $100K. They tell you what not to build, push back on bad assumptions, and design for production reality from day one. The cheap option says yes to everything, builds exactly what you ask for, and leaves you with the bill when it breaks.
The math always favors building right: a $15K offshore build routinely turns into $95K or more once you add emergency fixes, lost revenue, and a full rebuild. A $20K to $30K production-grade build with real auth, proper monitoring, and clean architecture costs $25K to $35K total over the same period. The "expensive" option is literally a third of the price.
Technical debt compounds exactly like financial debt, and you're paying interest whether you see the invoice or not. Every feature that takes two weeks instead of three days, every bug that keeps reappearing, every developer who quits because the codebase is unmaintainable. That's all interest. The longer you wait to address it, the more you owe, and eventually the only option is a full rewrite back to zero.
Five questions will tell you everything you need to know before writing a check: show me the test suite, what happens at 10x users, can someone else maintain this if you disappear, how are passwords stored, and show me the deploy process. These don't test skill. They test judgment. Pass all five and you're in good hands. Fail three or more and walk away regardless of the quote.

Frequently Asked Questions

Why does cheap software always end up costing more than building it right the first time?

Three structural forces make cheap software expensive: incentive misalignment, invisible quality, and compounding technical debt. The agency, freelancer, or no-code platform benefits from shipping fast and moving on. Nobody in that transaction is incentivized to say "let's slow down and do this right." Meanwhile, the quality problems (security gaps, scaling limitations, unmaintainable code) are invisible until they become emergencies. And technical debt compounds like financial debt, so the $15K you saved upfront generates ongoing interest in the form of slower features, recurring bugs, and developer turnover.

What is the real cost of a $15K offshore software build over two years?

In the projects I've audited, a $15K offshore build typically reaches $95K to $120K within 18 to 24 months. The pattern is consistent: $15K initial build, $15K to restructure the database when it can't scale, $15K to replace hand-rolled authentication with a proper service, $10K to add monitoring and testing that should have existed from day one, $20K to untangle tightly coupled code, and eventually $50K for a full rebuild because the foundation can't support further fixes. Add lost revenue during downtime and churned users who never return, and the real cost exceeds $120K for what started as a "$15K deal."

How do you evaluate whether a software developer or agency will deliver quality work?

Ask five specific questions before writing any check. First, "Show me the test suite" (not "do you test?"). Second, "What happens at 10x our current users? Walk me through it." Third, "If you disappear tomorrow, can someone else maintain this?" Fourth, "How are passwords stored?" (if they built auth from scratch without a compliance reason, that's a red flag). Fifth, "Show me the deploy process." These questions test judgment, not skill. A developer who passes all five understands production reality. A developer who fails three or more will deliver code that works in demos but breaks under real-world conditions.

What is the difference between a software "facelift" and a "heart transplant"?

A facelift means the core architecture is sound but the surface needs work. Features are slow, the UI feels dated, queries could be optimized. This is a four-week engagement with targeted improvements. A heart transplant means the core architecture is broken: tightly coupled code, hand-rolled auth, no monitoring, scared-to-deploy Fridays. This requires a structured rebuild that takes six-plus months. The critical mistake is applying a facelift when you need a heart transplant, because surface fixes on a rotten foundation just waste budget and delay the inevitable rebuild.

Should startups use no-code platforms to build their first product?

No-code platforms are excellent for one thing: validating an idea before investing real money. Build a prototype, test it with users, prove demand. That's a legitimate $5K experiment. The mistake is treating the prototype as the product. No-code platforms cap your customization, lock your data on someone else's infrastructure, and make you dependent on their pricing decisions and uptime. When the platform raises prices 40% overnight (and I've seen this happen), you have no leverage because migrating means rebuilding everything from scratch. Use no-code to validate. Then build production-grade when you've proven the idea works.