I Used Claude AI to Build a SaaS in 3 Days

Everyone says you can build a SaaS "in a weekend." Most of those claims are either misleading or involve a very loose definition of "built."

I wanted to test the claim properly. I had a product idea, a time limit, and Claude Sonnet 4 as my co-developer. Here's the real story.

The Product Idea

I was building a simple SaaS for micro-agencies: a client portal where freelancers could share project status updates, files, and invoices with clients — without handing them access to Slack or Notion.

Basic requirements:

• Freelancer creates a portal, invites clients by email
• Clients see updates, download files, view invoices
• Freelancer gets paid through Stripe
• Everything branded with the freelancer's logo and name

This is not a trivial product. It has auth, multi-tenancy, file storage, Stripe, email, and a decent UI. Exactly the kind of thing that used to take 2–3 months.

Day 1: Setup (2 hours)

I cloned PropelKit — a Next.js 15 boilerplate with Supabase, Stripe, Resend, and multi-tenancy already wired up.

Then I ran /pk:start to kick off PropelKit's AI Product Manager. It interviewed me:

• "What's your product called?"
• "Who is the primary user — the freelancer or the client?"
• "What does a client need to do once they're invited?"
• "Do you need file uploads? What types?"

After 10 minutes of conversation, it generated:

• A customized brand.ts with my product name and colors
• A features.ts with multi-tenancy enabled
• Database schema for portals, clients, and updates
• A starter API structure for the key endpoints

I had a running local dev environment in under 2 hours. Auth worked. I could create an account and see the dashboard.

Day 1: Core Feature (4 hours)

I opened Claude Code and started describing what I needed:

I need a "portal" concept. A portal belongs to a freelancer (the logged-in user). 
It has a name, a custom slug, and an optional logo URL. Create:
1. The Supabase table with RLS policies (only the owner can create/edit)
2. The API routes: GET /api/portals, POST /api/portals, GET /api/portals/[slug]
3. A dashboard page at /dashboard/portals that lists portals and has a "New Portal" button
4. A creation form with name and slug fields

Claude wrote the migration SQL, the API routes, and the dashboard page. I read everything, caught one RLS policy that was too permissive, and fixed it in one more message.

By end of day 1: Freelancers could create and manage portals. The core data model was solid.

Day 2: Client Invitation and Portal View (6 hours)

This is where it got interesting. Client invitations involve:

• Generating a secure invite token
• Sending an email with a custom link
• Creating a client account linked to the portal
• A portal view page accessible without full auth (just the invite token)

I broke this into 5 separate Claude conversations:

1. "Create the invite token system — store in Supabase, expire after 7 days"
2. "Add the POST /api/portals/[slug]/invite endpoint that creates a token and sends email via Resend"
3. "Build the /invite/[token] page that validates the token and creates a client account"
4. "Create the client dashboard at /portal/[slug] that shows updates"
5. "Add the access control — clients can only see portals they're invited to"

Each conversation was focused and small. Claude got each one right on the first or second try.

The email template I wrote in plain text first, then asked Claude to convert it to a nice HTML email with the brand colors.

By end of day 2: Clients could be invited and view their portal.

Day 3: File Uploads, Invoices, and Polish (5 hours)

File uploads with Supabase Storage were the trickiest part. The Claude prompt:

Add file upload to the portal update system. Use Supabase Storage. 
Files should be scoped to the portal (RLS on the bucket). 
The upload should happen client-side with a presigned URL, 
then the file reference saved to the database.
Add a file list component to the portal view.

Claude got the presigned URL flow wrong on the first try (it used the server-side approach instead of client-side). I corrected it, and the second attempt was exactly right.

The Stripe integration was already in PropelKit. I just needed to wire up the invoice creation flow:

Add a simple invoice feature to portals. A freelancer can create an invoice with 
amount, description, and due date. When the client pays via Stripe checkout, 
mark the invoice as paid. Show unpaid invoices prominently in the client portal.

This took about 45 minutes total — mostly because PropelKit's Stripe setup was already done.

The Results

After 3 days (roughly 17 hours of actual work):

• Working multi-tenant SaaS with auth
• Client invitation system with email
• File uploads with scoped storage
• Stripe payments for invoices
• A reasonably polished UI (I used Lovable for the landing page)
• Deployed on Vercel

Is it production-ready? Mostly. I'd want another day for:

• Error handling edge cases
• Loading states on slower connections
• Mobile responsiveness polish
• Stripe webhook retry handling

But it works. Real users could sign up today.

What Claude Got Right

Perfect at:

• Database schema design and Supabase migrations
• API route structure and error handling
• React component structure
• Form validation
• Tailwind CSS styling

Good at:

• Supabase RLS policies (with review)
• Email templates
• Next.js App Router patterns

Needed guidance:

• Complex auth flows (I had to describe the security model clearly)
• File upload presigned URLs (got wrong once)
• Edge cases in multi-tenancy (got it right with more context)

What the Stack Looked Like

Framework: Next.js 15 (App Router)
Database: Supabase (PostgreSQL + Storage + Auth)
Payments: Stripe (via PropelKit)
Email: Resend (via PropelKit)
AI model: Claude Sonnet 4 via Claude Code
Hosting: Vercel
UI: shadcn/ui + Tailwind + Lovable for landing
Boilerplate: PropelKit

The Key Lesson

The bottleneck isn't writing code anymore. It's knowing what to build.

I spent more time thinking about the invite flow, the permission model, and the UX than I spent actually coding. Claude handled the implementation. I handled the product decisions.

If you try to vibe code without a clear mental model of what you're building, you'll get confused AI outputs and waste hours cleaning up. If you think clearly and prompt specifically, Claude is genuinely fast.

How to Replicate This

1. Start with PropelKit (or another good boilerplate). Don't start from scratch.
2. Use the AI PM to generate your initial spec. It forces you to think clearly about the product.
3. Break features into small, testable chunks. Never prompt for more than one screen at a time.
4. Read every file Claude creates. It takes 5 minutes and catches most mistakes before they compound.
5. Deploy on day 1. Having a real URL keeps you honest about what's actually done.

Three days to a working SaaS. That's the state of development in 2026.

The only question is what you're going to build.

---

PropelKit gives you everything except the idea. Auth, payments, AI tools, and an AI PM to help you plan it. Get started →