AI MVP en 7 Jours — Stack pour Indie Builders

What's in this pack (the 7-day shipping toolchain)

This is the toolchain for a solo builder who has seven calendar days to turn an idea into a product that can take money. Not a hackathon prototype, not a Friday-night side project — an actual MVP with auth, payments, analytics, error tracking, and a live URL by Sunday night.

If fullstack-indie-hacker is the 2-week version (more careful scaffolding, Drizzle vs Supabase debate, Kamal escape hatch) and ai-side-hustle-kit is the marketing pipeline (agents finding customers for an already-shipped product), this pack lives between them: the compressed week where you stop thinking and start shipping, with AI tools doing the heavy lifting so one human can hold the whole stack in their head.

The ten picks split into five layers, each owning specific days:

• Ideation & editor (Day 1) — Cursor as the AI-native editor that holds the codebase, v0 to sketch UI before any framework choice is made.
• Scaffold (Day 1-2) — Bolt.new to generate the working app skeleton in the browser, Supabase to bring DB + auth + storage with one URL.
• Core feature (Day 3-4) — the days when no tool can save you. You build the one thing your product does.
• Payments (Day 5) — Stripe MCP so Cursor / Claude Code can wire checkout, subs, and webhooks without context-switching to the Stripe dashboard.
• Analytics & monitoring (Day 6) — PostHog for product analytics + session replay, Sentry for error tracking. Resend wires transactional email the same day.
• Launch (Day 7) — OpenRouter as the model-agnostic LLM gateway so you're not locked to one provider on launch day, Vercel CLI for the actual deploy.

Every tool here is production-ready, AI-agent-readable (Cursor / Claude Code / Codex can drive most of them), and free-tier-friendly through your first 100 users. The whole stack costs $0 in fixed monthly fees for an MVP — pay-as-you-grow on Stripe (2.9% + 30¢), Resend (3k emails/mo free), and OpenRouter (token pass-through).

Install in this order (Day 1 → Day 7 timeline)

Day 1 — Idea to scaffold

1. Cursor — the AI-native editor. Install first because every later tool gets wired through it. Cursor Tab gives you multi-line edit prediction, Composer drives multi-file changes from a prompt. Open the empty folder and start.
2. v0 by Vercel — UI generation in the browser. Before you scaffold the app, generate 3-5 page designs in v0 so you know what you're building. 30 minutes of v0 sketches saves 4 hours of Day 4 "what should this page look like."
3. Bolt.new — full-stack app generator in the browser. Type the product description, Bolt scaffolds a working Next.js app with auth, DB calls, and the routes you described. Export to a git repo, open in Cursor, keep building.

Day 2 — Backend foundation

4. Supabase — the open-source Firebase. Postgres + auth + storage + realtime, one URL. Use it for everything: users, your domain data, file uploads, even feature flags. The fast lane that lets you skip the "which auth library" question entirely. Free tier carries the MVP.

Day 3-4 — Core feature

No new installs. This is the irreducible work: the one thing your product does that nothing else does. Cursor + Supabase from above is enough. The tools shut up so you can think.

Day 5 — Payments

5. Stripe MCP — payments as an MCP tool. Lets Cursor / Claude Code wire checkout, subscriptions, webhooks, and the customer portal directly from your editor. The MCP wrap is the difference between "Stripe in an afternoon" and "Stripe in a weekend" — for a 7-day sprint, that afternoon is everything.
6. Resend — transactional email API. React Email templates, dead-simple SDK. Wire signup confirms, receipts, and password resets the same day you wire Stripe. They're a pair.

Day 6 — Observability

7. PostHog — product analytics + session replay + feature flags + LLM observability. One SDK, four jobs. The session replay alone is worth it on Day 6: you'll watch the first three users hit your signup flow and find two bugs before launch.
8. Sentry — error tracking. Install in 5 minutes, catches the production error that will absolutely happen 4 hours after launch. Free tier covers any MVP for months.

Day 7 — Launch

9. OpenRouter — unified API for 300+ LLMs. If your product uses an LLM (most do in 2026), don't hardcode to one provider on launch day. OpenRouter lets you switch GPT/Claude/Gemini/Llama with one env var when the chosen model has a bad week.
10. Vercel CLI — vercel --prod from the repo. Preview URL on every git push, production URL when you ship. Free tier covers any pre-revenue MVP. Default destination for everything from Day 1.

