Introducing the MakerKit TanStack Start SaaS Starter Kit

The MakerKit TanStack Start SaaS starter kit is out today. It ships in three variants, Drizzle, Prisma, and Supabase, all available right now. This is the same production feature set we've been shipping for years, moved onto TanStack Start.

TL;DR

What it is: a production SaaS starter kit built on TanStack Start (Vite + Nitro), TanStack Router, and TanStack Query.
Three variants, all shipping today: Drizzle, Prisma, and Supabase. Drizzle and Prisma share one architecture and differ only in packages/database; Supabase is a deeper swap — Supabase Auth instead of Better Auth, RLS-enforced authorization instead of @kit/rbac, and feature code under packages/features instead of separate @kit/organization-core/@kit/rbac/@kit/admin packages.
Stack: TanStack Start, React 19, TypeScript 7 (Go-ported compiler), Tailwind 4, Base UI, Postgres, with Better Auth on the Drizzle/Prisma variants and Supabase Auth (RLS-enforced) on the Supabase variant.
Dev tooling: oxlint and oxfmt (Oxc, Rust-based) for lint and format, TypeScript 7's native compiler for type checking — fast enough for tight human and AI-agent feedback loops.
Built for AI coding agents: AGENTS.md files at the root and in every package, a bundled MCP server, and full documentation shipped in the repo, so Claude Code, Cursor, and other agents have the context to build features correctly on the first try.
Included: auth, billing, teams/organizations, RBAC, super admin, storage, transactional emails, i18n, analytics, monitoring, CMS (blog and docs).
Deploy anywhere: Nitro outputs for Node, Vercel, and Cloudflare. No framework lock-in.
Start here: TanStack Start landing page or the Drizzle docs / Prisma docs / Supabase docs.

What we shipped

A full SaaS foundation on TanStack Start. Not a demo, not a starter that stops at the login page. The web app in apps/web runs on vite dev and uses TanStack Router's file-based routing.

Three variants ship at the same time:

TanStack Start + Drizzle (docs) — Better Auth, workspace packages including @kit/auth, @kit/organization-core, @kit/rbac, @kit/admin
TanStack Start + Prisma (docs) — same architecture as Drizzle, only packages/database changes
TanStack Start + Supabase (docs) — Supabase Postgres, Supabase Auth, and RLS-enforced authorization via @kit/supabase

Same feature set, same quality bar, across all three. Drizzle and Prisma are architecturally identical, differing only in one package. Supabase is a deeper swap — different auth, different authorization model, different package layout. More on both below.

Why we built it

We already ship a production SaaS kit on Next.js. We built the TanStack Start version because a real slice of developers want a different set of tradeoffs, and TanStack Start hit the point where those tradeoffs are worth taking to production. The reasoning here is the same one we laid out in our TanStack Start vs Next.js comparison.

Vite dev and build speed. TanStack Start runs on Vite. Cold starts and hot module replacement are fast, and the build stays fast as the app grows. If you've felt an App Router project get sluggish in dev, this is the contrast you're looking for.

End-to-end type-safe routing. TanStack Router is file-based and fully typed. Route params, search params, and loader data are all inferred. A wrong link is a type error at build time, not a 404 you find in production. This is a genuinely different experience from string-based route helpers.

Server functions. You write server logic as typed server functions and call them from the client with full inference across the boundary. No hand-written fetch layer, no drift between the two sides.

TanStack Query as a first-class data layer. Query is wired in, not bolted on. Caching, invalidation, and mutations are the data model, not an afterthought.

Deploy anywhere, no lock-in. TanStack Start builds through Nitro, so the same app targets a Node server, Vercel, or Cloudflare from one codebase. You're not tied to a single host. If your infra story is "our own VPS" or "Cloudflare," this kit fits without workarounds.

Cutting-edge dev tooling. Linting runs on oxlint, formatting on oxfmt, both part of the Rust-based Oxc toolchain, and type checking runs on TypeScript 7, the Go-ported native compiler, instead of the JS-based tsc. All three are an order of magnitude faster than the ESLint/Prettier/tsc stack most kits still ship. pnpm run healthcheck chains lint, format, and typecheck into one command, which is exactly the fast, deterministic feedback loop an AI coding agent needs to verify its own changes before handing them back to you, not just a nicer local dev experience.

Built for AI coding agents. Every package ships an AGENTS.md (root plus one per package: packages/database, packages/ui, apps/web, and the rest), with CLAUDE.md and GEMINI.md pointing at the same file so Claude Code, Cursor, Windsurf, and Gemini CLI all read one source of truth. A bundled MCP server (tooling/mcp-server, wired up in .mcp.json) exposes Makerkit-specific tools directly to your agent, and the full docs ship in the repo under docs/, not just on the marketing site. Point an agent at the codebase and it has the architecture, conventions, and package boundaries in context before it writes a line.

If you're new to the framework itself, our What is TanStack Start post is the primer.

What's included

Everything you need to charge money on day one, grounded in the actual packages that ship.

Auth, teams, and permissions

