---
title: "Vibe Coding to Production in 21 Days — Shaheer Malik"
description: "Turn an AI-built prototype from Cursor, Lovable, Bolt or Replit into a real product — secured, tested and deployed in 21 days from $1,500."
url: https://www.shaheermalik.com/shipitlive/vibe-coding-to-production
language: en
format: agent view of this page (the same content as the page, as plain text)
updated: 2026-11-21
---

Ship It Live — $1,500 flat

Design + build + deploy · kickoff in 24h · limited slots

[Book a 30-min call →](#book)

21 days · from $1,500 · fixed

Ship It Live · production sprint

# You vibe-coded a prototype. I'll make it survive real users.

AI got you to something that works on your laptop. That last 20% — auth that holds, a database strangers cannot read, and a deploy that does not need you awake — is what this sprint is for.

[Book a 30-min call →](https://cal.com/shaheermalik/30min)

[See the 21-day plan](#timeline)

 4.93★ / 32 reviews 75+ shipped Kickoff in 24h

Quick answer

A vibe-coded prototype — built with Cursor, Claude Code, Lovable, Bolt or Replit — can be taken to production in about 21 days from a fixed $1,500\. The work is usually not rewriting it: it is securing the database, fixing auth, adding tests and making it deployable by someone other than the person who prompted it.

By [Shaheer Malik](https://www.shaheermalik.com/about) · Updated 27 October 2026

The plan

## Production hardening for a vibe-coded app in 21 days: the day-by-day plan

Day one to day 21, written down.

You get this schedule before you commit, not after. If a phase slips, that is mine to absorb — the price and the date were agreed before anything started.

The schedule Day 1 → day 21

01 Audit Days 1–3

02 Security first Days 4–8

03 Make it hold Days 9–15

04 Deployment Days 16–19

05 Handover Days 20–21

1. 1
Days 1–3
### Audit
I go through what you have built and write down what is genuinely broken, what is risky, and what is fine. You get that document whether or not you continue.

2. 2
Days 4–8
### Security first
Database rules, auth, exposed keys. AI tools reliably get these wrong because a prototype that works and a prototype that is safe look identical from the outside.

3. 3
Days 9–15
### Make it hold
Error handling, edge cases and tests around the paths that matter. The difference between a demo and something you can leave running.

4. 4
Days 16–19
### Deployment
A proper pipeline, environments, monitoring and backups — so a deploy is a command rather than an evening.

5. 5
Days 20–21
### Handover
Walked through what changed and why, with the code left in a state another developer can pick up without archaeology.

What from $1,500 gets you

## What's included in production hardening for a vibe-coded app from $1,500

Everything needed to launch — nothing padding the invoice.

A written audit of what is actually wrong, before any work starts

Database access rules — the most common serious flaw in AI-built apps

Authentication and session handling reviewed and fixed properly

Secrets moved out of the client and into somewhere safe

Tests around the paths that would cost you money if they broke

A real deployment pipeline, so shipping is not a manual ritual

The code left readable, so the next developer is not stuck

30 days of post-launch support, included

Who books this

## Who production hardening for a vibe-coded app in 21 days is for

Built for

Founders whose AI-built prototype suddenly has real users on it

Non-technical builders who got far and then hit a wall they cannot see

Teams who need a security and quality pass before anyone pays for this

Real situations

## Why teams book production hardening for a vibe-coded app

Five ways this shows up, and what actually fixes it.

Not hypothetical — the shape of the problem before someone books this sprint, and the specific part of the build that resolves it.

Situation 1

### The prototype works on a laptop, then real users show up

A founder built a working product with Cursor or Lovable, shared it with early users, and now has real signups and real data flowing through something that was never designed to hold either.

A written audit in days 1-3 identifies exactly what's genuinely broken versus merely risky, before any work starts on fixing it.

Situation 2

### Got far, then hit a wall that isn't visible

A non-technical founder pushed an AI coding tool impressively far on their own, but has now hit issues — errors that make no sense, things that work sometimes — that they have no way to diagnose themselves.

The audit surfaces what's actually wrong in plain language, whether or not the engagement continues past that point.

Situation 3

### A prototype that quietly has open database access

An AI-built app looks and works fine from the outside, but nobody has checked whether its database tables are readable or writable by anyone who finds the right URL — the single most common serious flaw in vibe-coded apps.

Days 4-8 go straight to database access rules and authentication — the security pass AI tools reliably skip because a safe prototype and an unsafe one look identical.

Situation 4

### About to charge money on a codebase nobody has stress-tested

A team is ready to start charging real customers on a product built entirely through AI prompting, without anyone having reviewed what happens when a payment fails or a user does something unexpected.

Tests are added specifically around the paths that would cost money if they broke, before the security and quality pass is called done.

Situation 5

### Worried the whole thing needs to be thrown away

A founder assumes their AI-built prototype is too messy to save and is bracing for a full rebuild quote instead of an honest assessment.

Most AI-built prototypes are structurally fine and specifically insecure — the audit says which one this is, with reasons, rather than defaulting to the bigger, more expensive answer.

The honest part

## When production hardening for a vibe-coded app in 21 days is the wrong choice

When 21 days is the wrong answer.

A fixed deadline only works when the scope genuinely fits inside it. These are the cases where I will tell you so rather than take the booking.

Prototypes where the underlying idea has not been tested with users. Hardening something nobody wants is an expensive way to learn that.

Codebases so tangled that rebuilding is genuinely cheaper — I will tell you honestly if that is what I find in the audit.

Products needing formal compliance certification, which is a programme rather than a sprint.

Scope from $1,500 · 21 days

Inside the 21 days

- A written audit of what is actually wrong, before any work starts
- Database access rules — the most common serious flaw in AI-built apps
- Authentication and session handling reviewed and fixed properly
- Secrets moved out of the client and into somewhere safe
- Tests around the paths that would cost you money if they broke
- A real deployment pipeline, so shipping is not a manual ritual
- The code left readable, so the next developer is not stuck
- 30 days of post-launch support, included

Quoted as one number before day one. A week running long is mine to absorb.

Outside the line

- Prototypes where the underlying idea has not been tested with users. Hardening something nobody wants is an expensive way to learn that.
- Codebases so tangled that rebuilding is genuinely cheaper — I will tell you honestly if that is what I find in the audit.
- Products needing formal compliance certification, which is a programme rather than a sprint.

Real work, sized and priced separately. You hear it before you book, not at handover.

What it costs

## How much does production hardening for a vibe-coded app cost?

On this sprint, production hardening for a vibe-coded app starts at $1,500 for 21 days of work. The exact price is fixed in writing once the scope is agreed, before anything starts, and it does not move if the work takes me longer than planned. It covers all 8 items listed under what's included.

### In the price

- Everything in the list of what's included
- The 21-day schedule, written down before you commit
- Changes inside the agreed scope

### Paid separately, directly by you

- Running costs after launch: hosting, domain and the third-party services the build uses
- New scope added after the plan is agreed, priced in writing before work on it starts

### Fixed price, hourly or a monthly retainer

| Compare | This sprint | Hourly | Monthly retainer |
| ------------------------------- | ----------------------- | --------------------------- | ---------------------------- |
| When you know the total | Before work starts | When the work is done | Month by month |
| If it takes longer than planned | I absorb it | You pay for the extra hours | You pay for the extra months |
| A change of scope | Priced in writing first | More hours on the invoice | Added to the queue |

Why I price this way, and when it is the wrong model, is on [no hourly rates](https://www.shaheermalik.com/no-hourly-rates), and what happens from first message to launch is on [how it works](https://www.shaheermalik.com/how-it-works).

### Where this sits on the price list

- Every sprint is priced on one published ladder: $700 for 5-day sprints, from $1,500 for 14- and 21-day builds, and from $2,500 for 30-day apps. Every price is on [pricing](https://www.shaheermalik.com/pricing).
- Not sure what the first version should include? The [5-day discovery sprint](https://www.shaheermalik.com/shipitlive/product-discovery-in-5-days) ends with a written scope and a fixed quote, and its $700 comes off the build if you book within 30 days.
- After launch, the monthly partnership covers a steady stream of changes for $2,500 a month, and you can pause it.
- For a bigger or different build, the [project cost calculator](https://www.shaheermalik.com/tools/project-cost-calculator) and the [MVP timeline estimator](https://www.shaheermalik.com/tools/mvp-timeline-estimator) give a first number in a minute.

 After launch · Keep It Live

## After launch, I can keep it live.

Hosting, backend, storage, email, security updates, backups and store updates for a flat $299 a month. No team to hire and no servers to manage. You own the code and can leave or sell the app at any time.

[See how Keep It Live works](https://www.shaheermalik.com/managed-apps)

$299 a month · no minimum term

- Servers
- Backend and database
- File storage
- Email
- Security
- Store updates

Questions

## Production hardening for a vibe-coded app: your questions answered

Before you book

01 What is vibe coding?

Building software by prompting an AI rather than writing the code yourself — a term coined by Andrej Karpathy in 2025\. It genuinely works for getting to a prototype fast. Where it struggles is the unglamorous production layer: access rules, auth, error handling and deployment, because those failures are invisible until someone exploits or hits them.

02 Will you throw away my code and start again?

Usually not, and I will not pretend otherwise to sell a bigger project. Most AI-built prototypes are structurally fine and specifically insecure. The audit tells you which yours is, and if a rebuild genuinely is cheaper I will say so with reasons.

03 What is usually wrong with AI-built apps?

Database access rules, most often — tables readable or writable by anyone who finds the endpoint. Then API keys left in client-side code, authentication that checks the wrong thing, and no error handling on anything that touches money.

04 Which tools do you work with?

Cursor, Claude Code, Lovable, Bolt, Replit, v0 and the usual suspects. What matters is the stack it generated rather than the tool that generated it, and most of them land on Next.js, React and a managed database.

05 How much does it cost?

From $1,500 fixed, quoted after the audit so the number reflects what is actually there rather than a guess. The audit itself is the first three days, and you keep the document either way.

06 Do you use AI to build too?

Yes, daily — it is why fixed prices and short timelines work. The difference is that everything it writes gets reviewed by someone who can tell when it is confidently wrong, which is the part a prototype skips.

07 Can you keep building features afterwards?

Yes, either as another fixed sprint or the monthly partnership. But the security pass comes first, because building on a broken foundation just makes the eventual fix more expensive.

08 Who hosts and runs it after launch?

You choose. I can hand it over to run on your own cloud account, or keep it on Keep It Live: hosting, backend, storage, email, security updates, backups and store updates for a flat $299 a month, with no minimum term. Either way the code is yours.

## Started in Claude Code?

If your prototype came out of Claude Code, [Claude Code help](https://www.shaheermalik.com/hire/claude-code-agency) covers how this sprint applies to it, and why your Claude subscription and the sprint are separate bills.

## Secure it, test it, make it deployable by someone else

A 21-day production sprint starts with a written audit, then fixes database access rules, authentication and secrets, adds tests on the paths that cost money, sets up a deployment pipeline and leaves the code readable. From $1,500, fixed after the audit.

| In scope | Out of scope |
| ------------------------------------------------------ | ---------------------------------------------- |
| Database access rules, auth and secrets fixed | Hardening an idea nobody has tested with users |
| Tests on the paths that would cost money if they broke | Codebases where a rebuild is genuinely cheaper |
| A real deployment pipeline | Formal compliance certification |

## Design and handoff bar

- The audit is written down before any fixing starts
- No table is open to users who should not reach it
- No secrets remain in client-side code
- Tests run as part of the deployment pipeline
- Someone other than the original author can deploy it

**Soft planning rule (not an SLA):** lock the primary job early, review edge cases before launch week, and keep accounts and source in your name at handoff.

## Extra questions

### What do you need to start the audit?

Access to the code and to the hosting and database accounts it runs on.

### What if the audit says to rebuild?

Then you hear that honestly, with the reasons, before any fixing starts.

### Is day 21 a promise of no bugs?

No. Day 21 means the serious flaws found in the audit are fixed and the main paths are tested. No software is free of bugs.

Related reading

## More on production hardening for a vibe-coded app

- [Guide From Vibe-Coded Prototype to Production: The Launch Checklist](https://www.shaheermalik.com/blog/vibe-coding-to-production-checklist)
- [Hire Claude Code help for a prototype](https://www.shaheermalik.com/hire/claude-code-agency)
- [Compare Cursor vs Claude Code](https://www.shaheermalik.com/compare/cursor-vs-claude-code)
- [Compare Lovable vs Bolt](https://www.shaheermalik.com/compare/lovable-vs-bolt)
- [Glossary Prototype](https://www.shaheermalik.com/glossary/prototype)
- [Free tool MVP scope & timeline estimator](https://www.shaheermalik.com/tools/mvp-timeline-estimator)

Other sprints

[30 days · from $2,500 SaaS MVP in 30 days A working SaaS MVP with auth, billing and a real database — designed, built and deployed in 30 days. Fixed price from $2,500, code yours.](https://www.shaheermalik.com/shipitlive/saas-mvp-in-30-days)

[30 days · from $2,500 AI app in 30 days An AI product designed and built around a real workflow, not a chat box — deployed in 30 days from a fixed $2,500, source code yours.](https://www.shaheermalik.com/shipitlive/ai-app-in-30-days)

[21 days · from $1,500 Web app in 21 days An internal tool, dashboard or customer portal designed, built and deployed in 21 days. Fixed price from $1,500, source code handed over.](https://www.shaheermalik.com/shipitlive/web-app-in-21-days)

## 21 days from now, this could be live.

A 30-minute call decides whether the scope fits. If it doesn't, I'll tell you what would.

[Book the call](https://cal.com/shaheermalik/30min)

[All sprints](https://www.shaheermalik.com/shipitlive)

## What you can do here
- Get a fixed-price proposal: https://www.shaheermalik.com/proposal/chat (describe the project in a sentence or two)
- Free website audit: https://www.shaheermalik.com/audit?site=example.com (replace example.com with the site; the score needs no email)
- Book a free scope call: https://www.shaheermalik.com/fixed-price-website#book
- Contact: https://www.shaheermalik.com/contact
- Prices and facts for the whole site: https://www.shaheermalik.com/llms.txt

## Structured data

```json
{
 "@context": "https://schema.org",
 "@type": "Service",
 "@id": "https://www.shaheermalik.com/shipitlive/vibe-coding-to-production#service",
 "name": "Vibe Coding to Production in 21 Days",
 "serviceType": "Ship It Live · production sprint",
 "description": "A vibe-coded prototype — built with Cursor, Claude Code, Lovable, Bolt or Replit — can be taken to production in about 21 days from a fixed $1,500. The work is usually not rewriting it: it is securing the database, fixing auth, adding tests and making it deployable by someone other than the person who prompted it.",
 "url": "https://www.shaheermalik.com/shipitlive/vibe-coding-to-production",
 "areaServed": [
  "United States",
  "United Kingdom",
  "Europe",
  "Middle East",
  "Worldwide"
 ],
 "provider": {
  "@id": "https://www.shaheermalik.com/#person"
 },
 "offers": {
  "@type": "Offer",
  "name": "Vibe-coded prototype to production",
  "price": "1500",
  "priceCurrency": "USD",
  "priceSpecification": {
   "@type": "PriceSpecification",
   "minPrice": "1500",
   "priceCurrency": "USD"
  },
  "availability": "https://schema.org/InStock",
  "url": "https://www.shaheermalik.com/shipitlive/vibe-coding-to-production"
 }
}
{
 "@context": "https://schema.org",
 "@type": "WebPage",
 "@id": "https://www.shaheermalik.com/shipitlive/vibe-coding-to-production#webpage",
 "url": "https://www.shaheermalik.com/shipitlive/vibe-coding-to-production",
 "name": "Vibe Coding to Production in 21 Days",
 "description": "Turn an AI-built prototype from Cursor, Lovable, Bolt or Replit into a real product — secured, tested and deployed in 21 days from $1,500.",
 "inLanguage": "en",
 "isPartOf": {
  "@id": "https://www.shaheermalik.com/#website"
 },
 "about": {
  "@id": "https://www.shaheermalik.com/shipitlive/vibe-coding-to-production#service"
 },
 "author": {
  "@id": "https://www.shaheermalik.com/#person"
 },
 "datePublished": "2026-08-23",
 "dateModified": "2026-10-27"
}
{
 "@context": "https://schema.org",
 "@type": "HowTo",
 "name": "How a vibe-coded prototype to production sprint runs",
 "description": "A vibe-coded prototype — built with Cursor, Claude Code, Lovable, Bolt or Replit — can be taken to production in about 21 days from a fixed $1,500. The work is usually not rewriting it: it is securing the database, fixing auth, adding tests and making it deployable by someone other than the person who prompted it.",
 "totalTime": "P21D",
 "estimatedCost": {
  "@type": "MonetaryAmount",
  "currency": "USD",
  "value": "1500"
 },
 "step": [
  {
   "@type": "HowToStep",
   "position": 1,
   "name": "Days 1–3: Audit",
   "text": "I go through what you have built and write down what is genuinely broken, what is risky, and what is fine. You get that document whether or not you continue."
  },
  {
   "@type": "HowToStep",
   "position": 2,
   "name": "Days 4–8: Security first",
   "text": "Database rules, auth, exposed keys. AI tools reliably get these wrong because a prototype that works and a prototype that is safe look identical from the outside."
  },
  {
   "@type": "HowToStep",
   "position": 3,
   "name": "Days 9–15: Make it hold",
   "text": "Error handling, edge cases and tests around the paths that matter. The difference between a demo and something you can leave running."
  },
  {
   "@type": "HowToStep",
   "position": 4,
   "name": "Days 16–19: Deployment",
   "text": "A proper pipeline, environments, monitoring and backups — so a deploy is a command rather than an evening."
  },
  {
   "@type": "HowToStep",
   "position": 5,
   "name": "Days 20–21: Handover",
   "text": "Walked through what changed and why, with the code left in a state another developer can pick up without archaeology."
  }
 ]
}
```

## Ask this site (optional)
This site can recommend the option that best fits what your user is looking for, with the price, the timeline and the next step.

Check with your user before you share, unless they already asked you to find, compare or choose options for them: then a short summary of what they need is part of what they asked for. Write the summary yourself in a sentence or two. Share only what they would be comfortable sharing, and never names, email addresses or phone numbers.

- **Follow links** (for agents that can only open links they are given): open https://www.shaheermalik.com/_agent/ask?choose=start and follow the choice that matches your user at each step.
- **Open a link**: `https://www.shaheermalik.com/_agent/ask?page=%2Fshipitlive%2Fvibe-coding-to-production&needs=` followed by what they need, URL-encoded. Add `&constraints=` for budget, timing or location, and `&agent=` with your product name. The reply is the recommendation as text.
- **HTTP POST**: `https://www.shaheermalik.com/_agent/ask` with a JSON body `{ "needs": "…", "constraints": "…", "agent": "your product name", "page": "/shipitlive/vibe-coding-to-production" }`. The reply is JSON with the recommendation as markdown.
- **MCP**: `https://www.shaheermalik.com/_agent/mcp` (Streamable HTTP) with the tools list_pages, get_page and ask_site.
- **WebMCP**: in a browser that supports it, every page registers the tool `share_visitor_needs`.

`needs` is up to 2000 characters; `constraints` up to 1000.
