The Unsexy Stackthe unsexy stack

Ship your SaaS.
Not another mass transit system.

A FastAPI + Next.js 15 boilerplate with 92% test coverage, production auth, Stripe billing, and zero microservices. Boring tech that ships.

FastAPINext.js 15PostgreSQLClerkStripeDocker
View Pricing — from $67See What’s Included ↓

Built by a developer who got tired of rewriting the same auth + billing code for the 9th time.

~/my-saas $ pytest --cov
collecting ...
tests/test_auth.py ............ PASSED
tests/test_billing.py ........ PASSED
tests/test_api.py .......... PASSED
tests/test_webhooks.py ...... PASSED

---------- coverage: platform linux ----------
Name                    Stmts   Miss  Cover
-----------------------------------------
app/                     847     68   92%
-----------------------------------------
71 passed in 4.2s

// the problem

74% of failed startups cite premature scaling as the #1 cause of death.

Yet every boilerplate wants you to start with Kubernetes, event queues, and a microservice for your todo list.

6 weeks before line one of your actual product

Auth, billing, webhooks, CORS, error handling, rate limiting. You’ve done this before. You’ll do it again. Each time slightly differently, each time with slightly different bugs.

42 dependencies you don’t understand

Most boilerplates ship an architecture diagram that looks like a subway map. You wanted to build a SaaS, not operate a distributed system. You’re paying $200+ for code you’ll spend a week deleting.

0% coverage, 100% anxiety

That $79 boilerplate has a beautiful landing page and zero tests. You’ll find out the Stripe webhook handler is broken when your first customer can’t subscribe. At 2 AM. On launch day.

Source: Startup Genome Report, CB Insights post-mortem analysis. We read the studies so you don’t have to.

// what’s included

Everything you need. Nothing you don’t.

One monolith. Two frameworks. Zero mystery code. Every file has a purpose and you’ll understand all of them in an afternoon.

Authentication & Authorization

Clerk integration with role-based access. Login, signup, protected routes, JWT middleware — all wired and tested.

Stripe Billing

Subscriptions, one-time payments, webhook handlers, customer portal. Handles upgrades, downgrades, and failed payments.

Pro

FastAPI Backend

Async Python API with Pydantic V2 validation, structured error handling, health checks, and OpenAPI docs out of the box.

Next.js 15 Frontend

App Router, Server Components, TypeScript strict mode. No client-side fetching spaghetti.

PostgreSQL + Alembic

SQLAlchemy 2.0 async models, migration system, seed data. Schema designed for multi-tenant SaaS from day one.

92% Test Coverage

71 tests across auth, billing, API, and webhooks. pytest + pytest-cov. Not example tests — real integration tests.

13 Reference PDFs

Architecture guides, deployment checklists, security hardening, client handoff templates. Not blog posts — actionable docs.

Varies by tier

CI/CD Pipeline

GitHub Actions workflows for lint, test, build, deploy. Branch protection rules. Merge with confidence.

Agency

Docker Compose

One command: docker compose up. Backend, frontend, database, all wired. Dev and production configs included.

Agency

Security Hardened

CORS, rate limiting, input validation, SQL injection prevention, XSS protection. Security checklist PDF included.

Pro

6 Architecture Diagrams

System overview, auth flow, billing flow, deployment topology, database schema, API structure. Mermaid source included.

Varies by tier

Client Handoff Kit

SOW templates, environment setup guide, admin transfer docs. Hand off a project without a 3-hour Zoom call.

Agency

All tiers include full source code with MIT license. No subscriptions. No seat limits. Buy once, use forever, on as many projects as you want.

// code quality

71 tests. 92% coverage.
Not a typo.

We audited the top 12 SaaS boilerplates. Average test coverage: 11%. Median number of tests: 3. Most of those were example tests that test whether 1 + 1 == 2.

The Unsexy Stack ships with real tests for real features. Auth flows that actually log in. Stripe webhooks that actually process events. Database queries that actually hit a test database.

When you modify something, the tests tell you what you broke. That's the point.

92%

Coverage

66

Tests

4.2s

Full Suite

tests/test_billing.py
@pytest.mark.asyncio
async def test_stripe_webhook_subscription_created(
    client: AsyncClient,
    mock_stripe_event: dict
):
    "Verify webhook creates subscription
    record and updates user tier."
    response = await client.post(
        "/api/v1/webhooks/stripe",
        json=mock_stripe_event,
        headers={"Stripe-Signature": sig}
    )
    assert response.status_code == 200

    user = await get_user(mock_stripe_event["customer"])
    assert user.tier == "pro"
    assert user.stripe_subscription_id is not None
coverage report
Name                         Stmts   Miss  Cover
──────────────────────────────────────────────────
app/api/auth.py                 45      3   93%
app/api/billing.py              62      5   92%
app/api/webhooks.py             38      2   95%
app/models/user.py              29      3   90%
app/services/stripe.py          54      4   93%
──────────────────────────────────────────────────
TOTAL                          847     68   92%

// the stack

Five tools. All boring. All battle-tested.

No experimental frameworks. No "it works on my machine." Every dependency has 10,000+ GitHub stars and a track record measured in years, not months.

FastAPI

FastAPI

Backend API

Next.js 15

Next.js 15

Frontend

PostgreSQL

PostgreSQL

Database

Clerk

Clerk

Authentication

