From Idea to Live Product in 5 Days: How We Actually Do It

Five days is not a lot of time to build a product. It's also more than enough — if you know what you're doing.

We've shipped over 50 MVPs at Greta Agency. Some in 3 days, some in 7, a handful in 2. The timeline varies by scope, but the process is consistent. Here's exactly how we do it.

Day 0: Scoping (The Most Important Part)

Most projects fail before a line of code is written. The problem is usually scope — features that sound simple but aren't, technical dependencies nobody planned for, or a vague idea that turns into an argument about requirements at 2am on day 4.

We don't start building until we have:

A clear problem statement. One sentence: "This product helps [person] do [thing] without [frustration]." If we can't write this sentence, we're not ready.

A feature list with a line through most of it. We ask: what is the minimum set of features that proves the product works? Everything else is v2. A budget tracker doesn't need AI insights on day one. A SaaS tool doesn't need team collaboration in the first week. Cut mercilessly.

A data model. What entities exist? How do they relate? Five minutes with a whiteboard here saves two days of database migrations later.

A stack decision. No bikeshedding. For 90% of web products: Next.js, Supabase, Tailwind, deployed on Vercel. Auth via NextAuth or Clerk. Payments via Stripe. This stack is boring, proven, and fast to build with — especially with AI assistance.

Day 1: Scaffold and Foundation

Day 1 is infrastructure. We don't write business logic until the plumbing works.

What we build on Day 1:

• —Project scaffolded with create-next-app and configured (TypeScript strict mode, ESLint, path aliases, Tailwind)
• —Database schema created and migrated (Supabase)
• —Auth working end-to-end — sign up, sign in, session handling, protected routes
• —Basic routing structure in place
• —CI/CD pipeline live — pushes deploy automatically to Vercel

By end of Day 1, you can log in to a blank app. Not exciting, but foundational.

How AI helps here

Cursor writes most of the boilerplate. Supabase schema migrations, TypeScript interfaces for the data model, the auth callbacks — all of this is code that follows predictable patterns. AI is excellent at patterns.

What we don't let AI do unsupervised: security-sensitive code. Auth logic is read line by line. API routes that handle user data are written with explicit attention to input validation and authorization checks.

Day 2–3: Core Features

This is where the product gets built. We work feature by feature, not layer by layer. Meaning: we don't build all the API routes, then all the UI. We pick the most important user flow and build it end-to-end — database, API, UI, tested — before moving to the next one.

A typical feature cycle (2–4 hours per feature):

1. —Write the API route — validate inputs, check authorization, hit the database, return the right shape
2. —Write the UI — Cursor drafts the component, we refine it, wire up data fetching (usually with SWR or React Query)
3. —Manual test the happy path — does it work?
4. —Manual test the sad paths — what happens with bad input? Unauthorized requests? Empty states?
5. —Code review — we read what AI wrote before it stays in the codebase

The single biggest mistake with AI-assisted development is treating generated code as reviewed code. It isn't. You read every line, or you don't ship it.

By end of Day 3, the core user journey should work. A user can sign up, do the main thing the product does, and see the result.

Day 4: Polish and Edge Cases

Day 4 is when you find out what you missed.

• —Error states — what does the user see when an API call fails?
• —Loading states — spinners, skeletons, optimistic updates
• —Empty states — new users who haven't done anything yet
• —Mobile layout — if it breaks on a 375px screen, it's broken
• —Form validation — client-side feedback, not just server errors
• —Edge cases in the data model — what if a record is deleted while someone's viewing it?

We also do a first pass at performance. Next.js Image for any images. Check the bundle size (Vercel's build output shows this). Make sure we're not fetching data we don't need.

Day 5: Audit and Deploy

This is the most important day and the one most vibe coding projects skip.

Our pre-launch audit checklist:

Security

• —Are all API routes checking authentication before touching data?
• —Are all inputs validated and sanitized server-side (not just client-side)?
• —Is there any user data accessible without authorization? (Test with a second account)
• —Are environment variables in .env and not committed to git?
• —Are we using parameterized queries? (Supabase handles this, but check custom SQL)

Performance

• —Lighthouse score on the main pages (target > 85)
• —Core Web Vitals in Vercel's dashboard
• —No N+1 queries on any page (check Supabase logs)
• —Images optimized and responsive

Reliability

• —What happens if Supabase is slow? Does the UI handle it gracefully?
• —Are we handling errors in API routes and returning appropriate status codes?
• —Is there a 404 page? A 500 page?

UX

• —Does the app work on mobile?
• —Does the app work on Safari? (always check Safari)
• —Are there broken links?
• —Does the auth flow work on a fresh incognito window?

Once the audit passes, we deploy to production, set up uptime monitoring (we use Better Uptime), and hand off.

What AI Actually Does in This Process

AI writes probably 60–70% of the code by line count. But "wrote" is doing a lot of work in that sentence. AI drafts. We review, refactor, and sometimes rewrite. The code that makes it to production has been read by a human engineer.

The biggest productivity gains from AI-assisted development aren't in writing features — they're in:

• —Eliminating lookup time. We don't Google "how to set up Supabase realtime subscriptions" anymore. We ask Cursor.
• —Writing boilerplate fast. CRUD operations, TypeScript types, form validation schemas — all generated in seconds.
• —Debugging with more context. Paste an error and the relevant code into Claude and the diagnosis is usually immediate.

What AI is bad at, consistently:

• —Security. It will write code that works but isn't safe. You have to know enough to catch it.
• —Architectural decisions. AI will happily write your entire app into a single 2000-line page component if you let it.
• —Understanding business logic. It doesn't know what your product is supposed to do. You have to.

The Part Nobody Talks About: Momentum Management

Five days is also a psychological challenge. Day 3 is when every project feels broken and unfinishable. This is normal. The half-built state of a product looks much worse than zero progress because you can see exactly what's missing.

The fix: ship something to a staging URL at the end of every day. Seeing it run in a real browser, even partially, breaks the mental model that nothing works.

Frequently Asked Questions

Is everything actually done in 5 days, or do you cut corners?

The core product is done. Auth, main features, deployment, mobile layout, and a security audit. What's not done: advanced analytics, team features, integrations beyond the core ones, admin dashboards. We're explicit about what's in and out of scope before we start.

What kinds of products can be built in 5 days?

Web apps with a clear, bounded scope: SaaS tools, internal tools, marketplaces (basic), consumer apps, landing pages with CMS, API-powered products. Native mobile apps, products with real-time features at scale, or anything requiring significant data processing are scoped separately.

What happens if something's wrong after launch?

Every project includes a 14-day post-launch support window. If a bug comes up in normal usage, we fix it. We also set up error monitoring (Sentry) as part of the deployment so we see errors before you do.

How much does a 5-day MVP cost?

Our standard range is $5K–$30K depending on scope. The scope call (free, 30 minutes) gives you an exact number. We don't start until both sides agree on exactly what's included.