Marc Lou ShipFast GitHub: SaaS Starter Evolution

If you searched for "marc lou shipfast github," you're likely mapping the SaaS starter-kit landscape: what ShipFast solved, where it lives on GitHub, and what comes next. This guide covers that lineage and explains why the space is moving toward AI-native starters that provision services instead of handing you a box of parts.

What Marc Lou Built (And Why It Matters)

Marc Lou popularized the modern SaaS boilerplate with ShipFast, a private GitHub repository you clone after purchase. It bundles payments, a database, login, and battle-tested UI so founders skip weeks of setup. The pitch worked: Marc publicly documented making $250K+ in five months selling it, and the template became a reference point for the whole "launch in days, not weeks" category.

ShipFast's insight was correct and durable: the framework choice is not what slows you down. The wiring between services is. But ShipFast is a manual template. You clone it, read the README, and configure everything by hand.

The next generation moves that setup work onto a coding agent. That's the idea behind BoiledPlate: an AI-native Nuxt + Supabase starter whose setup runs itself. Your agent interviews you, then provisions Stripe products and webhooks, a Supabase database with row-level security, and Google sign-in in a single session.

The Real Cost of SaaS Setup (That Nobody Talks About)

Ask ten founders how to ship fast and you get ten stack arguments — Next vs Nuxt, Postgres vs a hosted DB, Stripe vs Paddle. Pick whatever you already know and that debate is over in an afternoon.

What actually eats your launch is the plumbing between the pieces: webhook idempotency, RLS, refunds, and EU consent. None of it is clever. It's endless, slightly different every time, and invisible until it breaks in production.

Agents change the equation. Instead of you wiring four services by hand, the agent provisions them while you answer questions about your product. The slow part — bolting the parts to each other — moves off your plate.

BoiledPlate vs. ShipFast vs. Building from Scratch

ShipFast is the manual template that proved the market. You get a complete repo and configure it yourself.

BoiledPlate is the agent-driven evolution. It ships an AGENTS.md contract and applies deterministic patches — automated, repeatable code changes that reshape the codebase to your answers.

Building from scratch is the DIY trap. "Just use these libraries" still leaves you wiring Stripe webhooks against your database, writing RLS policies, and handling refund flows by hand.

Each approach trades time for control. Scratch gives maximum flexibility and costs the most weeks. ShipFast gives a head start with manual setup. BoiledPlate compresses the setup itself into a session.

How BoiledPlate Actually Sets Itself Up

The first session is an interview. Your agent asks for the product name, languages, theme, and billing model — then reshapes the entire codebase with deterministic patches.

Deterministic patches are not freehand code generation. They're repeatable transformations, so the same answers produce the same result. That reliability comes from the AGENTS.md contract: one documented way to do data access and secrets, so the agent stays consistent instead of inventing a new pattern every file.

By the end of a session, Supabase RLS, Stripe products, and Google sign-in are provisioned — not stubbed for you to finish later.

Webhook Architecture That Actually Works

"It worked in testing" is where most billing implementations die. Stripe retries webhooks. They arrive twice. They arrive out of order. If your handler isn't idempotent, a repeated call duplicates side effects.

The correct model treats Stripe webhooks as the source of truth for billing state — not the client-side success page a user might never reach. BoiledPlate builds on this: signature-verified, idempotent webhooks that survive retries and race conditions.

Delivery is subtle. In BoiledPlate's own product webhook, some failures must throw and some must never do — because a throw tells Stripe to retry, and retrying the wrong step doubles the damage.

Billing Edge Cases That Ship-Ready Starters Must Handle

Real billing is more than a checkout button:

• EU consent laws. Selling to Germany means encoding a withdrawal waiver into the pay button via Stripe's consent_collection. Getting this wrong at launch is a compliance problem, not a to-do.
• Multi-plan subscriptions. Single-tier billing doesn't survive customer reality. BoiledPlate ships multi-plan Stripe subscriptions.
• Refunds and state drift. When Stripe says one thing and your app says another, the webhook wins.

Staging webhooks rarely reproduce production surprises, which is why the architecture has to be defensive from day one.

Auth and Security: Row-Level Security Done Right

