Custom development vs no-code: when each one makes sense

"No-code will replace development." "No-code tools collapse at scale." Both extreme positions are false. The useful truth is this: there are problem categories where no-code always wins, others where code always wins, and a middle ground where the decision depends on variables that change every 18 months.

When no-code always wins

Internal processes for non-tech companies, with < 50,000 executions/month, where business logic changes faster than a dev team could implement it. Typical examples:

• Back-office workflows (lead assignment, delivery note sending, basic payment reconciliation).
• Internal dashboards for non-technical teams that need to be edited without asking a developer.
• Forms and internal portals (Tally, Softr, Glide).
• Marketing/sales automation (Make, simple n8n, Zapier).
• Ultra-early MVPs where validation matters more than architecture.

In these cases, custom code costs 5-10x more and falls behind business change. No-code is the right answer, and if built well, it scales much further than anti-no-code discourse suggests.

When custom code always wins

• Commercial product (B2B SaaS, owned e-commerce, marketplace). Your UX is part of the product; you cannot depend on Bubble's UX.
• Critical performance. More than ~100k operations per hour, latency < 200ms.
• Deep compliance/security. SOC 2, HIPAA, PCI require stack control.
• Proprietary algorithms. If your IP is code, locking it inside a third-party platform gives away your value.
• Integrations requiring transactional consistency. Real ACID, not eventual consistency with retries.

The middle ground (where projects break)

This is where projects that started in Bubble/Webflow + Airtable live after growing enough for the tool to become a bottleneck, but not enough to justify rewriting everything. The question is not "should I migrate?" It is "what is the value of six more months in the tool vs rewriting now?"

Signs you reached the no-code limit:

• Your CTO/dev needs workarounds to do basic things (three concatenated Airtable formulas because there is no subquery).
• Platform costs exceed US$1,500/month and keep growing.
• Release speed dropped because every new feature requires reorganizing the base.
• Your B2B customer asks for things you cannot offer (SSO, public API, on-prem).

Portfolio strategy (the honest answer)

The most efficient companies we see do not choose one thing. They manage a portfolio of stacks by problem category:

Need type	Recommended stack
Commercial product / SaaS	Custom code (Next.js, Postgres, etc.)
Changing back-office	n8n + Postgres + minimal coded UI
Internal portals/dashboards	Retool, Tooljet, or whatever is lovable
Marketing site / landing	Framer, Webflow, or Next.js if you have dev capacity
Forms and lead capture	Tally, Typeform
Documents / contracts	DocuSign + automation with Make/n8n

The code-everywhere anti-pattern

A 6-person company wrote its own internal CRM with React and Postgres, spent 4 months of one of its best engineers, ended up with a product worse than HubSpot, and by year 2 no developer wanted to touch it because nobody maintained it. That same team could have bought HubSpot Starter for US$200/month and dedicated that engineer to its core product.

Code-everywhere kills startups just as much as no-code-everywhere kills companies at scale.

24-month cost comparison (typical project)

"Internal client portal with login, dashboard, file upload and comments". Support team: 1 senior dev + 1 PM (half-time).

• No-code (Softr + Airtable + Make): setup US$3,500. Monthly US$280. 24-month total: US$10,220.
• Low-code (Retool + Postgres): setup US$9,000. Monthly US$190 (Retool + hosting). 24-month total: US$13,560.
• Custom code (Next.js + Postgres): build US$28,000. Monthly US$120 (hosting). 24-month total: US$30,880.

The no-code portal is 3x cheaper, and enough for 80% of cases. Custom code only wins if you need premium UX, complex integrations, or you will scale to 50k+ users.

Does no-code scale?

Yes, as far as the SaaS behind it scales. Airtable handles millions of rows on enterprise plans. Webflow supports sites with millions of visits. The question is not whether it scales; it is whether it makes economic sense to scale there.

Who maintains the no-code setup when the builder leaves?

The same problem exists with code. Documenting the setup (15-minute Loom for each workflow + README) solves 90% of the issue. The difference is that documented no-code can be maintained by any basic technical person; documented code requires maintaining the language and framework.

Is hybrid always the answer?

For medium-large companies, yes. For very early startups, no: coordinating between stacks can cost more than it saves. Start monolithic (all no-code or all code) and add another category when it hurts.

What we recommend

Make a quick inventory of your internal systems. Mark each one as "core" (impacts the customer-facing product) or "support" (internal operation). Core almost always goes to custom code. Support almost always goes to no-code. The most expensive mistake is confusing the two categories.

If you are starting a new product: start in no-code if your hypothesis is not validated. Move to code when you have clear signals (recurring revenue, month-2 retention > 25%, feature requests you cannot build inside the platform).