Monorepo SaaS Starters 2026: Which to Pick

The monorepo has moved from enterprise concern to indie hacker default. When your SaaS needs a marketing site, a dashboard app, an API server, and shared component packages, a monorepo stops being premature optimization and starts being the obvious architecture. Three starters dominate this space: next-forge, create-t3-turbo, and bare Turborepo templates. They're built for different builders with different assumptions.

This is a three-way comparison. For a deep review of next-forge specifically, see our next-forge review. Here, we're comparing the full field to answer one question: which monorepo starter should you clone?

Quick Reference

	next-forge	create-t3-turbo	Turborepo (bare)
Apps	6 (web, app, api, docs, email, storybook)	2 (Next.js web + Expo mobile)	1–2 (bare)
Shared packages	16+	~8	2–3
Auth	Clerk	NextAuth / Better Auth	DIY
Billing	Stripe	None	DIY
Database	Neon + Prisma	Prisma / Drizzle	DIY
Email	Resend	None	DIY
Analytics	PostHog	None	DIY
Error tracking	Sentry	None	DIY
Mobile app	❌	✅ Expo	❌
Type safety	High	Very high (tRPC)	DIY
Price	Free (MIT)	Free (MIT)	Free
Setup time	30 min	1–2 hours	30 min + weeks
Stars	7,000+	4,000+	N/A

next-forge — The Opinionated All-in-One

next-forge is a Turborepo monorepo maintained by Hayden Bleasel and backed by Vercel. It's the most ambitious free SaaS starter in 2026 — six independently deployable Next.js apps sharing 16+ packages, with every third-party integration pre-wired.

What You Get

Six apps:

1. apps/web — Marketing site (Next.js, shadcn/ui, Fumadocs)
2. apps/app — Dashboard/user-facing app (Next.js, Clerk auth)
3. apps/api — Separate API server (Hono or Next.js)
4. apps/docs — Documentation site (Fumadocs)
5. apps/email — Email preview and development (React Email)
6. apps/storybook — Component library and design system

Sixteen+ packages:

• @repo/auth — Clerk auth configured
• @repo/database — Prisma + Neon
• @repo/email — React Email + Resend
• @repo/analytics — PostHog
• @repo/billing — Stripe
• @repo/observability — Sentry + Vercel Analytics
• @repo/feature-flags — PostHog feature flags
• @repo/ui — shadcn/ui component library, shared across apps
• @repo/design-system — Tailwind config, fonts, themes
• Plus TypeScript, ESLint, and config packages

Setup

npx next-forge@latest init my-saas
cd my-saas

That's it. After init, you configure API keys (Clerk, Neon, Stripe, Resend, PostHog, Sentry) in .env.local files and run pnpm dev. The first run builds all apps simultaneously via Turborepo's task graph.

The Opinionation Trade-off

next-forge is opinionated in the best way for getting started fast, and the worst way if your choices differ. Specifically:

• Clerk is baked in. Switching to Better Auth or NextAuth means rewriting @repo/auth and every place auth() is called across six apps. This is real work.
• Neon is the database. If you want Supabase or PlanetScale, you reconfigure @repo/database.
• Vercel-optimized. next-forge assumes Vercel deployment. Deploying to Coolify requires work to handle the multi-app architecture.

If you're comfortable with Clerk, Neon, and Stripe, next-forge is the fastest path from zero to production-grade monorepo SaaS.

Activity and Maintenance

7,000+ GitHub stars, commits weekly, open issues triaged actively. Hayden Bleasel is a visible maintainer who ships changelog posts. One of the better-maintained free starters in any category.

---

create-t3-turbo — T3 Stack in a Monorepo

create-t3-turbo (often called "T3 Turbo") is the monorepo variant of the T3 stack. Where T3 is a single Next.js app with tRPC, Prisma/Drizzle, NextAuth, and TypeScript, T3 Turbo extends this into a monorepo with shared packages consumed by both a Next.js web app and an Expo mobile app.

The purpose is specifically about web + mobile code sharing, not about the multi-app SaaS architecture next-forge targets.

What You Get

Two main apps:

1. apps/nextjs — Next.js web application
2. apps/expo — React Native mobile app

Shared packages:

• @acme/api — tRPC router shared between web and mobile
• @acme/auth — NextAuth / Better Auth configuration
• @acme/db — Prisma/Drizzle schema
• @acme/validators — Zod schemas shared between client and server
• @acme/ui — Shared React components (web-only, not native)

Setup

npx create-t3-turbo@latest

The CLI asks if you want NextAuth or Better Auth, Prisma or Drizzle. You get a working Next.js + Expo project sharing tRPC types and the database schema.

The Star Feature: Full Type Safety Across Web and Mobile

The key insight of T3 Turbo is that when you define a tRPC procedure:

// packages/api/src/router/post.ts
export const postRouter = createTRPCRouter({
  list: protectedProcedure.query(({ ctx }) => {
    return ctx.db.post.findMany({ where: { userId: ctx.session.user.id } });
  }),
  create: protectedProcedure
    .input(z.object({ title: z.string().min(1) }))
    .mutation(({ ctx, input }) => {
      return ctx.db.post.create({ data: { title: input.title, userId: ctx.session.user.id } });
    }),
});

