Marc Lou's ShipFast: From $0 to $90K Monthly

Marc Lou didn't invent the SaaS boilerplate. He turned it into a business that reportedly clears $90K in a good month. If you want to understand why a folder of Next.js code sells better than most funded startups, you have to look past the code and at the playbook: the launch, the pricing, the portfolio, and the marketing. Here's the full breakdown — and what it teaches anyone building on a different stack.

The Origin Story: From Broke to $90K+ Monthly

Before ShipFast, Marc Lou was broke. He'd shipped a string of startups that didn't stick, and the desperation shows in how he built ShipFast: fast, cheap, and aimed at solving his own repeated pain.

He chose Next.js for a boring, correct reason — market demand. Next.js had the largest mindshare among indie hackers, which meant the widest possible buyer pool. He wasn't picking the best framework; he was picking the most sellable one.

The proof came at launch. ShipFast reportedly earned about $6,000 of profit in 48 hours — more than he'd made in the entire prior year. That validation shaped everything after: the product wasn't "a better React app," it was "the thing that gets you to revenue this weekend."

What Makes ShipFast Different From Generic Bootstraps

The most common skeptical question — and it's a real Reddit thread — is "what does ShipFast do differently than any bootstrapper?" There are free starters for every stack. Why pay?

The answer isn't the parts. It's the wiring. Every starter hands you auth, a database client, a Stripe integration, and a landing page. As we've written before, the parts were never the problem — bolting them to each other is the part that eats your weekends. ShipFast sells the integrated ecosystem: Stripe, auth, and email that already agree with each other.

The stack choice is the easy decision. The plumbing is the project.

The Real Cost of SaaS Setup (What ShipFast Solves)

Ask ten founders how to ship fast and you get ten stack arguments. Meanwhile the actual time sink is invisible until it breaks:

• The Stripe webhook that has to reconcile with your database
• The row-level security policy you forgot until a user saw someone else's data
• The five files a new locale string has to land in before the build stops complaining
• Subscription state that drifts between Stripe and your own tables

None of it is clever work. It's endless, slightly-different-every-time work. That's the real cost of shipping SaaS, and it's exactly the weeks a boilerplate reclaims.

Webhook Architecture and Billing Edge Cases

The hardest part of any billing system is the webhook, not the checkout button. Checkout is a redirect. The webhook is where money becomes truth.

Two principles separate a toy integration from a trustworthy one:

Idempotency. Stripe retries webhooks on failure, which means your handler will receive the same event more than once. A non-idempotent handler double-grants access or double-emails. You need to safely absorb repeats.

Stripe as source of truth. Your checkout success page should never touch billing state. The success page is a client redirect a user can refresh, close, or fake. The webhook is the only event you can trust.

Then there's compliance. Selling to EU customers means encoding things like the German withdrawal waiver directly into the pay button via Stripe's consent_collection. Refunds and subscription reconciliation are more of the same: unglamorous, mandatory, easy to get subtly wrong.

The Interconnected Portfolio Strategy

ShipFast isn't a standalone product. It's the hub of a portfolio. It feeds CodeFast (a coding course), a YouTube channel, and a stream of smaller startups. Each one cross-promotes the others.

The genius is that shipping many startups validates the boilerplate itself. Every new launch is a live demo that the tool works. Revenue diversifies across product sales, courses, content, and affiliates — and the boilerplate sits underneath all of it as proof.

AI Agent Consistency: The AGENTS.md Solution

Here's where the playbook is about to change. When you build with coding agents, agents drift. Ask Claude to add a feature twice and you can get two different data-access patterns, two secret-handling conventions, two shapes of the same thing.

The fix is a contract. An AGENTS.md file documents the one way to do data access and secrets, so the agent produces consistent output every session. This is why BoiledPlate ships one — the setup interview and every later change route through documented conventions instead of the agent's mood that day. Write your conventions for the agent, not the next hire.

Product Delivery Mechanics: GitHub Invites as the Product

There's a quiet lesson in how ShipFast delivers: you don't get a download, you get a GitHub repository invite. The purchase triggers automation, not a human.

We build the same way, and it's harder than it looks. When the GitHub invite IS the product, your Stripe webhook has to decide which failures throw (retry me) and which must never throw (don't retry, you'll spam invites). Get that logic right and fulfillment scales to thousands of buyers with zero manual work.

