You have ideas. You've had them for months. They sit in a notes app, slowly fermenting into guilt. Every Monday you think "next weekend" and every Sunday night you've somehow reorganized your desk instead of shipping anything.
The problem isn't talent or tools. It's process. Most weekend projects die because builders spend Saturday making decisions they should have made Friday, and Sunday polishing things nobody asked for. 🔍
Six months ago, this guide wouldn't have been practical. Claude Code couldn't reliably scaffold a full-stack app from a single spec file. Supabase's free tier didn't include edge functions. Vercel's hobby plan had tighter deployment limits. But by late March 2026, every tool in this playbook runs on a free tier generous enough to ship a real product — not a toy demo. The cost of a weekend MVP dropped from "a few hundred dollars in hosting and APIs" to "literally zero dollars if you're careful." That's the window. 💰
Here's the playbook I've reverse-engineered from watching hundreds of weekend launches over the past year — the ones that actually produced a live URL with real users by Sunday night. Not a prototype. Not a Figma mockup. A deployed product. The secret weapon: Claude Code — Anthropic's terminal-based AI coding assistant that reads your project, writes code, and runs commands right inside your codebase.
Friday night: One hour of decisions (not code)
The weekend starts Friday at 9pm. Not with code — with decisions. Every minute you spend deliberating on Saturday is a minute you're not building.
Pick a project shape
These are the only shapes that realistically ship in a weekend:
| Shape | Example | Complexity |
|---|---|---|
| Tool | PDF merger, image compressor, text formatter | Low |
| Dashboard | Analytics viewer, status page, metrics display | Medium |
| Marketplace lite | Directory, listing site, curated collection | Medium |
| SaaS micro | One-feature product with auth and a billing page | Medium-High |
| API wrapper | Take an ugly API — a way for programs to talk to each other — and make it pretty | Low-Medium |
Write the one-page spec
Open a file. Write exactly this. Nothing more:
# Weekend MVP: [Name]
## One sentence
[What it does, for whom]
## Core flow
1. User lands on page
2. User does [main action]
3. User gets [result]
## Must have (Saturday)
- [ ] Landing page
- [ ] Core feature
- [ ] Deploy to production URL
## Nice to have (Sunday)
- [ ] Auth
- [ ] Email notifications
- [ ] Basic analytics
## Will NOT build
- [ ] Admin panel
- [ ] Payment processing
- [ ] Mobile app
- [ ] User profiles
That "Will NOT build" section? Most important part of the whole doc. It's your shield against scope creep — the natural tendency to keep adding "just one more thing" until Sunday's gone and you've built nothing complete.
Set up the repo
A repo (repository) is just a project folder tracked by Git — version control software that saves every change you make, like infinite undo for your code.
mkdir my-mvp && cd my-mvp
git init
# Pick ONE stack. Don't deliberate.
# Option A: Next.js + Supabase (full-stack, most flexibility)
npx create-next-app@latest . --typescript --tailwind --app
# Option B: Static + API (simpler, faster)
# Just create index.html and a /api folder
touch SPEC.md # Paste your one-page spec here
git add -A && git commit -m "init: weekend mvp"
Next.js is a React-based framework — think of it as a starter kit for building web apps that handles routing, server-side rendering, and deployment out of the box. Supabase gives you a database, user login, and file storage with zero server setup.
Saturday morning: Build the core (4-5 hours)
Wake up. Coffee. Terminal open. No social media, no email, no "let me just check one thing."
Hours 1-2: Scaffold with Claude Code
This is where Claude Code earns its keep. Open it in your project directory:
claude
Give it the full context:
Read SPEC.md. This is a weekend MVP — we're building
the minimum possible product.
Scaffold the project:
1. Set up the page structure based on the core flow
2. Create the main feature component
3. Set up basic styling with Tailwind
4. Create a layout with nav and footer
5. No auth yet, no database yet — just the UI and core logic
Claude Code generates 5-15 files. Don't review every line. You're checking three things: does it run (npm run dev), is the core flow there, is the code structure sane?
Hours 2-4: Implement the core feature
This is the only code that matters. Everything else is scaffolding — structural support that isn't the product itself.
Say you're building a meeting cost calculator. You tell Claude Code:
The core feature is a calculator that takes:
- Number of participants
- Average hourly rate
- Meeting duration
And shows a real-time cost counter, total cost, and
cost-per-minute breakdown. Single React component.
No backend needed. Use useState for the timer,
useEffect for the counter animation.
Claude Code writes it. You test in the browser. You iterate:
The counter animation is jerky. Use requestAnimationFrame
instead of setInterval. Make the cost number huge — 72px,
monospace font.
Key discipline: only iterate on the core feature. If the nav looks wrong, write it down. Fix cosmetics Sunday.
Hours 4-5: Deploy 🚀
Deploy before lunch. Having a live URL — a real address anyone can visit — changes your psychology from "playing with code" to "building a product."
# Vercel (fastest for Next.js)
npx vercel
# Or Cloudflare Pages (fastest for static sites)
npx wrangler pages deploy ./out
Vercel auto-deploys every time you push code. Free tier covers any MVP. Send the URL to one person. Their 30-second reaction tells you more than a week of solo development.
Lunch: Walk away
Seriously. Eat food that isn't at your desk. The afternoon session doubles in productivity when your brain has rested.
Saturday afternoon: Connective tissue (3-4 hours)
Core feature works. Now make it feel like a product.
Hours 6-7: Database (if needed)
Not every MVP needs a database — a structured place to store and retrieve data. A calculator doesn't. A directory does.
If yours does, tell Claude Code:
Set up Supabase:
1. Design the minimum schema — only tables for the core flow
2. Set up the client in lib/supabase.ts
3. Add basic CRUD for the main data type
4. No RLS yet, no complex queries — just make it work
CRUD means Create, Read, Update, Delete — the four basic operations on any data. RLS (Row Level Security) controls who can see which rows. Skip it for now.
Supabase's free tier gives you 500 MB of PostgreSQL — a powerful open-source database. For an MVP, you'll use about 1 MB. That's 500 MVPs worth of headroom. 💰
// lib/supabase.ts — this is all you need
import { createClient } from '@supabase/supabase-js'
export const supabase = createClient(
process.env.NEXT_PUBLIC_SUPABASE_URL!,
process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
)
Hours 7-8: Auth (if needed)
Auth (authentication) — making users log in to identify themselves. A meeting calculator doesn't need it. A personal dashboard does.
Add Supabase Auth:
1. Email + password signup/login
2. Simple auth form component
3. Protected route for the dashboard
4. Session management via middleware
5. No social login, no MFA — just email and password
MFA (multi-factor authentication) is that second code from your phone. Supabase Auth handles 50,000 monthly active users for free. You'll never hit that during MVP weekend.
Hours 8-9: Landing page
Your landing page needs exactly four things:
- Headline — what it does (5-8 words)
- Subheadline — who it's for (1 sentence)
- CTA button — "Try it free" / "Get started"
- One screenshot — show the product working
Create a landing page:
- Hero section with headline, subheadline, and CTA
- One section showing the core feature
- Simple footer with contact info
- No testimonials, no pricing, mobile responsive
No feature comparison table. No "trusted by" logos. No animated gradients. Ship the real thing, not a marketing site about the real thing.
Sunday: Polish and launch (6-8 hours)
Morning: Fix everything you ignored ⚡
Open your notes from Saturday. Feed them to Claude Code in a batch:
Fix these in order:
1. Nav doesn't highlight the active page
2. Mobile menu doesn't close after clicking a link
3. Loading state shows blank — add a skeleton
4. Form validation missing on email field
5. Footer links go nowhere — add pages or remove links
Each fix is small. Together they turn "demo" into "product."
Afternoon: Launch checklist
### Works
- [ ] Core feature works on desktop Chrome
- [ ] Core feature works on mobile Safari
- [ ] All links go somewhere
- [ ] Forms validate input
- [ ] Errors show user-friendly messages
### Looks right
- [ ] Favicon exists
- [ ] Page title and meta description set
- [ ] OG image for social sharing
- [ ] No placeholder text ("Lorem ipsum")
- [ ] Consistent spacing and typography
### Production ready
- [ ] Environment variables set in production
- [ ] HTTPS works
- [ ] Loading time under 3 seconds
- [ ] No console errors
- [ ] 404 page exists
Ask Claude Code: "Run through this checklist against our codebase. Tell me what passes, what fails, fix the failures." It handles this in minutes.
Evening: Ship it
Post to Twitter/X, relevant Discord servers, one Reddit thread, Hacker News "Show HN" if it fits. The post format that works:
I built [product name] this weekend — it [does thing] for [audience]. [URL] Built with Next.js + Supabase + Claude Code. Feedback welcome.
Don't write a 2000-word launch essay for a weekend project. The product speaks or it doesn't.
The time-killers that destroy weekend MVPs 🗑️
| Time killer | Why it's tempting | Why it's a trap |
|---|---|---|
| Custom design system | "It should look professional" | Tailwind defaults look fine |
| Auth from scratch | "I don't trust third-party" | Supabase Auth takes 10 minutes |
| Database optimization | "What if we scale?" | You have 0 users. Optimize at 1,000 |
| CI/CD pipeline | "Best practices" | Push to main. Vercel auto-deploys |
| Test suite | "I should have tests" | Manual test a weekend MVP |
| Payment integration | "I need to monetize" | Get users first. Add Stripe in week 2 |
| Admin panel | "I need to manage data" | Use Supabase dashboard directly |
CI/CD (Continuous Integration/Continuous Deployment) means automated testing and deploying every time you push code. Valuable at the right time. This weekend is not that time.
The realistic timeline
Friday 9pm: Write spec, set up repo (1h)
Saturday 9am: Scaffold + core feature (4h)
Saturday 1pm: Lunch break (1h)
Saturday 2pm: Database + auth + landing page (4h)
Saturday 8pm: Done for the day
Sunday 10am: Polish + bug fixes (3h)
Sunday 2pm: Launch checklist + deploy (2h)
Sunday 5pm: Post online + collect feedback (1h)
Sunday 6pm: Weekend MVP shipped
Total focused coding time: ~14h
14 hours of focused work. Not 48 hours of sleepless scrambling. Sleep both nights. Exercise Sunday morning. Rested code beats exhausted code every time.
🦝 Schnapps's take
The weekend MVP stress-tests your idea, not your stamina. If you can't explain what the product does in one sentence, you can't build it in a weekend. If you can't build the core feature in 4 hours with Claude Code helping, the feature is too complex for an MVP.
The projects that ship share one trait: the builder cut scope ruthlessly. One section on the landing page. One feature in the app. Two tables in the database. And it shipped.
The projects that don't ship share a different trait: the builder spent Saturday afternoon researching which animation library to use for page transitions. There are no page transitions in an MVP. There's a page, and it works. Ship that. 🚀
