From MVP to production:
a vibe coder's scaling playbook.

Your AI-built MVP works. People are signing up. Then the first 50 users show up at the same time and everything starts smoking. This is the gap between "it works" and "it works under load." Here are the seven layers you have to fix to cross it, in the order we fix them on every cleanup project — with realistic time and cost estimates for each.

The order matters more than the work itself

Most teams try to scale by adding a CDN and calling it done. That's like putting a faster engine in a car with bald tyres. The right order is from the inside out: data layer first, then app layer, then infrastructure, then observability. If you skip a layer, the one above it won't hold.

Layer 1 — Data model (1–3 days)

If your database schema is wrong, nothing above it can be made fast. Vibe-coded apps almost always have:

• JSON columns hiding what should be tables
• Missing foreign keys
• No indexes on columns you query often
• Single tables with 30+ columns

What to do: draw your actual data model on paper. Identify entities and their relationships. Normalise the worst JSON columns into proper tables. Add foreign keys with cascading deletes. Add indexes on every WHERE and JOIN column. Typical cost when we do this: ₹6,000–₹15,000.

Layer 2 — Query patterns (1–2 days)

With the schema fixed, audit the queries hitting it. The killers are almost always:

• N+1 patterns — fetching a list, then querying once per item. Replace with a single JOIN or batched IN query.
• Unbounded lists — SELECT * FROM x with no LIMIT. Add pagination.
• Subscribed websockets on every render — common in Supabase Realtime usage. Move subscription to a top-level component, share via context.

Tool: EXPLAIN ANALYZE on every query that runs more than 10x/minute. Typical cost: ₹4,000–₹10,000.

Layer 3 — Code structure (3–5 days)

Now the code itself. The work is mostly mechanical:

• Break files over 300 lines into smaller modules
• Extract business logic out of React components into pure functions
• Move data-fetching into hooks/services, not inline in components
• Pick one state-management pattern (Zustand, Jotai, plain context — anything, but pick one)
• Type-safe everything. Replace any with real types.

This is the part that takes a real engineer the longest and that AI tools genuinely cannot do well, because it requires holding the whole codebase in your head at once. Typical cost: ₹15,000–₹40,000.

Layer 4 — Auth & authorisation (1–2 days)

If you're using Supabase, enable Row Level Security on every table. Write explicit policies for who can read/write each row. If you're using your own auth, add middleware that checks roles before every protected route. Typical cost: ₹3,000–₹8,000.

Layer 5 — Caching & performance (1–3 days)

With the foundations fixed, add caching where it makes sense:

• Add HTTP cache headers to static API responses
• Add React Query / SWR for client-side data caching
• Add a CDN in front of static assets (Vercel/Cloudflare do this automatically; check it's actually on)
• Defer non-critical JS with <script async> or dynamic imports

Typical cost: ₹4,000–₹10,000.

Layer 6 — Deployment & CI/CD (1 day)

Stop deploying from your laptop. Set up GitHub Actions (or Vercel's automatic deploys) to run on push to main. Add a preview deployment on every PR. Add a basic test that hits your API health endpoint. Add a rollback button. Typical cost: ₹2,000–₹6,000.

Layer 7 — Observability (0.5 day)

You can't fix what you can't see. Add:

• Error tracking (Sentry — free tier is generous)
• Uptime monitoring (Better Stack / Pingdom)
• Web Vitals (Vercel Analytics or Google's web-vitals npm)
• A simple /health endpoint your monitoring can ping

This layer is non-negotiable for anything in production. You'll wonder how you lived without it. Typical cost: ₹1,500–₹4,000.

The total bill, honestly

End-to-end, taking a vibe-coded MVP to genuinely production-grade takes 10–15 working days and costs ₹40,000–₹100,000 depending on the size of the app. That's roughly the cost of a single month of one full-time mid-level engineer, which is probably less than you'd pay an agency for two weeks of greenfield work. The leverage is high because you're not building anything new — you're hardening what's already there.

The 80/20 if you only have a weekend

If you only have 48 hours, do this:

1. Add indexes to the 5 slowest queries
2. Add LIMIT to every list query
3. Enable RLS on every Supabase table
4. Add Sentry
5. Add automatic deploys on push to main

That covers 80% of the risk for 20% of the work. Everything else can wait until you have actual user pain to point at.

When to do this yourself vs hire

Layers 1, 2 and 3 (data, queries, structure) require someone who can hold the entire codebase in their head. If you can do this yourself, great. If not — this is exactly the work we do as a Refactor Sprint (₹14,999) or Production package (₹49,999+). Layers 4–7 are mechanical and well-documented; vibe-code your way through them with Cursor or v0 and you'll be fine.

---

Keep reading