The 14‑Day MVP Sprint: Exactly What Happens Each Day (Scope → Build → Demo)

You don’t need a 60‑page plan to launch something real. You need one user, one job to be done, and a thin slice shipped fast.

This post shows you, line by line, what actually happens in my 14‑Day MVP Sprint at Week One Labs -what decisions get made, when code lands, how I prevent scope creep, and how we hit a Day‑14 demo with docs and deploy.

TL;DR

• Day 1: Decide. Pick one user, one job, one metric. Freeze scope.
• Days 2–13: Build the thin slice -auth → one core flow → payments/analytics → integrations (if required) -plus docs and deploy.
• Day 14: Live demo + hand‑off. You own repo and infra.

Why 14 Days Works

Speed is not chaos. It’s constraint:

• One owner (me). No layers, no handoffs.
• One sprint. If it doesn’t fit, it goes to Sprint 2.
• One thin slice. Auth + core flow + payments/analytics proves value.

AI and mature cloud tooling have collapsed the cost of iteration. The bottleneck is deciding what to build. We fix that on Day 1.

The Day‑by‑Day Plan

Day 1 - Scope & Decisions (the “choose” day)

• User: Pick one primary persona who benefits now.
• Job‑to‑be‑done: One sentence: “When [situation], the user [does] to get [outcome].”
• Metric: First 30 days success (e.g., 25 qualified sign‑ups, 10 completed checkouts, 3 pilot teams).

Deliverables list:

• Auth (email/OAuth, session, roles if needed)
• Core flow (happy path) (e.g., “Create listing → Checkout”)
• Payments & Analytics (Stripe + basic funnel events)
• Integrations (if required) (e.g., Notion/Slack/Shopify)
• Deploy & Docs (you own repo + infra)

Out of scope examples: settings, notifications, complex reporting, multi‑tenant admin, edge cases beyond happy path. These go to Backlog (Sprint 2).

• Change control: Any new idea → backlog. No stealth scope.
• Artifact: a one‑page Scope Card (Problem, Thin Slice, Acceptance Criteria, Backlog, Timeline, Price). You sign it; we lock it.

Days 2–3 - Foundation & Auth

• Repo + CI: Set up monorepo (if needed), linting, formatting, preview envs.
• Database: Hosted DB with schema for the core flow (migrations from Day 2).
• Auth: Email/OAuth, sessions, basic authorization guard.
• Base UI: Layout, typography, design tokens so screens come together quickly.

Acceptance:

• You can sign up/sign in, stay signed in, and sign out.
• A stub page for the core flow exists and is behind auth.

Days 3–7 - Core Flow (Happy Path First)

Implement the one path that creates value. Example for a marketplace:

• Create listing (title, price, media)
• List view & detail
• Add to cart / direct checkout
• Confirmation

Rules:

• Focus on “one way to win.” Edge cases go to backlog.
• CRUD, but intentional (not everything editable yet).

Day 7 milestone: working happy path end‑to‑end in staging. Short video sent.

Acceptance:

• You can complete the primary job without errors.
• Events captured (view, start, complete).
• One teammate can reproduce locally using README.

Days 8–10 - Payments & Integrations

• Stripe (or relevant gateway) for checkout/subscribe -test mode first.
• Analytics: basic funnel events; a lightweight dashboard or export to a sheet.
• Integrations (if required): e.g., Notion sync, Slack webhook, Shopify, third‑party API.

Acceptance:

• End‑to‑end payment succeeds in test mode; receipt/record created.
• Events visible in analytics; simple query shows drop‑offs.
• Integrations exercised with mock data.

Days 10–12 - Hardening & Edge Cases (only the critical ones)

• Guardrails: input validation, empty states, 404/401 routes.
• Performance quick wins: N+1 checks, eager loading, indexes on hot queries.
• Security basics: rate limit on auth routes, CSRF where relevant, secrets management.
• Accessibility pass on the core screens.

Acceptance:

• P95 latency on hot endpoints < X ms in staging.
• Lighthouse/AXE pass on core pages.
• Critical errors covered with try/catch and user‑friendly fallbacks.

Day 13 - Docs, Deploy, Demo Rehearsal

• Docs: README (run, env, deploy), System sketch, API notes, Ops runbook.
• Deploy: Production env, seeds if needed, feature flags for risky items.
• Demo script: 5‑minute path that mirrors the user’s journey.

Acceptance:

• “Fresh laptop test” passes using README.
• Production up at a stable URL (or behind password if stealth).
• You can run the demo yourself without me.

Day 14 - Demo & Handoff

• Live demo (recorded) + walkthrough of code, infra, and decisions made.
• Hand‑off: repos, env vars (via a secure channel), dashboards, monitoring.
• Next steps: list of 5–10 items for Sprint 2 (prioritized by ROI).

Guarantee: If I miss agreed scope due to me, I add a free week.

Day 1:  [ Scope & Decisions ]  ──────────────────────────────────────────────┐
Days 2-3: [ Repo / DB / Auth ] ─────────────┐                                 │
Days 3-7: [ Core Flow (Happy Path) ] ───────┼─── Day 7 Milestone (video)      │
Days 8-10: [ Payments + Integrations ] ─────┘                                 │
Days 10-12: [ Hardening & Edge Cases ] ───────────────────────────────────────┤
Day 13: [ Docs / Deploy / Demo Script ] ──────────────────────────────────────┤
Day 14: [ Demo & Handoff ] ───────────────────────────────────────────────────┘

Definition of Done (DoD)

• User can: sign up/in, complete the core job, pay (if relevant), and see confirmation.
• You have: live URL, repo access, infra ownership, simple analytics, and docs.
• We know: the single metric we care about for the next 30 days.

Scope Creep: How We Avoid It (Without Being Rigid)

• Parking lot: any idea not on the Scope Card goes to backlog, with an owner and a value guess.
• Timeboxes, not “maybe later.” If a decision takes >30 minutes, we pick a sane default and move.
• Thin slice first: if a feature can be halved, we ship the half that proves value.

Tooling Defaults (so we move fast)

• Frontend: React/Next.js + component library (accessibility‑friendly).
• Backend: Node/TypeScript or a lightweight Python service where better.
• DB: Hosted Postgres (or equivalent) + migrations.
• Auth: Provider/OAuth + sessions.
• Payments: Stripe.
• Analytics: product event capture + simple dashboard (can be a Sheet).
• Infra: managed hosting with CI/CD; you own accounts.

If your context prefers different tools (e.g., Shopify, Supabase, Firebase), I adapt -while keeping the thin slice intact.

What If You Need “More Than an MVP”?

Great -we schedule Sprint 2 immediately after launch:

• Expand roles/permissions
• Additional flows
• Reporting
• Notifications
• Design refinements
• Performance projects

But we don’t delay the Day‑14 learning loop.

Common Questions

Can we change scope after Day 1?
Yes, into the backlog. Sprint 1 stays thin so we hit the demo.

Will this be “throwaway code”?
No. The sprint is production‑grade by default: clean structure, env separation, migrations, docs, and CI.