SaaS Skeleton

Production-ready Django + React SaaS starter

Skip the SaaS boilerplate. Ship your product.

SaaS Skeleton is a complete, tested codebase with passwordless authentication, multi-tenant workspaces, roles and permissions, team invitations and per-seat Stripe billing already wired together — so you spend your time on the product only you can build.

Try before you buyBuy the source code

Log in to the live application and explore every feature before purchasing the source.

  • Passwordless email codes + Google OAuth
  • Multi-tenant workspaces & invitations
  • Per-seat Stripe subscriptions
  • Role- and plan-based permissions

What's included

The first two months of every SaaS project, already done

Every feature below is implemented, tested and running in the demo — not a roadmap item. Log in and verify each one yourself.

Passwordless authentication

Email one-time codes with expiry and attempt limits, Google OAuth sign-in, and JWT sessions with automatic refresh.

Multi-tenant workspaces

Every account gets isolated workspaces with a switcher, settings, ownership rules and safe deletion guards.

Roles & permissions

Two-layer access control: workspace roles backed by Django groups, plus subscription-plan entitlements that gate features by plan.

Team invitations

Email invites with expiring tokens, a public accept flow, and seat-aware capacity checks before anyone joins.

Per-seat Stripe billing

Subscriptions with explicit seat counts, monthly and yearly prices, plan upgrades and downgrades with proration previews, cancel and resume.

Payment methods & invoices

Stripe Elements card management, default payment method, upcoming invoice preview and customer tax handling.

Transactional email

Themed HTML emails for sign-in codes and invitations. Console backend in development, SMTP-ready for production.

Internationalization

Full i18next setup with two languages shipped, plus locale-aware date and currency formatting throughout.

Drop-in runtime theming

Add one CSS file to styles/themes and it automatically appears in the user's theme picker — light and dark included.

API guardrails

Django REST Framework with JWT auth, per-scope rate limiting, pagination, filtering, consistent error handling and Swagger docs.

One-command dev stack

make start boots PostgreSQL 16, applies migrations, seeds a superuser and the Stripe catalog, and forwards webhooks locally.

Demo domain module

A complete todo CRUD with list views, filters, permissions and tests — a working template for your own features.

Product tour

The hard parts, handled properly

Auth, tenancy and billing are where SaaS projects stall. Here they are finished — edge cases included.

Authentication your users won't fight

No passwords to store, reset or leak. Users sign in with a short-lived email code or their Google account, and stay signed in with refresh-token JWT sessions.

  • One-time email codes with configurable length, expiry and attempt limits
  • Google OAuth with automatic account creation and profile sync
  • JWT access tokens with 7-day refresh sessions via SimpleJWT
  • Rate-limited endpoints and consistent API error handling out of the box

Multi-tenant from the first commit

Tenancy is not something you can bolt on later. Workspaces, memberships, custom roles and invitations are modeled in the database and enforced at the API layer from day one.

  • Isolated workspaces with a switcher, settings page and ownership guards
  • Custom roles backed by Django groups — create, rename and edit per workspace
  • Two-layer checks — role permissions plus subscription-plan entitlements gate every action
  • Email invitations with expiring tokens and seat-capacity enforcement

Per-seat billing that already handles the edge cases

Real Stripe subscriptions with explicit purchased seats — not a placeholder pricing page. Proration previews, plan changes, seat updates, cancellation and webhooks are all implemented and tested.

  • Seat-based subscriptions with monthly and yearly prices per plan
  • Upgrade, downgrade and seat changes with exact proration previews before confirming
  • Cancel, resume, incomplete-subscription expiry and upcoming invoice preview
  • Stripe webhooks, catalog seeding and customer tax handling included

Developer experience

From clone to your first feature in one sitting

