Understanding the real cost curve of vibe-coded apps from MVP to production

The rental web is catching up to SaaS: bolt-together no-code frameworks like Lovable and Bolt promise a working UI in minutes and a fast path to MVP. The pricing looks honest—pay for what you use, stop when you stop. This lands well in early demos and hackathons. Here’s the catch: real apps grow, and subscriptions and credit models tilt the cost curve dramatically as “sandbox” usage becomes production. When you own your kit, you pay once, own the code, and the meter stops.

Most teams keep paying for the privilege of not owning the base—indefinitely.

Let’s walk through what you actually pay as usage scales, hard numbers, then where owning the kit breaks the loop.

Sandboxes are cheap — until you scale

Spin up a “workspace” or “app” on any payg tool. $10/mo covers a small app, some database rows, and a few thousand component renders. It feels like a win compared to the up-front cost and unknown effort to write your own stack.

This is exactly what breaks down.

Every metric you care about—seats, records, requests, storage, function calls—grows with your user base, features, or just being alive for months.

• 1,000 signups? That’s a plan bump.
• Overage charges on usage spikes, even when revenue didn’t spike.
• Want branding removed? That’s $39/mo instead of $9.

What felt like a cup of coffee a month compounds, and you never stop paying to hold your code hostage.

The numbers: a real scenario

Let’s model an app—a fitness tracker that launches on a Bolt-style platform. MVP supports 2,000 monthly active users, with a basic set of screens, modest logic, and some scheduled jobs.

• Sandbox: starter at $12/mo, capped to 500 records, single admin.
• Growth: bump to $39/mo for 3,000 records, +$15/mo for scheduled tasks, +$9/seat for guest trainers.
• Storage: 250MB included, +$5/mo per GB if users upload images or files.
• Function: 10,000 invocations included, then $5 for each 25k calls.

In three months:

$39 base
+ $15 jobs
+ (5 trainers × $9)
+ $10 extra storage
+ $10 extra function invocations 
= $119/mo

Annualized: $1,428 just to keep the doors open—no codebase portability, no local dev, no change of infra.

The “cheap” period ends as soon as you have a feature or user graph that grows.

The unit economics don’t trend in your favor

Sandbox platforms charge per feature and usage. You keep paying for:

• Each additional record or row (users, events, invoices), not just storage
• User seats (we see 2× headcount tax on a growing ops team)
• Function execution (every API call, even for scheduled or periodic jobs)
• Non-branding
• Moving off their infra (a “download” often costs extra or is blocked at scale)

A single spike—say, a PR mention—can cost 10× your expected run rate that month.

You “own” nothing: code, infra, or price stability.

What your $99 buys when you own the kit

Contrast: buy a kit like OTF’s full-stack Fitness or SaaS for $99, you pull the repo and own:

• Codebase: React/Expo + Hono + Postgres, editable end-to-end
• Design system: ~200 fully themed components for web + native (@otfdashkit/ui, @otfdashkit/ui-native)
• Auth, payment, jobs, infra as infra—change them at will
• Real migrations and seeds you control (no row count lock-in)
• All source, invested in by contributors (not a walled garden)
• One-time cost: $99. All-in. Everything else is open-source, stays free (MIT).

Real cost: $99 + whatever infra you pick (could be $0/mo on a light Postgres + Vercel hobby plan). Years out, the marginal cost is still zero.

enable: own the output, swap the infra, and pay once.

[[IMG: cost-curve]]

Credit pricing: a compounding trap

Many sandbox tools push a credits model in place of fixed plans. It feels nimble (“only pay for what you use!”). The effect is pure opacity:

- 1 credit per 10 function calls
- 2 credits per auth
- 10 credits per thousand rows ingested
- 100 bonus credits for referrals

A marketing win—engineers struggle to model the real end-month cost.

We track teams who budgeted $40/mo on credits and hit surprise overages of $180. It’s justified by “the app’s successful”; in reality, you’re paying for table stakes: function calls and record inserts.

Compare to a real stack:

# Add a new tenant to the DB — no usage cap, you own the data
psql -d mydb -c "insert into tenants (name) values ('acme-gym');"

No credits to reconcile. No monthly meter. Just scale infra when you want (or not).

Features-as-cash-register

Here’s what the “pro” plans sneak in:

• White-labeling (hide their brand): a hard paywall. In your own kit, change a logo file (src/app/logo.svg) and you’re done.
• Scheduled jobs: triggers and background tasks, paid per interval or run, sometimes 10× the price of running your own cron.
• Third-party API calls: charge per call, even when cost to them is zero.
• Export: getting your own data usually costs a fee.

Each non-trivial feature is priced per-usage or locked behind tier upgrades.

Owning the kit: you own the background jobs. You own the scheduler (could be a 20-line cron file). Nothing to meter.

Migration isn’t a real option after the first month

Most sandboxes offer CSV or limited exports (“take your data elsewhere!”). For a trivial app, maybe. For any non-toy, friction is built-in:

• You leave behind source code, infra setup, business logic (triggers, workflows)
• UI is proprietary—not portable components, not React, not native code, not shareable.
• Migration means a total rewrite, plus data mapping pain.

When you buy and hold the kit, you fork a repo—no migration cycle. Just incremental upgrades.

Counter-arguments: what you do get with a sandbox

Credit where due: if success is not guaranteed and burn must be zero, sandboxes get you to a clickable demo for almost nothing. Their onboarding, env setup, and zero-deploy mean hours to prototype, not weeks.

• Right tool for dogfood and internal tools: Bypass procurement, just ship it.
• Zero-ops for hackathons: No one wants to debug VPC config at 2am.

But the cost curve is rarely part of the demo, and the trap is not avoiding sandboxes—it’s not exiting them.

OTF: buy once, own it forever

OTF is simple: the fee ends on day one. The kit is yours. Fully open source, under the MIT. Every full-stack kit, every core UI package is installable by npm or copy-paste, no meter.

When sandboxes fit:

• Disposable, single-owner apps
• MVPs you plan to throw away

When you hit retention, paying users, or production status—stop renting. The code that matters should be yours.

What this enables: full-stack kits you extend with real code, AI-tool ready configs, ship-to-prod deploy in one script. Never re-implement the basics just to break out of a lock-in fee.

Own the cost curve.

[[IMG: cost-slope]]

The lesson here is simple: buy and hold the base. When the work is real, rent stalls and owning compounds.