How they fit together

  Day 1            Day 2            Day 3-4          Day 5            Day 6            Day 7
  ─────            ─────            ───────          ─────            ─────            ─────
  Cursor      →    Supabase    →    YOU         →    Stripe MCP  →    PostHog    →    Vercel CLI
  v0          →    (DB+auth)        BUILD THE        Resend           Sentry          OpenRouter
  Bolt.new                          ONE FEATURE      (signup +        (errors +        (LLM gateway)
  (scaffold)                        (no new tools    receipts)        replay +              │
      │                              save you here)       │           flags)               │
      │                                  │                │              │                 ▼
      └──────────────────────────────────┴────────────────┴──────────────┴───────► Live URL

The shape is deliberate: the AI tools cluster at Day 1 (when scaffolding is generic enough to be generated) and Day 7 (when integrations are commoditized enough to be wired by an agent). The middle is irreducibly human — Day 3-4 is where your product becomes itself. Don't add tools there; add hours.

The money / data / observability triangle on Day 5-6 is the cheapest insurance you can buy: Stripe MCP + PostHog + Sentry together take ~3 hours and catch ~80% of the post-launch fires that would otherwise eat your Week 2.

Tradeoffs you'll hit

• Depth vs speed — every tool here is picked for speed of shipping over depth of customization. Supabase over rolling your own Postgres + Auth.js. Vercel over Kamal. Stripe MCP over hand-writing webhooks. The cost is real: you're locking into vendors and patterns that will need replacement at some scale. The benefit is real: you ship in 7 days instead of 7 weeks, and at week-1 scale, vendor lock-in is a good problem to have.
• Vendor lock-in — Supabase, Vercel, Stripe, Resend, PostHog Cloud, Sentry, OpenRouter — that's seven SaaS dependencies. Two are open-source (Supabase, PostHog, Sentry — all self-hostable when you outgrow the hosted plan), the rest are pure SaaS. If your business or jurisdiction requires self-hosting, swap Supabase→Postgres+Auth.js, Vercel→Kamal, Resend→Postal, PostHog→self-host. Adds 2-3 days; out of scope for the 7-day timeline.
• Is 7 days actually sustainable? — for one MVP, yes, and people have done it on stream repeatedly. For every project, no — you'll burn out by month two. The 7-day frame is a forcing function for one specific idea you've been overthinking: pick the one, run the sprint, ship it. Do not try to repeat this weekly indefinitely.
• Cursor vs Claude Code vs Codex — pack picks Cursor as the primary because Cursor Tab + Composer feels closest to "pair-programming with an AI" inside one editor surface, which matters when you're running on caffeine. Claude Code is strictly more powerful for multi-file refactors (and the Stripe MCP / Supabase MCP / Sentry MCP servers all work with it). Codex is the right call if you live in the terminal. Pick one, don't switch mid-week.
• v0 + Bolt.new — isn't this redundant? — v0 designs (UI components and pages, you copy code out), Bolt.new scaffolds (a working app with routes, DB calls, auth). v0 saves you UI thinking on Day 1; Bolt.new saves you scaffolding work the same day. They're complementary on Day 1, useless after Day 2 — by then you're in Cursor.

Common pitfalls (the 7-day-killer mistakes)

• Feature creep — "let me just add an admin dashboard" is how 7-day MVPs become 21-day MVPs. The MVP does one thing. The dashboard, the team feature, the API for partners — all post-launch. Write them on a Day 8 list and close the browser tab.
• No payment, no data — shipping without Stripe wired means you don't know if anyone will pay. Shipping without PostHog means you don't know if anyone is using it. Both are mandatory for the 7-day frame; if they're not in by Saturday night, push launch to Day 8 rather than cut them.
• Not dogfooding before launch — Day 6 evening: go through your own signup → payment → use → email receipt loop as a real user, on a different browser, on mobile. You will find three bugs. They're cheaper to fix Saturday than Sunday morning.
• Forgetting auth until Day 5 — if you're building anything beyond a public landing page, auth goes in Day 2 with Supabase, not Day 5 "when I add payments." Stripe Checkout will redirect back to your app expecting a logged-in user; if auth isn't ready, you eat half a Friday on a hack.
• Adding monitoring "after launch" — Sentry takes 5 minutes on Day 6, or 4 hours of "why is this 500-ing for some users" on Day 8. PostHog takes 10 minutes on Day 6, or a week of "are people actually using the core feature" guesswork. Both go in before the launch URL goes public.