On the Drizzle and Prisma variants, authentication runs on Better Auth through @kit/auth and @kit/better-auth: sign up, sign in, password reset, email verification, and 2FA/OTP. Multi-tenancy lives in @kit/organization-core, covering personal accounts, organizations, member invites, and workspace switching. On top of that, @kit/rbac adds role-based access control with per-tenant roles, so your customers define their own permissions.

On the Supabase variant, the same capabilities run on Supabase Auth through @kit/supabase, with authorization enforced by Postgres Row Level Security. Multi-tenancy, member invites, and roles live under packages/features (accounts, team-accounts), and role/permission gates use withMinRole and withFeaturePermission from @kit/function-middleware. Same outcome, different foundation.

Billing and admin

Billing runs through @kit/billing-ui (or the equivalent feature package on Supabase) and the billing config package: subscriptions and a customer portal, so you can monetize on launch day. The super admin panel lets you manage users and organizations and impersonate accounts for debugging, on every variant.

Everything else, already wired

The supporting infrastructure ships done: file uploads on S3-compatible providers (@kit/storage, or Supabase Storage on the Supabase variant), provider-agnostic transactional email (@kit/mailers), internationalization (@kit/i18n), analytics and monitoring (@kit/analytics, @kit/monitoring), and a marketing site, blog, and docs backed by the CMS (@kit/cms).

Drizzle and Prisma: same kit, one different package

Drizzle and Prisma are architecturally identical. Auth, billing, teams, RBAC, admin, routing, UI: all the same. The ORM lives entirely in packages/database, and that's the only thing that changes between them.

The Drizzle variant depends on drizzle-orm and postgres and uses drizzle-kit for migrations and studio.
The Prisma variant depends on @prisma/client and the Prisma Postgres adapter, and uses the Prisma CLI for migrations and Prisma Studio.

Concretely, the only diff is the packages/database dependencies:

// packages/database — Drizzle variant
"dependencies": {
  "drizzle-orm": "...",
  "postgres": "...",
  "drizzle-kit": "..."
}
// packages/database — Prisma variant
"dependencies": {
  "@prisma/client": "...",
  "@prisma/adapter-pg": "...",
  "prisma": "..."
}

Pick based on how you like to work with your database, not on which features you get, because the feature set is the same either way. Prisma 7 is pure TypeScript now, so both variants deploy cleanly to Nitro's serverless and edge targets. If you want the full breakdown, footprint numbers included, read TanStack Start: Drizzle vs Prisma. MakerKit defaults to Drizzle for the TanStack Start kit, with the Prisma variant as a drop-in alternative.

Supabase: the same kit on Supabase Auth and RLS

The Supabase variant is a deeper swap than an ORM choice. In place of packages/database and Better Auth, it ships packages/supabase (Supabase clients, generated types) and authenticates through Supabase Auth, with authorization enforced by Postgres Row Level Security instead of application-level checks. Feature code is organized under packages/features (accounts, admin, auth, notifications, team-accounts) rather than the separate @kit/organization-core / @kit/rbac / @kit/admin packages the Drizzle and Prisma variants use.

If you're already running Supabase, or you want RLS as your authorization layer instead of Better Auth's application-level model, this is the variant to reach for. It's the natural home for teams migrating off our Next.js + Supabase kit who want TanStack Start's routing and Vite's dev speed without leaving Supabase.

Getting started

Choose your variant and follow the installation guide:

The kit uses a Turborepo monorepo with pnpm. Drizzle and Prisma use Docker for local Postgres; Supabase uses the Supabase CLI for local Postgres, Auth, and Storage. pnpm dev starts the app; the docs walk you through environment setup, the database, and your first deploy.

Want the full pitch and screenshots first? See the TanStack Start SaaS starter kit landing page.

For deeper dives, read TanStack Start vs Next.js, Drizzle or Prisma on TanStack Start, and the What is TanStack Start primer.

Frequently Asked Questions

Are all three variants available now?

Yes. Drizzle, Prisma, and Supabase all ship today. None of them are 'coming soon.'

Which one should I choose?

All three give you the same feature set. Choose Drizzle if you want SQL-style control, the smallest footprint, and no generate step; choose Prisma if you prefer schema-first modeling and Prisma Studio; choose Supabase if you want Supabase Postgres, Supabase Auth, and RLS-based authorization, or you're already on Supabase.

What's the difference between the Supabase variant and Drizzle/Prisma?

Drizzle and Prisma are architecturally identical and use Better Auth; they differ only in packages/database. The Supabase variant is a deeper swap: it uses Supabase Auth instead of Better Auth, enforces authorization with Postgres Row Level Security, and organizes feature code under packages/features instead of separate auth/rbac/admin packages.

Where can I deploy it?

Anywhere Nitro targets: a Node server, Vercel, or Cloudflare, from the same codebase.

How is this different from the Next.js kit?

Same feature set, on a different framework. TanStack Start gives you Vite speed, type-safe routing, and deploy-anywhere output.

Do I need to know TanStack Start already?

No. Start with the What is TanStack Start primer, then follow the installation docs.

Ready to build? Get started with the TanStack Start kit.