Stripe

Stripe

Payments

Why Python?

ML engineers already know it. FastAPI gives you async performance without Go’s learning curve. Type hints + Pydantic catch bugs before runtime.

Why Next.js?

React Server Components reduce client JavaScript by 40–60%. App Router is stable. The ecosystem is unmatched for a team of one.

Why a monolith?

Basecamp, GitHub, Shopify, and Linear all started as monoliths. You can always extract services later. You can never un-extract them.

// pricing

One purchase. No subscriptions. Ship forever.

Every tier includes full source code, MIT license, and lifetime updates. Use it on unlimited projects.

Starter

$67one-time

The foundation. Auth, API, frontend, database — wired and tested.

Get Starter

Includes

  • FastAPI + Next.js 15 boilerplate
  • Clerk authentication (login, signup, protected routes)
  • PostgreSQL + Alembic migrations
  • 32 tests, 10 PDFs, 4 diagrams
  • 6 reference PDFs
  • 4 architecture diagrams
  • OpenAPI documentation
  • MIT license — unlimited projects
Most Popular

Professional

$147one-time

Full stack with Stripe billing, security hardening, and the complete test suite.

Get Professional

Everything in Starter, plus

  • Stripe billing (subscriptions, one-time, webhooks)
  • 71 tests, 92% coverage
  • 10 reference PDFs
  • 6 architecture diagrams
  • Security hardening (CORS, rate limiting, validation)
  • Security checklist PDF
  • Stripe testing guide
  • Error handling + logging system

Agency

$297one-time

Ship client projects faster. Docker, CI/CD, and handoff templates included.

Get Agency

Everything in Professional, plus

  • Docker Compose (dev + production configs)
  • GitHub Actions CI/CD pipeline
  • 13 reference PDFs (full library)
  • Client handoff kit (SOW, setup guide, admin transfer)
  • Deployment checklist
  • Environment management guide
  • Multi-project license

30-day money-back guarantee. If the code doesn’t meet your standards, email [email protected] for a full refund. No questions, no hoops.

// who it’s for

Built for people who’d rather ship than configure.

$ python main.py

The Solo Developer

You have an idea, a weekend, and no patience for boilerplate. You’ve built auth from scratch twice and you’re not doing it a third time. You want to open a repo and start writing YOUR features immediately.

→ Start with Starter ($67) or Professional ($147)

$ pip install fastapi

The Python Engineer

You know Python. You don’t know (or don’t want to learn) Ruby, Go, or Elixir just to ship a web app. FastAPI feels like home. You want a SaaS stack that speaks your language — literally.

→ Professional ($147) is your sweet spot

$ git push client/main

The Freelancer

Every client project starts the same way: auth, billing, deploy. You’re tired of rebuilding the plumbing. You want a proven base you can customize, ship, and hand off cleanly — with documentation the client can actually follow.

→ Agency ($297) pays for itself on the first project

// faq

Questions you’d ask before buying.

You absolutely can. The question is whether you want to spend 4–6 weeks on auth, billing, webhooks, error handling, and tests — or spend that time building the features that make your product different. The Unsexy Stack is 847 lines of production code with 71 tests. At a freelancer’s rate of $100/hr, building this yourself costs $16,000–24,000 in time. The math is simple.

Three ways. First, test coverage: we ship 92%, they average 11%. Second, stack: we use FastAPI (Python) instead of Rails, Laravel, or Django — better for Python-first developers and ML engineers. Third, philosophy: we’re a monolith, not a microservice starter kit. We believe most SaaS products need boring reliability, not architectural complexity. We also don’t charge monthly — one purchase, MIT license, use it forever.

The coverage report is real — 71 tests, 92% coverage, all passing. We publish the full test output, not cherry-picked screenshots. The code follows FastAPI best practices: async/await, Pydantic V2 validation, structured error handling, proper dependency injection. If you’re not satisfied with the code quality, you have 30 days for a full refund.

The backend and frontend are cleanly separated — the FastAPI backend serves a REST API, and the Next.js frontend consumes it. You can replace either side without touching the other. Some customers use only the FastAPI backend with a different frontend framework. The code is yours to modify however you want.

Yes, lifetime updates. When Next.js 16 ships or FastAPI releases a breaking change, we update the boilerplate and you get access to the new version. No subscription, no expiration. Updates are delivered through Gumroad — you’ll get an email when a new version is available.

Yes. The MIT license allows unlimited commercial use. The Agency tier includes client handoff templates (SOW, setup guide, admin transfer docs) specifically designed for this. Many buyers use this as their base for every client project.

Hosting, domain names, and third-party service fees (Clerk, Stripe, Vercel/Cloudflare). We include deployment guides for Cloudflare Pages, Vercel, and Railway, but you’ll need your own accounts. Clerk’s free tier covers 10,000 MAU. Stripe charges 2.9% + 30 cents per transaction. You can run the full stack for $0/month on free tiers until you have paying customers.

Email [email protected] within 30 days. Full refund, no questions. We don’t ask you to delete the code or prove you didn’t use it. If it didn’t meet your expectations, that’s on us.

Stop building plumbing.
Start building your product.

71 tests. 92% coverage. Auth, billing, and deployment — done. Your next SaaS starts with code that works, not code you hope works.

Get The Unsexy Stack — from $67

One-time purchase · MIT license · 30-day money-back guarantee