The maintenance bill for replacing SaaS with vibe coding has two layers, not one.
Most pages on this question quote one number, somewhere between $20 and $200 a month, and call it the cost. That number conflates two different bills: the build tool you use to iterate, and the substrate the app actually runs on (Postgres, email, repo, analytics). The build tool is what you pay while you keep changing the app. The substrate is what you pay forever. They have different shapes, different ceilings, and different lock-in. mk0r is the worked example for splitting them, because every session provisions four real substrate accounts you own.
Direct answer, verified 2026-04-30
For a typical small-CRUD SaaS replacement (under 0.5 GB of Postgres data, under 3,000 emails per month, one private repo), the practical monthly maintenance cost is roughly $0 on the substrate plus $19/mo on the build tool while you keep iterating. After you stop iterating, you can clone the GitHub repo we created and run the app yourself for $0/mo at small scale.
Substrate ceilings checked against neon.com/pricing (0.5 GB / project), resend.com/pricing (3,000 emails / month), and github.com/pricing (unlimited private repos, free). Build-tool price verified in src/app/checkout/page.tsx line 105.
The number you have been quoted is half of the bill
Walk through the takes that show up everywhere on this topic and you can sort them into two buckets. Bucket one quotes a build-tool subscription: $20 for Cursor, $25 for Lovable, $19 for mk0r, plus token spend. Bucket two quotes a doomsday rebuild number, $50K to $100K, on the assumption that vibe-coded apps eventually need a professional rewrite to be safe in production.
Both are about the build tool. Neither is about the substrate. The substrate is the part that does not go away when you stop iterating: a Postgres somewhere, an email-sending account somewhere, a place the code lives, a place you watch traffic. Every running app, vibe-coded or not, has a substrate. The maintenance cost question is fundamentally about that.
The reason the takes lump them together is that most build tools ship the substrate inside the tool. Bolt deploys to its own runtime, Replit Agent uses Replit's own database, v0 is glued to a single deployment target. When the substrate is welded into the build tool, the bill looks like one number. mk0r's choice is to fan out to four real provider accounts under your line of access, which makes the two bills visible and separable. That separation is what this page is about.
What a typical SaaS-replacement stack costs, side by side
Concretely, here is a representative stack a solo founder is replacing: a habit tracker, a booking page, a small internal CRM seat, a survey tool, a form builder, a niche dashboard. List prices on each in 2026 sit between $9 and $30. The replacement story has to compete with the sum of those, not with one of them.
$127/mo of small SaaS, or $19/mo while iterating
Habit tracker SaaS: $9/mo Booking-page SaaS: $19/mo Niche CRM seat (x2): $30/mo Internal dashboard: $25/mo Survey tool: $19/mo Form builder: $25/mo ────── Stack total: ~$127/mo Maintenance: five vendor dashboards
- Six monthly bills, six dashboards
- Cancel one and the workflow it powers stops
- Maintenance: chasing renewals across vendors
The substrate, in code, line by line
This is the part most cost articles omit. When you claim a new mk0r session, four real provider calls fire before the agent has run any tool. Open src/core/service-provisioning.ts on GitHub. The function at line 277 wraps Resend, Neon, and GitHub in a single Promise.allSettled at line 297, with PostHog allocated synchronously at line 82. The five env vars (DATABASE_URL, RESEND_API_KEY, GITHUB_REPO_URL, VITE_POSTHOG_KEY, VITE_POSTHOG_APP_ID) land in /app/.env at line 367 before your prompt finishes streaming.
| Feature | Typical paid stack | mk0r-provisioned per session |
|---|---|---|
| Build / iteration cost | Cursor + Claude API: $20 + token spend | $19/mo flat after 21-day trial |
| Postgres | Self-managed RDS or Supabase Pro ($25/mo) | Neon free tier per session, 0.5 GB / project |
| Transactional email | Postmark / SendGrid Essentials ($15-$19/mo) | Resend free tier per session, 3,000 emails / mo |
| Code hosting | GitHub free or Pro ($0-$4) | GitHub private repo on your account, free |
| Analytics | Mixpanel / Amplitude paid plans | PostHog app id, shared project, $0 |
| Net substrate at small scale | $60-$70/mo across vendor seats | $0/mo on free tiers, account ownership intact |
At small CRUD scale (under 0.5 GB Postgres, under 3,000 emails/month, one repo). Beyond those ceilings the substrate becomes paid.
What the substrate ceilings actually are
Free tier is not a marketing word, it is a number. These are the four ceilings, all verified on each provider's pricing page on 2026-04-30.
A habit tracker for one user does not get near any of those. A vertical CRM with three teammates does not get near any of those. A booking page for a single coach does not get near any of those. The categories where vibe coding genuinely substitutes for a small SaaS subscription are the same categories that fit comfortably inside these ceilings. That is not a coincidence, it is why the substitution works at all.
The cost shape that survives cancelling the build tool
The maintenance cost question is really the question of what happens when you stop using the build tool. With a vendor-locked tool, the answer is "the app stops." With mk0r, the answer is "the app keeps running on the substrate accounts already on your line of access."
What you own after you cancel
// Vendor-locked vibe-coded app
//
// The build tool runs the database for you.
// The build tool runs the email API for you.
// The build tool owns the deploy URL.
// The build tool owns the git history.
// You can export, sometimes.
// You cannot keep running it for $0.
// Cancel the build tool, the app stops.
//
// 1 cost path: build-tool subscription
// 1 lock: you do not own the substrate
// 1 maintenance ceiling: vendor's free tierWhen the maintenance number stops being roughly $0
Three tripwires push the substrate off free, in this order.
- Email volume. Past 100 emails per day or 3,000 per month, Resend tips off free. The next tier is $20 a month for 50,000 emails, which is the cliff most consumer SaaS replacements never reach.
- Database size. Past 0.5 GB on a Neon project, you land on the Launch plan at $19 a month with 10 GB included. Comments, file uploads stored as bytea, or audit logs without retention are how this cliff is actually hit.
- Compute hours. Past 100 CU-hours on a Neon project, you pay per CU-hour. Scale-to-zero after 5 minutes idle keeps a hobby app well below this. A constantly-pinged background job exhausts it within days.
None of these hit a small consumer SaaS replacement. All three hit if you turn the prototype into a real product with traffic. The maintenance cost story flips from "roughly $0 substrate" to "$30 to $60 a month substrate" somewhere around the moment the app gets meaningful daily-active users. That is not a vibe-coding-specific story; it is the same shape every cloud-hosted app has. The interesting thing is that the build tool is no longer the line item that scales.
The honest catch the dollar number does not capture
If the only cost is dollars, vibe coding wins this comparison cleanly at small scale. The other costs are where the cautious takes from the existing pages on this topic land their punches.
Generated apps have weak observability. When an email does not arrive, you find out by trying it; the agent loop does not page you. Schema migrations on real user data are not the part vibe coding handles well; you can describe a feature, you cannot wave at a corruption-safe migration. The apps mk0r generates are mobile-first HTML/CSS/JS, which is great for replacing a small consumer SaaS but is the wrong shape for a regulated workflow with bespoke compliance evidence. None of those are dollars per month, but all of them are real maintenance burdens that show up after the substitution.
The categories where the substitution actually works are the categories where those burdens are small. A habit tracker that never had a migration story does not need one now. A booking page for one solo coach is not a regulated workflow. The substrate cost being $0 lines up with the cases where the labor cost is also small, and that overlap is what the "replace your SaaS subscriptions" pitch is actually leaning on.
“The bill is real but it is not the bill the takes are quoting. Once you separate the build tool from the substrate, the substitution makes sense for the categories it actually fits.”
How this generalizes beyond mk0r
The two-layer framing is not mk0r-only. Every vibe-coding tool has a build-tool layer and a substrate layer; the question is how visible the seam is. v0 plus Vercel is a build tool plus a fixed substrate. Bolt or Lovable plus Supabase is the same shape. Replit Agent runs both layers inside Replit. Cursor and Claude Code outsource the substrate to whatever you wire up yourself.
The maintenance-cost question splits the same way for all of them. The free-tier ceilings are similar at small scale. The difference is whether the substrate accounts are yours after you cancel the build tool. mk0r's choice is to put them on your line of access (a GitHub repo on m13v that you have clone access to, a Neon project under your control, a Resend audience that survives) so that the substrate can outlive the build tool. The dollars look the same; the lock-in does not.
Want to price out a specific SaaS replacement?
Tell us the SaaS you are trying to drop and the rough scale. Fifteen minutes is usually enough to tell whether it lives inside the substrate free tiers or not.
Frequently asked questions
What does it actually cost per month to replace a small SaaS subscription with a vibe-coded app on mk0r?
Two layers, summed honestly. Layer one is the build tool: mk0r is $19 per month after the 21-day trial (src/app/checkout/page.tsx line 105). Layer two is the substrate, the four real backends each session provisions: Neon Postgres, Resend, GitHub, PostHog. At small CRUD scale (under 0.5 GB of Postgres data, under 3,000 emails per month, one private repo), every one of those lands inside its provider's free tier, so the substrate bill is $0. Net: $19/mo while you keep iterating on the app inside mk0r, and $0/mo if you stop iterating, clone the GitHub repo we created, and host the app yourself.
Why do the other articles on this question quote one number and you quote two?
Because the other articles conflate the two layers. They quote either the build-tool subscription ($20-$200/mo across Lovable, Replit, Cursor, etc.) or they quote a doomsday rebuild number that lumps in security audits, technical debt, and a professional rebuild. The honest split that nobody publishes is: build tool is one bill, substrate (database, email deliverability, repo hosting, analytics) is a separate bill, and the substrate is the one that survives the build tool. The substrate is what you pay forever; the build tool is what you pay while iterating. Naming them together hides which one is actually the maintenance cost.
Where can I see the four substrate accounts mk0r provisions, in code?
Open src/core/service-provisioning.ts. The provisionServices() function at line 277 fans out four real provider calls. Resend audience and per-app sending key (lines 105 and 126), Neon Postgres project on aws-us-east-2 with pg_version 17 (line 174), GitHub private repo named mk0r-<sessionSlug> on the m13v account (line 233), and a PostHog app id allocated synchronously (line 82). The Resend, Neon, and GitHub calls run in parallel via Promise.allSettled at line 297. The DATABASE_URL, RESEND_API_KEY, GITHUB_REPO_URL, and PostHog ids land in /app/.env at line 367 before your first prompt finishes streaming. None of these are mocks. All four are real SaaS that bill on usage.
What is the substrate free-tier ceiling, in numbers?
Verified 2026-04-30 on each provider's pricing page. Neon free plan: 0.5 GB of storage per project, 100 CU-hours per project per month, scale-to-zero after 5 minutes idle, up to 100 projects per account. Resend free plan: 3,000 emails per month, 100 emails per day, one verified sending domain. GitHub free plan: unlimited private repos, 2,000 GitHub Actions minutes per month for private repos. PostHog: the project mk0r uses is shared across sessions, so you do not pay for it at all on the substrate side. A small consumer SaaS replacement (a habit tracker for one user, a niche internal tool, a single-tenant booking page) sits well inside all four ceilings.
What stops being free, and at what scale?
Three honest tripwires. Email volume is the first to bite: a transactional email past 100 a day or 3,000 a month tips Resend off free, and the next tier is $20 a month for 50,000 emails. Database size is second: a chat or comments app that grows past 0.5 GB lands you on Neon's $19/mo Launch plan (10 GB included). Compute is third: an idle scale-to-zero database does not burn CU-hours, but a constantly-pinged background job will exhaust the 100 CU-hour project allowance and require a paid tier. None of these hit a small consumer SaaS replacement. They all hit if you turn the prototype into a real product with traffic.
Can I cancel mk0r and keep the app running?
Yes, that is the point of provisioning real accounts instead of vendor-locked snapshots. The GitHub repo we created (visible in /app/.env as GITHUB_REPO_URL) is on your line of access, the Neon project is yours, the Resend audience and key are yours. Clone the repo, npm install, npx vite, and you have the same app running locally. Your maintenance cost after cancelling mk0r is whatever the substrate costs you, which at small scale is $0. The portability is the difference between mk0r and a build tool that keeps your app inside its own runtime forever.
Why is mk0r itself $19 a month if the substrate is free?
Because the build tool is not the substrate. mk0r runs the agent loop: a Claude Sonnet that reads your prompt, plans changes, edits files in an E2B sandbox, runs Playwright in a real Chromium, validates the output, and iterates. Token spend on the model and compute spend on the E2B VMs are real costs that scale per active prompt. The $19/mo covers the iteration tool. The substrate it provisions is on free tiers because the substrate scales with your app's traffic, not your prompt count. Two different cost shapes, two different bills.
Does this story generalize beyond mk0r, or is the free-substrate trick mk0r-only?
It generalizes weakly. Most other vibe-coding tools wire in a substrate, but they pick one fixed vendor (v0 to Vercel, Bolt and Lovable to Supabase, Replit Agent to Replit's own database). The free-tier ceiling story is similar at small scale, but the lock-in is heavier because the substrate is shipped as part of the tool's product, not as a separate account you own. mk0r's choice to provision real accounts under your line of access (a GitHub repo on m13v with you having clone access, a Neon project, a Resend audience) is the part that lets the substrate bill survive the build-tool bill. If you only care about cost while iterating, all the tools look similar. If you care about cost after you stop iterating, account ownership changes the answer.
What is the catch on the vibe-coded side that this maintenance-cost framing hides?
Three honest catches. First, generated apps have weak observability, so debugging a slow query or a failed email is harder than reading a vendor's status page; that is a labor cost, not a dollar cost, but it is real. Second, schema migrations are the part that does not vibe well; a corruption-safe migration on a Postgres with real user data is a thing you cannot wave at. Third, the apps mk0r generates are mobile-first HTML/CSS/JS, which is fine for replacing a small consumer SaaS but not the right shape for a regulated workflow with bespoke compliance needs. The substrate is cheap; the categories where the substrate is cheap and the app is correct overlap less than the build-tool marketing suggests.