The entire stack runs in Docker — no local Python or Node required. One command boots the database, applies migrations, seeds Stripe and starts the app.

  1. Step 1

    Clone the repository

    Get the full Django + React codebase with Docker Compose, Makefile and documentation for every subsystem.

  2. Step 2

    Configure your environment

    Copy the .env examples and add your Stripe test keys. Branding, app name and Google OAuth are simple env variables.

  3. Step 3

    Run "make start"

    PostgreSQL, migrations, a dev superuser, Stripe catalog seeding and local webhook forwarding — all from a single command.

  4. Step 4

    Build your product

    Replace the demo todo module with your own domain logic. Auth, tenancy, billing and permissions are already there.

terminal
$ git clone git@github.com:you/your-saas.git && cd your-saas
$ cp server/.env.example server/.env
$ cp client/.env.example client/.env
# add your Stripe test keys — that is the only required edit
$ make start
✔ postgres 16 up · migrations applied · superuser created
✔ stripe catalog seeded (Basic / Pro / Enterprise)
✔ webhook forwarding running · app on http://localhost:5173
project structure
├── Makefile            # start, stop, migrate, stripe-webhooks
├── docker-compose.yml  # full local stack
├── client/             # React 19 + Vite + Tailwind 4
│   ├── src/pages/      # landing, auth, billing, workspaces
│   └── src/styles/themes/  # drop-in theme CSS files
└── server/             # Django 5 + DRF
    ├── users/          # OTP auth, Google OAuth, profiles
    ├── workspaces/     # tenancy, roles, invitations
    ├── billing/        # Stripe seats, webhooks, catalog
    └── todo/           # demo module — replace with your product

Try a theme

Live on this page

twitter.css
/* client/src/styles/themes/twitter.css */
:root {
  --primary: #1e9df1;
  --background: #ffffff;
  --radius: 0.8rem;
  /* …all tokens: colors, fonts, shadows */
}
.dark {
  --background: #0b0a12;
  /* dark variant of every token */
}

White-label ready

Rebrand the entire app with one CSS file

Themes are plain CSS variable files discovered at build time. Drop a new file into styles/themes and it instantly becomes a selectable option in every user's theme picker.

  • Drop-in themes

    Any CSS file added to styles/themes is auto-registered — no code changes, no imports, no configuration.

  • Design tokens everywhere

    Colors, fonts, radii and shadows are all CSS variables. The whole UI — including this landing page — follows the active theme.

  • Light and dark built in

    Each theme ships light and dark variants, and users switch instantly with the built-in theme toggle.

Technology

A boring, proven stack — on purpose

No exotic frameworks to learn. Mainstream, well-documented technologies your team already knows and can hire for.

Django 5 + DRF

Battle-tested backend with DRF, SimpleJWT and Swagger docs

React 19 + Vite

Modern SPA with fast hot-reload development

Tailwind CSS 4

Utility-first styling with CSS-variable theming

PostgreSQL 16

Runs in Docker with persistent volumes

Stripe

Subscriptions, seats, webhooks and Elements

Docker Compose

Full local stack — no local Python or Node needed

JWT (SimpleJWT)

Access + refresh token sessions

i18next

Two languages shipped, easy to add more

Build vs. buy

What building this yourself actually costs

Conservative estimates for one experienced full-stack developer implementing and testing each subsystem from scratch.

Subsystem
From scratch
SaaS Skeleton
Passwordless auth, OAuth & JWT sessions
1–2 weeks
Included
Multi-tenant workspaces, roles & permissions
2–3 weeks
Included
Invitations & seat-aware member management
1 week
Included
Per-seat Stripe billing with proration & webhooks
3–4 weeks
Included
Transactional emails, theming & i18n
1–2 weeks
Included
Docker stack, seeding & developer tooling
3–5 days
Included
Time before you write your first product feature
2–3 months
Day one

Start where most SaaS projects end up after two months

Explore the full application with a live account — sign in, create a workspace, invite members, run a test subscription. When you're convinced, buy the source and make it yours.

Try before you buyBuy the source code

No credit card required to try. Purchasing gives you the complete source code.