The Anti-Plumbing Stack: Why These Tools Work Together

The specific tools matter because each one carries its weight and demands something back:

• Nuxt / Next.js — the framework everyone already knows, so onboarding friction is near zero.
• Supabase — auth is the fast part; RLS is the part you forget. Rolling your own auth is a mistake you make once.
• Stripe — reliable webhook delivery and mature refund handling, if you respect idempotency.
• Resend — transactional email without running mail infrastructure. Simple to send, annoying to send exactly once.

We break down what each piece actually demands in detail. The short version: good stack, real wiring cost.

Technical Debt and Real Bugs You'll Actually Hit

Shipping to thousands of developers surfaces the same recurring bugs, and they're rarely the ones you plan for:

• JSON-LD hydration crashes — a page can return 200 from curl and 500 in Chrome purely because of source order in structured data.
• Canonical URL edge cases — a misconfigured blog can quietly tell Google its canonical URL is localhost:3000.
• Peer dependency conflicts — the Node ecosystem where one analytics package breaks your typecheck.
• Webhook retry failures — the hardest to debug because they only fail intermittently, under load, in production.

A boilerplate's real value is that someone already hit these bugs so you don't have to.

The Marketing Advantage: Why Marc Lou's Approach Works

Marc Lou's biggest edge isn't the code — it's the marketing. He publishes his revenue figures, his failures, and his playbooks openly. Transparency is the marketing. His YouTube channel doubles as proof of concept and an SEO moat that competitors can't buy their way past.

Building in public beat stealth here because the product's promise — "you can ship fast" — is best demonstrated by a founder visibly shipping fast, in public, on repeat.

Pricing Strategy and Unit Economics

ShipFast is a one-time purchase with lifetime updates, and so is BoiledPlate at €159. This pricing model works for boilerplates specifically because the buyer's mental math is simple: one payment versus weeks of their own billable time.

A free, MIT-licensed tier acts as the top of the funnel. Developers try the free version, hit the plumbing wall, and upgrade for the automation. Low CAC, high perceived value, no subscription to churn out of.

Customization Without Merge Hell

The dirty secret of boilerplates is what happens after you buy. You customize the code, then a new version ships, and merging updates into your fork becomes hell.

The way out is semantic, agent-readable release notes and opt-in, deterministic patches. Updates apply to customized code without forcing a full re-fork. This is the difference between a boilerplate you use once and a boilerplate you keep.

SEO and Technical Foundation as Differentiator

The foundation that ships out of the box quietly compounds:

• JSON-LD, canonical URLs, and og:meta tags configured correctly from day one
• TypeScript strict mode for long-term maintainability
• i18n in four languages so localization isn't a rewrite later
• A prerendered Markdown blog for content and SEO

None of this wins a demo. All of it matters six months in.

Comparing BoiledPlate to ShipFast: Stack-Specific Positioning

ShipFast owns the Next.js crowd. BoiledPlate is built for the Nuxt + Supabase + Stripe + Resend stack, with heavier emphasis on webhook idempotency, EU compliance, and — the real differentiator — agent-driven setup where your coding agent interviews you and provisions the services, not just the code.

Choose based on your stack and how you work. If you live in Next.js, ShipFast is the default. If you're on Nuxt and building with agents, BoiledPlate is the more natural fit.

The Myth vs. Reality: What Boilerplates Actually Solve

A boilerplate does not solve product-market fit. You still need an idea people want. It does not make your startup good.

What it solves is weeks of plumbing — the endless, error-prone integration work between services. Framework choice is easy; service integration is the bottleneck. The shipping-speed advantage is real, and speed is a genuine moat when your competitors are still wiring their webhooks.

Building a Sustainable Business on Top of Boilerplates

The durable version of this business isn't one-time sales — it's the ecosystem. Lifetime updates keep the product alive, community and content keep customers around, and each new startup the founder ships re-validates the framework in public.

As the underlying stack commodifies, the moat shifts from code to automation and consistency. That's the future Marc Lou pointed at, and the one AGENTS.md-driven, webhook-provisioned tools are built for: fewer manual steps, higher switching costs, and delivery that runs itself. Read more on how the plumbing — not the stack — is the real project.