next-forge: The Monorepo SaaS Starter That Changes Everything 2026

Q: What Turborepo Gives You?

Parallel execution: turbo dev starts all six apps in parallel. turbo build builds only apps affected by changed files. Remote caching: If you've built packages/design-system and the source hasn't changed, Turborepo serves the cached build output. CI goes from 8 minutes to 45 seconds for unchanged packages. Dependency graph awareness: turbo typecheck knows to run packages/database typechecks before apps/app typechecks that depend on it.

Most SaaS starters give you a single Next.js app. next-forge gives you a production monorepo — a complete, multi-app architecture with a marketing site, dashboard app, API server, documentation site, email system, and Storybook instance, all wired together with Turborepo. It's free, open source, and backed by Vercel.

If you've been putting off a monorepo structure because of setup complexity, next-forge removes that excuse entirely.

TL;DR

next-forge is the most complete free SaaS starter in 2026. Where most boilerplates give you auth + Stripe in a single app, next-forge gives you the full production architecture: six independently deployable apps sharing 16+ packages, with Clerk, Stripe, Neon, PostHog, Sentry, and Resend already integrated. npx next-forge@latest init gets you running in minutes. The tradeoff: monorepo complexity means a steeper learning curve than single-app starters.

Key Takeaways

Free and open source forever — backed by Vercel, MIT license, no licensing fees or per-seat costs
6 deployable apps in one repo — web (marketing), app (dashboard), api, docs, email, storybook
16+ pre-integrated packages — Clerk auth, Stripe billing, Neon database, Resend email, PostHog analytics, Sentry error tracking
Turborepo for task orchestration — parallel builds, remote caching, task dependency graph
7,000+ GitHub stars — active maintainer (Hayden Bleasel), regular updates, strong community
One-command init — npx next-forge@latest init scaffolds the entire monorepo

What Is next-forge?

next-forge started as Hayden Bleasel's personal SaaS boilerplate — the infrastructure he used to ship his own products quickly. Vercel formally adopted it as a template, and it's now the production pattern Vercel recommends for serious Next.js SaaS applications.

The philosophy is different from other starters. Rather than a "minimal starting point you customize," next-forge is an opinionated, production-ready architecture you deploy and start building on top of. Every integration decision is already made.

npx next-forge@latest init my-saas

That single command scaffolds a complete Turborepo monorepo with all six apps, all packages, and all integrations pre-wired. Clone-to-running-app time: under 15 minutes if you have the required accounts ready.

The Monorepo Architecture

Six Apps, One Repo

apps/
├── web/        ← Marketing website (Next.js, landing page, blog, docs)
├── app/        ← Main SaaS application (dashboard, user features)
├── api/        ← API server (background jobs, webhooks, non-edge logic)
├── docs/       ← Documentation site
├── email/      ← React Email templates (Resend integration)
└── storybook/  ← Component library and design system