A valid JWT proves who someone is. It does not stop a query from returning another user's rows. That's the RLS gap — auth is the fast part; RLS is the part you forget until a user sees data that isn't theirs.

Supabase enforces permissions at query time in the database, not in application code you might bypass. BoiledPlate ships with RLS patterns already in place, which closes the most common and most dangerous class of starter-kit mistakes. RLS isn't the whole story — you still want signature verification, token expiration, and rate limiting — but it's the foundation.

Product Delivery as a Feature: GitHub Invites and Instant Delivery

Like ShipFast, BoiledPlate delivers code as a GitHub repository, not an email attachment. Buy Pro and you receive GitHub access within seconds, triggered by the same Stripe webhook architecture the product teaches. The delivery mechanism is a working example of the plumbing you're buying.

Pro is €159 one-time with lifetime updates. Updates ship as semantic, agent-readable release notes, so you can opt into changes even in code you've customized — a genuinely hard problem that raw git merges handle badly.

The Anti-Plumbing Stack: Why These Tools Work Together

The stack settles quickly, and each piece demands something specific:

• Nuxt — full-stack framework, minimal magic, agent-friendly.
• Supabase — PostgreSQL with RLS, fewer moving parts than a managed auth service.
• Stripe — the webhook standard every SaaS founder learns anyway.
• Resend — transactional email that's simple to send and annoying to send exactly once.

Tools like Firebase auth and heavier ORMs were left out deliberately to keep the surface small and the conventions consistent.

Technical Deep Dives: Real Bugs and Lessons Learned

The trustworthy version of this stack is a log of edge cases, and BoiledPlate documents its own:

• A JSON-LD hydration bug that returned 200 from curl and 500 in Chrome — because of source order.
• The blog that told Google its canonical URL was localhost:3000.
• A peer-dependency conflict where @vercel/analytics broke nuxt typecheck under strict mode.

These are the surprises that separate production from a hobby project.

SEO, TypeScript, and i18n From Day One

BoiledPlate ships a prerendered Markdown blog — no CMS, version control as the source of truth — with JSON-LD and og:url canonicals baked in. That matters because organic discovery and honest debugging posts are how SaaS founders (Marc Lou included) build durable traffic. Read the BoiledPlate blog for the running log.

The codebase is TypeScript in strict mode, typed end to end across database, API, components, and webhooks. Strictness costs more typing upfront and catches bugs before production. It ships four languages from day one, because adding i18n later breaks routing and forces a refactor you'll resent.

Pricing and Positioning: Free Lite vs. Pro

There are two tiers. BoiledPlate Lite is MIT-licensed and free — clone it and wire the services manually. Pro is €159 one-time with lifetime updates and instant GitHub delivery, and it's the agent-driven setup that provisions services for you.

The value exchange is straightforward: Lite removes the barrier to trying the stack; Pro removes the weeks of plumbing. One-time pricing suits founders who'd rather pay once and own the code than rent a platform.

When BoiledPlate Is the Right Choice (And When It Isn't)

Good fit: you're building on Nuxt + Supabase + Stripe, want multi-plan billing, and work with a coding agent like Claude.

Wrong fit: you're locked into Rails or Django, you have highly custom payment logic, or your organization can't use agents. You can diverge from BoiledPlate's opinions, but every divergence trades away some of the agent's consistency benefits.

Common Questions

"Is this just ShipFast renamed?" No. ShipFast is a manual template; BoiledPlate is agent-native with deterministic patches and an AGENTS.md contract. The lineage is real, the mechanism is different.

"Can I really deploy in minutes?" The setup session is fast, but your final timeline depends on your schema and Stripe configuration.

"Do I need to use Claude?" The starter ships agent-ready. Using an agent is optional — Lite is a clone-and-wire template either way.

The Bigger Picture

Marc Lou's ShipFast proved that founders will pay real money to skip plumbing, and its GitHub-delivery model set the template for the category. The next move is obvious in hindsight: if the plumbing is the project, and agents can now read conventions and apply patches, then the setup itself should run itself.

That's the bet BoiledPlate makes. The full product is worth a look if you've felt the gap between choosing a stack and actually shipping on it.

For deeper background on Marc Lou's work, see ShipFast and his write-up of the launch on Just Ship It.