ShipFast vs BoiledPlate: Marc Lou's SaaS Boilerplate Compared

When developers research SaaS boilerplates, one name comes up more than any other: ShipFast, Marc Lou's Next.js starter that reportedly earned $250,000 in five months and helped anchor a portfolio doing $90K+ per month. It's a genuine success story, and it's worth understanding why. But it's also worth asking a sharper question: what does a boilerplate actually solve, and what does it leave on your plate?

This is a comparison, not a takedown. ShipFast solved template speed brilliantly. BoiledPlate solves a different problem — the one that starts after you clone the repo.

The SaaS setup problem 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 the debate is over in an afternoon. The framework is not what slows you down.

What slows you down is the wiring between the pieces. Templates ship code — components, a landing page, a Stripe helper. They don't ship configured infrastructure. You still create Stripe products by hand, copy webhook signing secrets into env vars, write RLS policies you'll debug in production, and pray your Google OAuth redirect URI matches your deployed domain.

That gap — code versus running services — is where weeks disappear.

What Marc Lou got right

Marc Lou's real moat was never the code. It was timing, audience, and relentless marketing. He built in public, shipped fast, and turned ShipFast into the foundation of an interconnected portfolio: CodeFast to teach coding, then TrustMRR, DataFast, and more. Each product feeds the others.

The "ship fast" message resonates because founders genuinely are drowning in setup friction. Marc named the pain perfectly. He just chose to solve it with a template plus a community, not with automation.

That's the opening BoiledPlate steps into.

Where traditional starters fall short

Every SaaS starter hands you the same box of parts: auth, a database client, a Stripe integration, a pile of Tailwind. Then it leaves you alone in a room with the box and a README.

The parts were never the hard part. Bolting them together was:

Stripe: products, prices, webhooks, signature verification, retry logic — all on you.
Supabase RLS: templates show you a policy; you find the silent failures when a user sees someone else's data.
Google OAuth: one misconfigured redirect URI and you lose an afternoon.
Email: sending is easy; sending exactly once with proper unsubscribe headers is not.

None of it is clever. It's endless, slightly different every time, and it eats your weekends.

The agent-native difference

BoiledPlate is an AI-native Nuxt + Supabase starter whose setup runs itself. Instead of leaving you with the box, your coding agent interviews you once — name, languages, theme, billing model — then reshapes the codebase to your answers with deterministic patches.

More importantly, the agent doesn't just write code. It provisions the services:

Stripe products and webhooks created during setup, not weeks later.
A Supabase schema generated with RLS rules baked in.
Google sign-in wired before you write a line.

The distinction matters. ShipFast gives you boilerplate to customize. BoiledPlate applies your decisions and stands up the infrastructure in the same session.

Billing done right: the edge case graveyard

Billing is where most starters quietly punt. The checkout is the easy bit. The webhook is the product.

Duplicate calls, network failures, and Stripe's own retries mean your handler will run twice. Without idempotency, you double-provision, double-charge, or double-email. Your billing state has to live in Stripe events, not the client-side success page — because users close tabs, and the success redirect is not a guarantee of anything.

Then come the details nobody warns you about:

Subscription state without race conditions.
Refunds: partial, immediate cancellation, grace periods.
EU compliance — like encoding a German withdrawal waiver into the pay button so a one-time digital sale is actually enforceable.

BoiledPlate ships these patterns prebuilt. With a raw template, you learn each one the expensive way.

The real cost of wiring services

Here's the wiring each piece actually demands, laid out in detail in what it takes to wire up a Nuxt, Supabase and Stripe SaaS:

Stripe webhook verification: signature validation against replay, delivery guarantees, error handling that distinguishes "retry me" from "never retry."
Supabase RLS: which tables, which auth column, which policies fail silently and hand you an empty array instead of an error.
Email: Resend integration, transactional templates, unsubscribe headers.
Auth state syncing: Google sign-in → Supabase user → Stripe customer ID, all consistent.

These aren't features. They're prerequisites that only feel like features after you've debugged them.

Why Nuxt, Supabase, and Stripe fit together

This is the anti-plumbing stack, and each tool owns exactly one critical job:

