Buy SaaS when your process is standard and the tool fits without contortions. Use no-code to validate an idea or patch a small internal gap. Go custom when your process is your edge, when per-seat pricing has become a tax on growth, or when your team runs the business through spreadsheet glue between tools. The mistake isn't picking any one of these — it's staying in one after you've outgrown it.
The real question: whose process wins?
Every software decision is secretly a process decision. Off-the-shelf software encodes the vendor's idea of how your work should flow. Sometimes that's fine — accounting is accounting. But when the tool's process and your process disagree, one of them has to bend. Either your team contorts to fit the software, or the software bends to fit the team.
That's the whole framework. Everything below is just working out which side should bend in your case.
When off-the-shelf SaaS wins
SaaS is the right answer more often than a custom shop should admit. Buy, don't build, when:
- The domain is standardized. Payroll, accounting, email, calendars, generic CRM. Your way of doing payroll is not your competitive advantage — do not build payroll.
- The fit is 90%+ out of the box. If your team can work the vendor's way without daily friction, the subscription is cheap compared to owning software.
- You're small on seats and light on volume. $49/month is unbeatable. The math only turns when headcount and usage grow.
- The vendor's roadmap is your roadmap. You want the features they'll ship next. That alignment is worth paying for.
When SaaS quietly starts bleeding you
SaaS rarely fails loudly. It fails as a slow leak — and these are the signals we see over and over in operations work:
- The spreadsheet shadow system. The real process lives in exports, pivot tables and a "master file" someone maintains by hand, because the tool can't represent how you actually work. The tool has become a database with a subscription fee — the spreadsheet is the real app.
- Per-seat pricing × growth. 5 seats at $40 is fine. 40 seats at $40 is $19,200 a year, every year, forever — for software that still doesn't fit.
- Workflow contortions. Your team performs ritual workarounds — "put it in the notes field, then Maria re-types it into the other system on Fridays". Every workaround is unpaid integration labour.
- Plan-gated features. The one feature you need is on the Enterprise tier, bundled with fifty you don't, at 4× the price.
- Data hostage situations. Getting your own data out requires an API on a higher plan, a CSV that drops half the fields, or a support ticket.
One leak is livable. Three or more, and you're paying subscription prices and the hidden cost of bending your business around someone else's product.
When no-code is enough — and where its ceiling is
No-code tools (Airtable, Glide, Bubble, Zapier and friends) are genuinely good at two jobs:
- Validating an idea. Prove people want the thing before investing in real software. A weekend of Airtable beats a quarter of speculation.
- Small internal gaps. A form that feeds a table with three views and one automation. If it stays that size, it's done — ship it and move on.
The ceiling shows up predictably: record limits, automations that fail silently, logic scattered across a dozen zaps nobody dares touch, per-user pricing that scales worse than SaaS, and performance that degrades exactly when usage proves the tool mattered. No-code is also still lock-in — you own the idea, not the system.
Our rule of thumb: no-code is a great way to discover your requirements and a poor way to run them long-term at scale. Treat it as a draft, and budget for the day it gets rebuilt properly — that's often a one-week prototype, not a moonshot.
When custom pays for itself
Custom software used to need enterprise budgets. That's no longer true — AI-accelerated builds moved the break-even point dramatically. Custom wins when:
- Your process is the product. The way you quote, schedule, route or fulfil is why customers pick you. Encoding it in software compounds the advantage; renting a generic tool erodes it.
- The subscription math crossed over. A $12,000 fixed build that replaces $1,200/month of seats pays for itself in ten months — and you own it after.
- You're the integration. If humans re-type data between three systems, the custom build isn't a luxury; it's removing a full-time hidden job.
- Off-the-shelf says "no" to your best ideas. When the improvement your team wants most is impossible in the vendor's product, the roadmap conversation is over.
The five questions to ask
- Is this process a competitive edge, or commodity plumbing? (Edge → custom. Plumbing → buy.)
- What do current tools cost per year — subscriptions plus hours spent on workarounds and re-typing?
- Can the team work the vendor's way without a shadow spreadsheet system? Honestly?
- What happens at 2× your current volume — does the tooling scale, or does the pricing?
- If you had the perfect tool, what would it do that today's stack can't? If the answer is specific and valuable, that's a spec.
| Situation | Pick | Why |
|---|---|---|
| Standard domain, good fit, few seats | SaaS | Cheapest path; vendor maintains it |
| Unproven idea, small internal gap | No-code | Fast to try, fine to throw away |
| Process is your edge; growing seats; spreadsheet glue everywhere | Custom | Fixed cost, exact fit, you own it |
The honest disclosure
We build custom software for a living, so weight our bias accordingly — but notice the framework sends most standard problems to SaaS. That's deliberate. Custom builds only make sense where they clearly win, and a studio that tells you otherwise is optimizing for their invoice, not your business. It's the same reason we fixed-price everything: the incentives should point at your outcome.