Case snapshot

Who: Marc Lou (Marc Louvion), French indie maker, builds in public
Product: ShipFast—a Next.js starter for indie builders (auth, payments, landing pieces, etc.)
Public figures (his posts & interviews): building in public on Twitter from ~late 2021; by ~Aug 2023 nearly 20 side projects, ~35k audience, ~10 products making money, 3 sold for ~$50k total, the rest ~$4k/mo combined. ShipFast took about a week to assemble; Product Hunt brought ~$6,000 in ~48 hours; ~5 months later he said ~$250,000 cumulative at ~90% margin. Third-party write-ups often cite ~$43k/mo within ~two months; he later talked ~$50k/mo across products.

Why did nearly twenty products fail to lift income—while a starter he spent about a week packaging did?

Marc’s answer wasn’t “a better idea.” It was turning repeated labor from years of shipping into a product he could sell again and again.

Not “boilerplates are a hot niche,” but classic experience commercialization:

Ship many products → spot repeated work → find peers with the same pain → standardize the fix → sell it to people still building.

1. What he stocked wasn’t a hit—it was the grunt work he rewrote every time

His early path looked familiar: idea → build → ship → see if anyone pays. He just did it very fast.

Across roughly two years he published close to 20 projects. Some died, some earned, some reached a few hundred or a few thousand dollars a month. It looked like endless trials. Looking back from ShipFast, those misses and small wins answered another question:

What does every SaaS force a developer to rewrite?

Auth, signup, Stripe, pricing, landing, email, SEO, DB, deploy, i18n, basic UI… unsexy—and required again on every product.

So the real starting question became:

If I’ve written this ten times, is someone else writing it for the first time?

He also burned years on “brilliant ideas”: a VC-backed flop, a unicorn concept he hid while polishing logos—then couldn’t answer how it would make money. He flipped: ideas are cheap, execution isn’t; share early and let customers grade you. Shipping often replaced self-congratulation with reality.

2. Why didn’t the earlier products become a real business?

He could already make money. By summer 2023 he could build, ship, acquire on Twitter, earn on some apps, and sell others. His newsletter: ~10 products with revenue, 3 exits totaling ~$50k, the rest ~$4k/mo—enough in Bali, not a step-change.

The bind: most products meant finding customers for a new, unfamiliar need every time. Each new SaaS reopened: who buys, why, where, why trust me, how to pay. Tech can be cheap; acquisition and trust get paid again.

A subtler trap: third-party deep dives note he still called Habits Garden (~$800/mo) a failure—not because it made nothing, but because of mediocre success: just enough to feel close, never enough to level up. Total failure is easy to quit; mediocre success locks attention.

ShipFast connected the years:

Many products → know who developers are, where they hang out, what they redo → already solved it → package → sell to the same people.

Not a new category discovery—finally turning stockpiled work into a SKU.

Takeaway: Many indie makers don’t lack products; they restart the hunt for users every time. Valuable accumulation is when the next product can reuse the last one’s users, channels, and trust.

3. He wasn’t selling code—he was selling time (and pits already fallen into)

On the surface ShipFast is a Next.js base: landing blocks, auth, Stripe—launch in days, not weeks. Buyers really purchase:

Days or weeks of not rewriting the same stack.

The buying question shifts: SaaS asks “does this solve my problem?”; a boilerplate asks “how long would I spend writing this myself?” If a day of a developer’s work is worth hundreds of dollars, paying hundreds for a template is buying time.

Free Next.js starters are everywhere. Why pay? Not for “a zip of code,” but for “I’ve already hit the walls—you can start the product.”

	Free starter	ShipFast
Delivery	Skeleton	Fuller launch base
Integrations	Mostly DIY	Auth / Stripe / landing wired
Decisions	You assemble	A ready path
Buyer gets	Code start	Code + time + experience + fewer choices

~Aug 2023 on Product Hunt. His words: ~$6,000 in 48 hours; he told his wife they’d be lucky to make $100—5 months later ~$250,000 at ~90% margin.

Takeaway: If you’ve solved the same problem 5–10 times, it may no longer be “dev experience”—it may already be merchandise.

4. The moat isn’t the repo—it’s trust inventory