Both apps/nextjs and apps/expo consume this with full type safety:

// Identical call in both Next.js and React Native
const { data } = api.post.list.useQuery();
await api.post.create.mutateAsync({ title: "Hello" });

Change the procedure once, TypeScript catches every broken callsite across both apps simultaneously.

What T3 Turbo Doesn't Include

No billing. No email. No analytics. No marketing site. No admin panel. T3 Turbo is deliberately lean — it gives you the architecture and shared-code infrastructure, and you add application features yourself. This is a feature for developers who want to understand what they're building; it's a limitation if you want a batteries-included SaaS foundation.

Activity and Maintenance

4,000+ stars, community-maintained, active PRs. The T3 ecosystem (created by Theo Browne) has strong community support. Main maintainer Julius Marminge keeps the repo current with Next.js and Expo updates.

---

Turborepo Bare Templates — The Foundation Layer

Turborepo itself (the build system) comes with official starter templates that provide the monorepo plumbing without opinionated app code.

Available Templates

Basic Next.js + TypeScript:

npx create-turbo@latest
# Select: Next.js (Tailwind + shadcn/ui)

Gets you a monorepo with one Next.js app and a shared packages/ui and packages/utils. Minimal. No auth, no billing, nothing SaaS-specific. This is the foundation you build on.

Vercel Monorepo Template: The vercel/monorepo-turborepo template on Vercel's template marketplace extends the basic setup with two Next.js apps (web and docs), demonstrating how to configure multiple Vercel project deployments from one repo.

When to Start Bare

The bare Turborepo approach makes sense when:

• You want to understand every line in your repo
• Your stack diverges significantly from next-forge or T3 Turbo
• You're building something that doesn't fit the "SaaS dashboard + marketing site" pattern
• You have strong opinions about specific tool choices that neither starter accommodates

The cost: you're building your own packages from scratch. @repo/auth, @repo/billing, @repo/email — all of it. next-forge solves this by giving you 16 working packages. With bare Turborepo, you write them. Budget several weeks.

---

Decision Guide

Pick next-forge if...

You want to ship a SaaS product with a marketing site, dashboard, and API server as fast as possible. You're comfortable with Clerk, Stripe, Neon, and Vercel (or willing to migrate those integrations). You want a maintained, production-quality reference for what a 2026 SaaS monorepo should look like. You don't need a mobile app.

When it works best: Solo founders and small teams building standard SaaS products who want to copy the best practices and fill in business logic.

Pick create-t3-turbo if...

You're building a product that needs both a web app and a React Native mobile app and you want to share API types, database schema, and auth between them. You're already in the T3 ecosystem and love tRPC + Drizzle/Prisma. You're comfortable adding billing and email yourself.

When it works best: Mobile+web products where code sharing across platforms is the primary architectural concern.

Pick bare Turborepo if...

You have strong tech stack opinions that differ from next-forge (you want Better Auth instead of Clerk, Supabase instead of Neon, Polar instead of Stripe) AND you're willing to spend 2–4 weeks building your shared packages. Or you're an experienced engineer who wants full control over every dependency.

When it works best: Senior engineers at companies with specific tech requirements, or developers building non-standard products that don't fit the SaaS dashboard mold.

---

Stack Comparison in Practice

Here's what a typical feature looks like across all three:

Fetching protected data for the dashboard:

// next-forge: Direct Prisma call in Next.js Server Component
// apps/app/app/dashboard/page.tsx
import { auth } from "@clerk/nextjs/server";
import { database } from "@repo/database";

export default async function Dashboard() {
  const { userId } = await auth();
  const projects = await database.project.findMany({ where: { userId } });
  return <ProjectList projects={projects} />;
}

// create-t3-turbo: tRPC call (same code in web + mobile)
// packages/api/src/router/project.ts
export const projectRouter = createTRPCRouter({
  list: protectedProcedure.query(({ ctx }) => {
    return ctx.db.project.findMany({ where: { userId: ctx.session.user.id } });
  }),
});
// apps/nextjs/app/dashboard/page.tsx
const projects = await api.project.list();

// Turborepo bare: You implement both patterns from scratch

The tRPC approach in T3 Turbo adds a layer of abstraction that's essential for mobile sharing but unnecessary overhead for web-only SaaS. The Server Component pattern in next-forge is simpler for web-only and aligns with Next.js best practices.

---

Maintenance Activity (March 2026)

Starter	Last commit	Open issues	Stars	Velocity
next-forge	This week	~40	7,000+	Active
create-t3-turbo	This month	~25	4,000+	Active
Turborepo (official)	This week	Tracked in main repo	25,000+	Very active

All three are actively maintained. next-forge gets the most frequent feature updates. Turborepo core is maintained by Vercel (enterprise resources, fast iteration).

---

Summary

next-forge is the most ambitious and most batteries-included — if its stack matches your needs, it's the fastest path to a production monorepo SaaS. create-t3-turbo wins if you need web + mobile code sharing with the T3 pattern. Bare Turborepo is for teams who know exactly what they want and are willing to build the shared packages layer from scratch.

For more context on the monorepo vs single-repo decision, see monorepo vs single repo for SaaS boilerplates. For next-forge specifically, the next-forge deep-dive review covers every package and app in detail.