Each app deploys independently to Vercel. The web app hosts your marketing site and blog. The app handles everything behind login. The api runs jobs and webhook handlers that need persistent connections (which serverless functions can't maintain).

This separation matters architecturally:

Marketing site can be cached aggressively, updated independently
Dashboard app has its own deployment pipeline with feature flags
API server handles Stripe webhooks, background processing, and anything that needs >10 second execution time
Email app means email templates are version-controlled alongside the codebase, not in a third-party editor

16+ Shared Packages

packages/
├── design-system/   ← shadcn/ui components, shared across all apps
├── database/        ← Prisma schema, client, migrations
├── auth/            ← Clerk auth configuration
├── analytics/       ← PostHog client configuration
├── observability/   ← Sentry and logging setup
├── notifications/   ← Knock in-app notifications
├── feature-flags/   ← Feature flag configuration
├── email/           ← React Email templates
└── ...

Shared packages mean your design system is consistent across the marketing site and dashboard. Database schema changes propagate to every app. Auth logic is defined once, not duplicated.

Pre-Integrated Stack (2026)

Authentication: Clerk

next-forge uses Clerk by default — pre-built UI components, organizations, RBAC, and SSO. If you prefer Better Auth (self-hosted, no per-MAU cost), the swap is well-documented in next-forge's migration guides. Clerk is the faster path to launch; Better Auth is the cheaper path at scale past 10K MAUs.

// packages/auth/index.ts — pre-configured
import { auth } from "@clerk/nextjs/server";

export async function requireUser() {
  const { userId } = await auth();
  if (!userId) throw new Error("Unauthorized");
  return userId;
}

Database: Neon + Prisma

// packages/database/index.ts
import { PrismaClient } from "@prisma/client";
import { neonConfig, Pool } from "@neondatabase/serverless";
import { PrismaNeon } from "@prisma/adapter-neon";
import ws from "ws";

neonConfig.webSocketConstructor = ws;

const pool = new Pool({ connectionString: process.env.DATABASE_URL });
const adapter = new PrismaNeon(pool);

export const database = new PrismaClient({ adapter });

The Neon serverless adapter handles connection pooling for Vercel's serverless environment. Database branching in Neon means each feature branch gets an isolated preview database.

Payments: Stripe

Stripe is integrated in the api app, handling subscription lifecycle via webhooks. Checkout sessions and customer portal are exposed as API routes callable from the app frontend.

Email: Resend + React Email

// apps/email/emails/welcome.tsx
import { Html, Button, Text, Section } from "@react-email/components";

export default function WelcomeEmail({ name }: { name: string }) {
  return (
    <Html>
      <Section>
        <Text>Welcome, {name}!</Text>
        <Button href="https://app.yourdomain.com">Open Dashboard</Button>
      </Section>
    </Html>
  );
}

Email templates live in the apps/email directory as React components. Resend renders and delivers them. Local development runs a preview server so you can see template changes before sending.

Analytics + Monitoring

PostHog tracks product analytics (user events, funnels, session replays). Sentry captures errors and performance traces. Both are configured in the packages/observability and packages/analytics packages and available in every app.

Turborepo: Why the Monorepo Pays Off

Turborepo is the task runner that makes the monorepo manageable:

// turbo.json
{
  "pipeline": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": [".next/**", "dist/**"]
    },
    "dev": {
      "cache": false,
      "persistent": true
    },
    "typecheck": {
      "dependsOn": ["^build"]
    }
  }
}

What Turborepo Gives You

Parallel execution: turbo dev starts all six apps in parallel. turbo build builds only apps affected by changed files.

Remote caching: If you've built packages/design-system and the source hasn't changed, Turborepo serves the cached build output. CI goes from 8 minutes to 45 seconds for unchanged packages.

Dependency graph awareness: turbo typecheck knows to run packages/database typechecks before apps/app typechecks that depend on it.

Monorepo DX in Practice

# Start all apps in development
pnpm dev

# Build only affected apps (uses Turborepo cache)
pnpm build

# Run type checks across all packages
pnpm typecheck

# Add a dependency to a specific app
pnpm add stripe --filter=api

next-forge vs Single-App Starters

Feature	next-forge	ShipFast	Supastarter
Price	Free	$199	$299
Architecture	Monorepo (6 apps)	Single app	Single app (+ Nuxt)
Auth	Clerk	NextAuth	Better Auth
Database	Neon + Prisma	Supabase	Supabase
Multi-tenancy	Via Clerk orgs	✗	✓
Email templates	React Email app	React Email	React Email
Component docs	Storybook	✗	✗
Marketing site	Included (web app)	Included	Included
Monorepo tooling	Turborepo	✗	✗
GitHub stars	7,000+	—	—
Setup time	15–30 min	30–60 min	60–90 min

Who next-forge Is (And Isn't) For

Right for

Teams building B2B SaaS with multiple surfaces (marketing site + dashboard + API) who want each surface maintainable independently. The monorepo pays for its complexity when you have 3+ engineers or are planning to hire.

Developers who want the full Vercel stack — next-forge is opinionated about deploying to Vercel. If you're all-in on Vercel, the integration is seamless (preview deployments for all six apps from one PR).

Founders who want the same architecture as serious companies — the monorepo pattern used by Vercel, Linear, and most well-funded SaaS is now available as a starting point.

Not right for

Solo indie hackers shipping an MVP in a weekend — single-app starters like ShipFast or LaunchFast are faster for small, single-surface products. The monorepo overhead is a net negative when you're moving fast alone.

Non-Vercel deployments — next-forge assumes Vercel. Deploying all six apps to Railway or Fly.io requires manual configuration not covered in the docs.

Developers new to monorepos — if Turborepo, workspace dependencies, and inter-package imports are new concepts, expect 1–2 days of tooling orientation before you're productive.

Getting Started

# Init the monorepo
npx next-forge@latest init my-saas

# Navigate to the project
cd my-saas

# Install dependencies
pnpm install

# Copy environment variables
cp apps/app/.env.example apps/app/.env.local
cp apps/web/.env.example apps/web/.env.local
cp apps/api/.env.example apps/api/.env.local

# Start all apps
pnpm dev

Required accounts to configure before pnpm dev works fully:

Clerk (auth)
Neon (database)
Stripe (payments)
Resend (email)
PostHog (analytics)
Sentry (error tracking)

All six services have free tiers. Total cost pre-revenue: $0.

Verdict

next-forge is the best free SaaS starter in 2026 for teams that want to build seriously from day one. The monorepo architecture, pre-integrated stack, and Turborepo tooling remove weeks of setup that would otherwise delay real feature work.

The caveat is real: if you're building solo, moving fast, and don't need the multi-app separation, a single-app starter like ShipFast or Supastarter gets you to first customer faster.

For everyone else, there's no better free starting point. npx next-forge@latest init and you're shipping infrastructure that would take a team weeks to assemble.

Frequently Asked Questions

Is next-forge really free?

Yes. next-forge is MIT licensed, maintained by Hayden Bleasel and Vercel, and has no paid tiers, license fees, or usage costs. The services it integrates (Clerk, Neon, Stripe, etc.) have their own pricing, but next-forge itself is free forever.

Do I have to deploy to Vercel?

next-forge is optimized for Vercel but not locked to it. All six apps are standard Next.js apps deployable anywhere Next.js runs — Railway, Render, Fly.io, or self-hosted. The Neon database branching integration with Vercel preview deployments is a convenience feature, not a requirement. Expect some manual configuration if deploying to non-Vercel hosts.

How does next-forge handle environment variables across six apps?

Each app has its own .env.local. Shared secrets (like database URLs) are duplicated across apps intentionally — this makes each app independently deployable without shared environment configuration. next-forge includes a .env.example for each app listing every required variable.

Is Clerk required, or can I swap to Better Auth?

Clerk is the default. Swapping to Better Auth is documented in next-forge's migration guides — the packages/auth package is the only change point, and all apps import auth from there. The swap takes 2–3 hours and is the most common customization.

What's the difference between next-forge and create-t3-app?

create-t3-app is a single-app starter (Next.js + tRPC + Prisma + Tailwind + NextAuth). next-forge is a multi-app monorepo. For an individual developer building an MVP, T3 is simpler and faster. For a team building a production SaaS with separate marketing and dashboard surfaces, next-forge is the right architecture.

Browse all Next.js boilerplates or compare next-forge vs single-app starters on StarterPick.

next-forge: Monorepo SaaS Starter Review 2026