For indie hackers who ship.

Your SaaS scaffold,
done in 5 minutes.
Not 2 weeks.

One command. Auth, payments, database, email, Tailwind, Docker, CI/CD — wired together, tested, production-ready. Stop building the same foundation for the fourth time and start building the product.

Free. No account. No BS.
See what gets generated
Terminal
$npx saas-init@latest
? Auth provider: Clerk
? Payment provider: Stripe
? Database: Postgres
? Email service: Resend
? Project name: my-saas
✔ Scaffolding project...
✔ Installing dependencies...
✔ Configuring auth, payments, database, email...
✔ Running 250 tests... all passed
🚀 Done in 4m 32s. cd my-saas && pnpm dev
Next.js 14+ App RouterClerk or NextAuthStripe or Lemon SqueezyPostgres, SQLite, or Supabase250+ tests includedMIT licensed

The problem

You’ve been here before.
It still sucks.

Paid boilerplates sell you a black box.

You drop $300 on a "production-ready" boilerplate. Then you're untangling someone else's abstraction choices, their custom auth wrapper, their bespoke hook system. Every customization costs you an hour of archaeology. You didn't buy a head start. You bought a dependency.

Free OSS starters are already six months out of date.

The GitHub star count looks great. The last commit is from eight months ago. The auth library deprecated the function it relies on. The Prisma schema conflicts with the ORM version that actually installs. You spend a day just getting it to run.

Even the good ones skip the hard parts.

Auth and a landing page aren't a SaaS. The hard parts are billing — Stripe webhook handling, subscription state, upgrade/downgrade flows. Multi-tenant data isolation. Transactional email. A CI/CD pipeline that doesn't break on the first merge. Most starters stop at "here's a login page."

What you get

Everything you’d build anyway.
Already built.

Authentication

~$200 of setup time

Clerk or NextAuth pre-configured. Social logins, magic links, session handling, protected routes, middleware. You pick the provider at init time. It works on first run.

Data Layer

~$150 of setup time

Drizzle ORM with migrations ready to go. Postgres, SQLite, or Supabase — choose at init. Schema for users, accounts, and subscriptions included. Type-safe queries out of the box.

Payments + Email

~$400 of setup time

Stripe or Lemon Squeezy — full webhook handling, subscription lifecycle, billing portal integration. Resend or Postmark for transactional email. Both wired to real events, not placeholder console.log.

Infrastructure + UI

~$250 of setup time

Tailwind + shadcn/ui component library pre-installed and themed. Dockerfile for production. GitHub Actions CI/CD pipeline. 250+ tests covering auth, billing, and API routes.

Total if you built it yourself

~$1,000+ in developer-hours

What saas-init costs

$0

Free. Open source. MIT licensed. npx saas-init@latest and it’s yours.

How it compares

Why not just use ___?

Good tools. Different jobs.

create-t3-app
Great DX, locked-in stack
  • Opinionated — tRPC, specific stack baked in
  • No payments, no email, no auth wiring
  • You still build the SaaS layer yourself
saas-init is stack-agnostic — pick your auth, DB, and payments provider at init. No dead code for things you didn't choose.
create-next-app
A blank canvas
  • Bare minimum — just Next.js scaffolding
  • No auth, payments, email, or infra
  • You wire everything yourself, from scratch
saas-init adds the full SaaS layer on top — auth flow, Stripe checkout, transactional email, Docker, CI/CD — all wired up and tested.
Vercel / Supabase starters
Static clone-and-configure
  • Clone the repo, then manually configure everything
  • Templates are static — includes code for providers you won't use
  • Not designed to be regenerated or updated
saas-init generates based on your choices. Pick Clerk or NextAuth, Stripe or nothing, Postgres or SQLite — only the code you need is generated.
shadcn/ui CLI
Component-level, not app-level
  • Adds individual UI components to an existing project
  • No concept of auth, payments, or infra
  • Solves a different problem entirely
saas-init operates at the full project level — it's the scaffold your entire app is built on, not a component library on top of it.

Transformation

Here’s what changes.

Day 1

Quick Win

You run one command. You answer five questions. Five minutes later you have a running Next.js SaaS with login, billing, database migrations, email, Tailwind, Docker, and CI. You push to GitHub. The pipeline goes green. This part used to take you two weeks.

Week 1–2

Compound

You’re not debugging a Stripe webhook at 11pm. You’re writing the feature that makes your product different. The scaffolding is invisible — which is the point. Every hour you don’t spend on infrastructure is an hour you spend on product.

Month 1–3

Advantage

You ship an MVP while the person who bought the $300 boilerplate is still reading the documentation. You’re collecting feedback, iterating, closing your first paying customers. You have 250 tests. They have none.

End of Year

10x

You shipped three SaaS projects this year instead of one. One didn’t work — you killed it in week four. One is growing. One is profitable. That’s the math that only works when you stop rebuilding the same foundation.

MT
PS
DW
Joined by 1,200+ developers who stopped waiting

How many more projects are you going to delay?

You don’t need another week of setup. You need five minutes and one command. The repo is open. The code is yours. There’s nothing to lose and a week of your life to gain.

No account. No email required. MIT licensed. Works on macOS, Linux, Windows.