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

A Lovable or Bolt sandbox delivers instant dopamine — ship a working web app in an hour, no local setup, full UI. The appeal isn't hard to see. The early user demo loves it: every form and page is editable on the live site; every small ask reruns the AI loop. But by the time you scrape past week six, there's a new reality: every edit pings a backend you don't control, metered by subscription plus credits for every tweak, feature, or deployment. The launch price is a foot in the door — but the meter never ends.

The real question isn't "Can AI build a web app for $0 down?" It's: "If my demo gets traction, how much do I pay in month 1…12…24? What do I actually own at the end?"

Making the real cost curve explicit — what you keep paying to rent a sandbox, versus a one-shot kit you own — is the only way to choose sanely, not impulsively.

Why a subscription sandbox feels cheap (until it isn't)

The cost structure of sandbox platforms is designed for zero friction up front. Sign up, build, and deploy a logo-worthy app — all before lunch. You pay nothing, or next to nothing, until you want:

• Persistent data or production DB
• Custom domain and SSL
• Collaboration or access provisioning
• API or integration beyond the 10 “easy” ones
• Uptime beyond hobby scale
• Exports or real staging environments

Each surface is free — until it isn't. Costs expand along two axes: volume (users, deployments, traffic) and scope (features, plugins, advanced config). And both are enforced not by a one-off, but by recurring fees: monthly base plan + usage credits.

A typical subscription model breaks down like:

| App Stage      | Subscription | Credits Usage            | Total Annual (sample) |
| -------------- | ------------ | ------------------------ | --------------------- |
| MVP (1-2 users)| $0–$29/mo    | Light AI, low deploy     | $0–$348               |
| Pre-launch     | $29–$89/mo   | More edits, test users   | $348–$1,068           |
| Production     | $89–$249/mo  | Steady traffic, more AI  | $1,068–$2,988         |
| Growth         | $249+/mo     | API, staging, heavy use  | $2,988+               |

Plus: bills spike anytime you re-run the "AI build" loop after an edit, or hit credit thresholds for API calls/code generation/build minutes. Most devs don't model this at the whiteboard. But on day 55, when the finance tab lights up, the experiment reads as "success" — but the tool has become the landlord.

Takeaway: the upfront experience is optimized, but the ongoing cost is not. You rent, indefinitely.

What owning your kit actually changes — the end of the meter

Paying $99 up front for a kit you own flips the equation. It's a car, not a rideshare: a flat fee, shipped code, and your domain. Run the numbers:

• Up front: $99 (one kit), or $149 (bundle)
• You own 100% of the codebase: not “editable JSON” but full-stack sources (UI, backend, themes, tests, scripts)
• AI tool configs and prompts are included — you extend, don't re-regenerate
• No monthly fee for new features, user volume, or build minutes
• Ship to your own infra — $0 in surprise “credit” debits

After 12 or 24 months — or 10,000 users instead of 100 — the incremental cost is exactly $0. No algorithmic meter: just standard hosting, which you shop for.

It's captured by one constant:

// net cost at month N, single kit
const upfront = 99             // dollars
const recurring = 0            // for OTF — you own the source
const infra = estimateHost(...) // your Netlify / Vercel / R2 / Own S3

const total = upfront + N * recurring + N * infra

Whereas a sandbox's recurring is min(creditFloor, actualUsage) for every feature you gate.

Takeaway: a one-off is a cap, not a starter fee. Ownership ends the meter.

The real cost curve: proof, not posturing

Numbers make this concrete. Model the costs for a solo founder app, two paths:

Sandbox (Bolt / Lovable):

• $29/mo starter plan after trial
• $40/mo API credits (averaged over new features, test runs, build minutes)
• Grows to $89/mo at launch, $179/mo at early traction

Owned kit (OTF):

• $99 once (SaaS Dashboard), or $149 for all kits
• Standard hosting ($5–25/mo for typical apps, <1k DAU)
• No per-feature, per-build, or per-redeployment fee

Twelve months in:

| Platform      | 12-month Total |
| ------------- | -------------- |
| Sandbox       | $1,329         |  [$89/mo ×12 + avg. $40/mo credits]
| OTF           | $99 + $240     |  [$99 + $20/mo hosting]

The gap only grows with every extra feature, edit, or prompt rerun in the sandbox — every cycle is another fee.

Takeaway: At any horizon beyond two months, rent compounds. Owning compacts.

What you own at exit: full-stack vs fragments

"Export your code" in most sandboxes is a veneer — at best, you get a messy .zip, incompatible with upstream. Critical parts are still black-boxed: plugins, AI prompt history, build pipeline. The vendor lingo here is "enough to 'take it elsewhere'." In practice, you own a snapshot, not a codebase.

The difference:

• Sandbox: UI fragments, auto-generated data models, vendor-locked auth/integrations, no real CI/pipeline, broken AI context (no prompt history).
• OTF: Complete monorepo — all UI + logic + CI + infra scripts. One codebase that runs locally, in your CI, and deploys to prod, your way. Lift-and-shift possible.

Takeaway: Real ownership means you don’t depend on a "hosted builder" to keep the lights on, or a static export that rots the minute you want a new feature.

Shipping cost: feature velocity after month one

Modifying features in a sandbox is a budget item. Each new page/form trips an AI "build" — counted as a credit. Want to swap design tokens, run a full suite of tests, or add a new auth provider? Three options:

• Wait for high-latency LLM loop, burn more credits, wrestle with locked templates
• Code a sidecar plugin, which isn't really supported
• Open a support ticket and cross your fingers

In an owned kit, the extension path is just code:

# Add a new page
npx otf add page payments

# Edit design token, propagate across all platforms
npx otf theme edit --primary=teal

# Run tests locally, not per-credit
pnpm test

No credit grind, no "regen" lag, no dependency on the vendor's roadmap.

Takeaway: Feature velocity becomes a dev decision, not a financial tradeoff.

How to actually own the kit — the one command path

Ownership is a one-liner. Any paid OTF kit (SaaS, Booking, Fitness) is:

npx otf new saas-dashboard
# or for all kits and demos
npx otf download bundle

After that, it's your code, your repo. No git proxy, no vendor lock.

Additional configuration:

• Custom domain + SSL: ship with npx otf deploy --domain yourapp.com
• Mobile build: npx otf build mobile
• AI prompt configs: editable in ai/prompts/, not locked away

The meter ends there. No ongoing enables to buy.

Takeaway: The codebase that ships is yours — extensions, builds, edits, no recurring bill.

What this enables for real projects

Startups die on the cost curve: surprise recurring costs, coupled to someone else’s incentive to maximize ARPU (average revenue per user). OTF flips recurring upside down, minimizes up-front risk (single low price), and maximizes ownership. This changes:

• Nonprofit? Avoids a lifetime meter — own once, ship to cost-hosting
• Agency? Ship to clients, bill once, keep no vendor tax
• Indie? Pause your app for a year — your repo, no clock running

The intangible win: the source is not a screenshot or a zip. It’s the one primitive every developer still trusts: a folder of code you can git push anywhere.

Closing

A subscription sandbox feels cheap — until shipping features means counting credits, not just hours. The real cost curve is brutal if you don’t own your base. Pay once for the kit, and own your app at every scale. The meter stops the day you run npx otf new. The sandbox can't offer you that.