Nuxt: edge-friendly SSR that handles SEO and secrets server-side.
Supabase: RLS enforced at query time — security you don't have to remember in application code.
Stripe: webhook-driven billing, so the truth lives on the server, not the browser.

The trade-off is real: you're not on Firebase, Cognito, or a custom billing engine. For most SaaS, that's exactly the constraint you want — fewer moving parts, cleaner seams.

Agent consistency: the AGENTS.md contract

Coding agents drift. Ask the same agent to solve the same problem twice and you get two different solutions. That's fine for a prototype and fatal for a codebase you have to maintain.

BoiledPlate ships an AGENTS.md contract documenting one canonical way to read the code, find patterns, and apply changes. The point is to write your conventions for the agent, not the next hire. Deterministic patches beat freestyle rewrites because they're reproducible — and updates arrive as semantic, agent-readable release notes you opt into, so your customizations don't turn into merge hell.

Revenue math: template as platform

Marc Lou's playbook is a portfolio: ShipFast as the foundation, then courses and analytics tools stacked on top. It works because his edge is distribution.

BoiledPlate isn't competing on marketing. It's competing on what the code can do. Pricing reflects that: €159 one-time, lifetime updates, instant delivery via GitHub. The GitHub invite is the product — agent-readable code, no SaaS overhead, no subscription. Recurring revenue isn't the goal; reducing friction for builders who value shipping is.

Technical specifics that actually matter

The small things break in ways that cost real hours:

JSON-LD: get source order wrong and you get 200 from curl, 500 in Chrome.
Canonical URLs: it's shockingly easy to ship a blog that tells Google its canonical URL is localhost:3000.
i18n: four languages prerendered from day one, not bolted on later.
TypeScript strict mode: fewer surprises in production.
Peer dependencies: Nuxt versions matter — some packages quietly break typecheck.

The debugging tax

The bugs that cost the most are the quiet ones. RLS policies that fail silently and return empty arrays. Webhook retries that duplicate rows. Stripe signature validation windows and clock skew. OAuth redirect URIs that work on localhost and die on your deployed domain. Transactional email that lands in spam because deliverability is not just SMTP — it's a webhook where some failures must throw and some must never.

BoiledPlate exists because someone already paid this tax and wrote down every edge case. Those lessons are baked in, not left as exercises.

When to use which

Be honest about the fit:

Use BoiledPlate for billing SaaS with user accounts and email flows, when you want production-ready wiring in weeks.
Use ShipFast for simpler products where marketing leverage and Marc's audience-building playbook are your real advantage.
Use a blank slate when you have infrastructure you must control and years of runway.

BoiledPlate is narrower and faster. ShipFast is broader and proven on distribution. They optimize for different things.

Lite vs. Pro

Lite (MIT, free): clone and wire manually — you do the agent interview work yourself. See the free Nuxt + Supabase boilerplate.
Pro (€159, lifetime): GitHub delivery, agent-ready code, automated provisioning, and updates that include webhook patterns, RLS improvements, and compliance changes.

One-time pricing exists to kill decision friction for builders who'd rather ship than deliberate.

The Marc Lou effect: marketing vs. infrastructure

Marc Lou's success isn't reproducible with tactics alone — it's timing, audience, and execution. Copying his landing page won't copy his outcome.

BoiledPlate isn't trying to be the next ShipFast. It's trying to be the infrastructure ShipFast founders secretly wish existed: so boring it disappears. The builder's real choice is between fast boilerplate with weeks of wiring, or a slightly longer setup that ships configured.

Getting started

The path from interview to deployed SaaS is short. Your agent asks about billing model, data schema, email workflows, and branding. Deterministic patches apply your answers. Stripe products and webhooks get created. Supabase schema is generated with RLS. Google OAuth is pre-wired. Then you deploy and start selling — a session to production-ready, not weeks of setup.

Looking forward

Coding agents already exist. Infrastructure built for them mostly doesn't — yet. Deterministic patches and AGENTS.md-style contracts are how customization stops fighting updates, and they're becoming the sensible default. As Stripe's own webhook guidance and Supabase's RLS documentation make clear, the hard part was always the wiring. BoiledPlate's bet is that agents should do that wiring, consistently, once.

Marc Lou taught the market to ship fast. BoiledPlate takes the next step: ship configured. Browse the blog for the edge cases that shaped it.