Case Study: From Notion Doc to Day‑14 Live Demo (The Thin‑Slice MVP)

A first‑time founder brought a one‑page Notion doc for an internal tool idea for property managers (“PropOps”): reduce back‑and‑forth and get requests → assigned → resolved → invoiced without spreadsheets. They didn’t want an agency contract or a 10‑week plan - just a working MVP to test with 5–10 real users.

I built it in 14 days.

TL;DR

• Thin slice: Auth → submit request → assign → resolve → invoice (Stripe) → basic analytics.
• Stack: React/Next.js, Node/TypeScript, hosted Postgres, Stripe, simple event analytics.
• Outcome: Day‑14 demo used in 6 customer interviews; 2 pilots confirmed in 2 weeks; team killed their spreadsheet in week 1.

The Scope Card (Day 1)

• Problem (user & job): Property managers need to capture tenant issues, assign to contractors, and close with payment - without email threads & spreadsheets.
• Success metric (30 days): 10 active users across 2 buildings; ≥ 20 resolved tickets; 1 paid transaction (pilot pricing).
• Thin slice (deliverables):
  • Auth (email + session)
  • Core flow: Create request → Assign → Resolve → Close
  • Payments: Stripe (test → live)
  • Analytics: ticket funnel events (created → assigned → resolved → paid)
  • Deploy & Docs: client owns repo + infra
• Out of scope (moved to Sprint 2): roles/permissions beyond admin/standard; notifications matrix & templates; advanced reporting & exports; contractor marketplace search; custom theming.
• Change control: Any new idea → Backlog; Sprint 1 remains thin.

Architecture (keep it boring & proven)

[Next.js (App)]   - UI + SSR/ISR
      |
      | REST/JSON
      v
[Node/TS API]   - auth, validation, business logic
      |
      | Prisma (ORM)
      v
[Hosted Postgres]
      |
      +--> Stripe (payments)
      +--> Webhooks (events)
      +--> Simple analytics sink (events table)

Why these defaults

• Reversible decisions, fast DX, strong ecosystem.
• Hosted Postgres + migrations → production‑minded from Day 2.
• Stripe early → de‑risks the “last mile” (where MVPs die).

Data Model (thin & explicit)

orgs(id, name)
users(id, email, name, org_id, role)
tickets(id, org_id, title, desc, status, assignee_id, created_at, resolved_at)
comments(id, ticket_id, author_id, body, created_at)
payments(id, ticket_id, stripe_pi, amount_cents, status)
events(id, org_id, type, actor_id, ticket_id, created_at)  -- created/assigned/resolved/paid

Note: No “settings” table yet. That’s surface area we don’t need for a demo.

Day‑by‑Day Highlights

Day 1 - Decide

• One user, one job, one metric locked.
• Scope Card signed (1 page). Backlog created.

Days 2–3 - Foundation & Auth

• Repo, CI, lint, prod/staging envs, database & migrations.
• Email auth with sessions; minimal roles (admin/standard).
• Base UI with consistent tokens (typography, spacing) for speed.
• Acceptance: Can sign up/in; see a stub “Create Request” screen behind auth.

Days 3–7 - Core Flow (happy path only)

• Create request (title, description, photos)
• Assign (dropdown of users, simple status)
• Resolve (status change + optional comment)
• List (kanban or simple list with filters by status)
• Detail (timeline: created → assigned → resolved)
• Non‑goals: bulk import, CSV, triage automation, advanced filters → Backlog.
• Milestone (Day 7): End‑to‑end happy path recorded in a 90‑second Loom.

Days 8–10 - Payments & Analytics

• Payments: Stripe Checkout for “resolution fee” (pilot pricing).
• Events: ticket_created, ticket_assigned, ticket_resolved, payment_succeeded.
• Mini dashboard: counts per stage + simple conversion.
• Why: Money & measurement de‑risk the MVP. Even if they pivot, they learn where users drop.

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

• Validation, empty states, guard rails on status transitions.
• Index on tickets(status, org_id).
• Access control (org‑scoped everything).
• Lighthouse pass on core pages; focus states, labels, color contrast.

Day 13 - Docs, Deploy, Demo Rehearsal

• Docs: README (run, env, deploy), system sketch, API notes.
• Deploy: production URL live (client’s account).
• Demo script: 5‑minute path mirroring the user’s real day.

Day 14 - Demo & Handoff

• Live demo + recorded walkthrough.
• Handoff: repo, env vars via secure channel, dashboards.
• Sprint 2 candidates prioritized (see below).

What Shipped vs What Waited

Shipped (production)

• Email auth + session
• Create → Assign → Resolve → Close
• Stripe Checkout (test & live)
• Events & mini dashboard
• Docs, deploy, ownership

Deferred (Backlog for Sprint 2)

• Email/SMS notifications matrix
• Role granularity (contractor vs manager vs owner)
• Bulk upload, CSV export
• SLA timers & escalations
• Theming, whitelabel, audit log

Reason: The demo must make the user say “yes” to the next conversation. The list above doesn’t change that decision in week 1.

Obstacles & How I Cut Through

• Photo uploads were slow on residential Wi‑Fi.
  Fix: Compress on client, stream to storage, show optimistic previews.
• Assign flow felt clunky with a long dropdown.
  Fix: Start with search‑as‑you‑type for members; defer org‑wide directory to Sprint 2.
• Ambiguity about “resolution fee.”
  Fix: Pilot toggle: paid vs zero‑amount “close” (still creates a record). Learn from real usage.

The Outcome

• A working Day‑14 demo that mirrored the real work: capture → assign → resolve → invoice.
• Used in 6 customer interviews; 2 pilots confirmed.
• The founder’s team ditched their spreadsheet for tickets within the first week.

This is the point of a thin slice: create a believable, repeatable demo that starts real conversations.

Lessons for Founders (What Made This Work)

• Define the one job. “Resolve maintenance requests” beat “platform for property.”
• Ship the happy path. Edge cases became backlog with owners + notes.
• Add money early. Payments change behavior; they surface friction you won’t see in fake demos.
• Measure the funnel. If you can’t see created → assigned → resolved, you’re flying blind.
• Own your infra. From day 1, the accounts and repo are yours.

If This Sounds Like You

You’ve got a doc, a deck, or a voice note. You’re not hiring a department - you want a working product in 14 days to test, sell, or raise.

I’ll send you my free 3‑slide scope sketch (problem → thin slice → timeline) and a start date.

Comment “MVP” or book a 20‑min scope call: weekonelabs.com

Key Takeaways

• Thin slice = auth + core flow + payments/analytics.
• Decide once, then move. Backlog is your friend.
• Demo > deck. Real usage uncovers the truth faster than planning.