After ShipFast took off, clones flooded in; Twitter turned boilerplates into a meme. Many still didn’t match his sales. Code copies; trust inventory doesn’t.

Years of building in public—what he shipped, how he launched, revenue, failures, marketing, PH—meant “this is the base after all those projects” had evidence. A brand-new account selling a “$299 ultimate indie template” gets: did you make money with it? Marc barely needs to answer—the years are the proof.

The loop, compressed:

Public shipping → audience & credibility → repeated pain → productize experience → sell to the same circle → revenue & attention amplify.

The PH ~$6,000 in 48 hours is easy to misread as “PH traffic is magic.” Cold products and people with a developer audience eat different traffic. Stack then: existing audience + new SKU + clear pain + high ticket + one-time buy.

PH amplifies; it doesn’t invent the engine. Copying “sign up for PH → ship a Next.js template” won’t copy that day. What copies: enter a clear circle, keep solving its problems, then productize a proven fix.

Takeaway: Code copies; proof you’ve lived the problem doesn’t. Build in Public wasn’t just marketing—it was pre-loading the trust a sale needs.

5. Why a one-time fee fit the usage cycle

Many assume monthly SaaS is “better.” For ShipFast, maybe not.

Buyers want to start a product. They don’t need to open the boilerplate daily. Demand is episodic: buy → build → launch. Force “$29/mo” and you hit “why rent a pile of code?”

One-time matches that psychology; the seller gets one build, many sales, low marginal cost—and high margin if support stays sane (he cited ~90%). Critics said one-time goes to zero; he later pointed at monthly curves: revenue follows product and marketing, not pricing shape alone.

Same logic as EasyCV’s quarterly shift:

Don’t pick SaaS first and force users into it. See how long they need you—then bill accordingly.

Two more verifiable moves: primary CTA nearly straight to Stripe (less signup friction); funny, self-deprecating videos, with Twitter as the first pool.

Near-zero ads × trusted circle × short checkout ≈ fits high-ticket digital goods.

6. Turn your own cost into their spend

Auth, pay, landing, SEO, deploy… used to be his time cost on every project. Standardize, document, productize—and internal capability becomes an external SKU.

Many small teams hold similar inventory: twenty admin panels, thirty payment hooks, fifty deploys, the same contracts or scaffolding. Buried in client work, it’s only cost; extracted, it’s templates, plugins, tools, or courses.

Often more realistic than inventing a greenfield idea—if you’ve already done the thing more times than peers.

7. Don’t treat “ship 20 products” as the secret

The wrong summary: ship more → one will explode.

Fail → ship → fail again mostly yields repos. Marc’s move was hunting repeated commercial assets across projects. He noticed that “shipping a product fast” might be worth more than any single consumer idea—so “shipping fast” became the product.

Don’t copy “another 2023 Next.js template for $250k.” Copy the process that produced it.

8. How to replay the case (not the SKU)

Step 1: Inventory repeated labor

List last year’s projects, e.g.:

• Project A → auth + pay + email + SEO
• Project B → auth + pay + SEO
• Project C → auth + pay + deploy
• Project D → auth + pay + i18n

Find what shows up most.

Step 2: Check others are stuck too

Search GitHub issues, Reddit, Discord, maker communities, client feedback.

Don’t ask “is there a market?”
Ask: “Is a group of people already solving this over and over?”

Step 3: Use it yourself before you sell it

Skip the “ultimate template” fantasy. Run your approach through 2–3 real projects until it clearly saves time. Best inventory is “what I kept after ten times,” not “what I think should exist.”

Step 4: Sell into your old circle

Ideal buyers aren’t strangers—they’re people who had your problem. You already know where they are, why it hurts, and what they’ll pay for.

Step 5: Turn one labor into many sales

Project experience → repeated problem → standard fix → template / tool / plugin / API / course → build once → sell repeatedly

That’s the part of Marc Lou worth copying.

Strip the code away and ShipFast is simple: sell the time and pits you already paid for to people who still need to launch fast—so past labor pays more than once.

What’s worth productizing is rarely what you invented on a whiteboard—it’s what you’ve already done many times and proven on yourself.

Product

• ShipFast