T3 Turbo vs T3 Stack: Monorepo vs Single-App

Same Family, Different Architectures

The T3 ecosystem has two official starting points, and developers confuse them constantly. T3 Stack (create-t3-app) scaffolds a single Next.js application with end-to-end type safety. T3 Turbo (create-t3-turbo) splits that same philosophy across a Turborepo monorepo with shared packages, a Next.js web app, and an Expo React Native mobile app.

Both live under the t3-oss GitHub organization. Both use tRPC for type-safe APIs. Both are free and open source. But they solve fundamentally different problems, and choosing the wrong one either leaves you fighting unnecessary complexity or rebuilding your architecture when you outgrow a single app.

This comparison breaks down when the monorepo is worth the overhead -- and when a single app is the smarter bet.

TL;DR

T3 Stack (create-t3-app) is a CLI that scaffolds a single Next.js application with tRPC, Prisma or Drizzle, NextAuth, and Tailwind CSS. It is the most popular free boilerplate in the Next.js ecosystem with 28K+ GitHub stars, and it gets a type-safe project running in minutes with zero monorepo complexity. T3 Turbo (create-t3-turbo) is a Turborepo monorepo template that splits the T3 philosophy into shared packages -- separate packages for your API layer (tRPC), database (Drizzle + Supabase), authentication (Better Auth), and UI components (shadcn-ui) -- with both a Next.js web app and an Expo React Native mobile app consuming them. Choose T3 Stack if you are building a web-only product and want the simplest path to production. Choose T3 Turbo if you need a mobile app alongside your web app, or you want to share typed packages across multiple applications from day one.

Key Takeaways

T3 Stack is a CLI scaffold. T3 Turbo is a template repo. T3 Stack lets you interactively pick which pieces you want (tRPC, Prisma, NextAuth, Tailwind -- all optional). T3 Turbo gives you everything pre-configured in a monorepo with no pick-and-choose.
T3 Turbo includes mobile out of the box. The Expo app with React Native, Expo Router, and NativeWind means you can ship iOS and Android alongside your web app, sharing your API layer, database schema, and auth logic.
They use different default auth and ORM. T3 Stack defaults to NextAuth + Prisma. T3 Turbo currently uses Better Auth + Drizzle + Supabase. These are not just swapped libraries -- they reflect different architectural priorities.
T3 Stack has a far larger community. 28K+ GitHub stars versus T3 Turbo's 5.9K. More tutorials, more StackOverflow answers, more community extensions.
Monorepo overhead is real. Turborepo adds a build orchestration layer, workspace configuration, and package boundary management. For a solo developer building a web-only SaaS, this complexity rarely pays for itself.
T3 Turbo shines for teams and multi-platform projects. When two or more developers work on different apps that share a data layer, the monorepo structure prevents drift and catches integration bugs at compile time.

Quick Comparison Table

Feature	T3 Stack (create-t3-app)	T3 Turbo (create-t3-turbo)
Type	CLI scaffold	Template repository
Architecture	Single Next.js app	Turborepo monorepo
Framework	Next.js 15	Next.js 15 + TanStack Start
Mobile	None	Expo SDK 54 (React Native)
Auth	NextAuth.js (optional)	Better Auth
ORM	Prisma or Drizzle (optional)	Drizzle
Database	Any SQL (you configure)	Supabase (Vercel Postgres driver)
API Layer	tRPC (optional)	tRPC v11
Styling	Tailwind CSS (optional)	Tailwind CSS v4 + NativeWind v5
UI Library	None (you choose)	shadcn-ui (shared package)
Build System	Next.js built-in	Turborepo
Shared Packages	N/A (single app)	api, auth, db, ui
Shared Tooling	N/A	ESLint, Prettier, TypeScript configs
GitHub Stars	28K+	5.9K
Customization	Interactive CLI (opt-in pieces)	All-or-nothing template
Setup Complexity	Low (5 minutes)	Medium (15-30 minutes)
Best For	Web-only projects, solo devs	Multi-platform, teams
License	MIT	MIT

Architecture Deep Dive

T3 Stack: One App, Everything Colocated

When you run npm create t3-app@latest, the CLI asks which pieces you want. Say yes to everything and you get a single Next.js project with this structure:

my-app/
  src/
    pages/ or app/
    server/
      api/
        routers/
        trpc.ts
      auth.ts
      db.ts
    styles/
    utils/
  prisma/
    schema.prisma
  next.config.js
  tailwind.config.ts

Everything lives in one directory. Your tRPC routers, Prisma schema, auth configuration, and frontend components are all part of the same build. When you run next dev, your entire application starts. When you deploy, you deploy one artifact.

This simplicity is the point. There is no workspace configuration. No inter-package dependency graph. No question about which package owns which code. A junior developer can clone the repo, run npm install, and understand the project structure in ten minutes.

The trade-off appears when you need the same backend logic somewhere else. Want a React Native app that calls the same tRPC procedures? You either duplicate the API layer or restructure into a monorepo -- and that restructuring is not trivial after six months of development.

T3 Turbo: Shared Packages, Multiple Consumers

T3 Turbo splits the T3 philosophy into isolated, typed packages that multiple apps consume:

apps/
  expo/          -- React Native mobile app
  nextjs/        -- Next.js web app
  tanstack-start/ -- TanStack Start web app (alternative)

packages/
  api/           -- tRPC router definitions
  auth/          -- Better Auth configuration
  db/            -- Drizzle schema and database client
  ui/            -- shadcn-ui component library

tooling/
  eslint/        -- Shared ESLint presets
  prettier/      -- Shared Prettier config
  tailwind/      -- Shared Tailwind theme
  typescript/    -- Shared tsconfig

Each package in packages/ is a self-contained module with its own package.json and TypeScript configuration. The api package exports tRPC routers. The db package exports the Drizzle schema and client. The auth package exports authentication helpers. The ui package exports React components.

Both the Next.js and Expo apps import from these shared packages. Change a database column in packages/db, and TypeScript immediately flags every component in every app that references that column. Add a new tRPC procedure in packages/api, and both the web and mobile apps can call it with full type safety.

Turborepo orchestrates the builds. It understands the dependency graph between packages and apps, runs builds in parallel where possible, and caches results so unchanged packages are not rebuilt. On a team where multiple developers push changes throughout the day, this caching can cut CI times significantly.

The trade-off is complexity. You manage workspace dependencies, deal with package resolution quirks, configure Turborepo pipelines, and reason about which package owns which responsibility. For a solo developer building a web-only MVP, this overhead is pure cost with no return.

Feature Comparison

Authentication

T3 Stack includes NextAuth.js as an optional dependency. When you select both NextAuth and Prisma during scaffolding, you get a working auth setup with the User, Session, Account, and VerificationToken models, a Discord OAuth provider as the default, and type-safe session access through tRPC context. You add more providers, configure callbacks, and build login pages yourself.

T3 Turbo uses Better Auth, a newer authentication library that generates its schema directly into your Drizzle database. The auth configuration lives in the shared packages/auth directory and is consumed by both the Next.js and Expo apps. Better Auth supports an OAuth proxy plugin for preview deployments, which is a practical benefit for teams using Vercel preview URLs.

Neither choice is objectively better. NextAuth is battle-tested with a massive ecosystem of providers and adapters. Better Auth is newer and designed specifically for modern TypeScript patterns with Drizzle. If you have a strong preference for one auth system, that should factor into your decision.

Database and ORM

T3 Stack defaults to Prisma but also supports Drizzle as an option during scaffolding. Prisma works with PostgreSQL, MySQL, SQLite, SQL Server, and CockroachDB. You configure your database connection and manage migrations through the Prisma CLI. The generated client gives you fully typed queries.

T3 Turbo uses Drizzle exclusively, preconfigured with Supabase and edge-bound via the Vercel Postgres driver. The database package is designed to work at the edge, which matters for serverless and edge-deployed applications. Drizzle's SQL-like syntax gives you more control over generated queries than Prisma's abstraction layer.

For most projects, either ORM works well. Prisma has more documentation and community resources. Drizzle has a smaller runtime footprint and generates SQL that is closer to what you would write by hand. T3 Turbo's Drizzle choice reflects its focus on edge deployment and performance.

Mobile Support

This is the single biggest differentiator.

T3 Stack has no mobile story. It is a Next.js web application. If you decide six months in that you need a React Native app, you are either starting a separate project and duplicating your API layer, or migrating to a monorepo structure -- which is essentially adopting T3 Turbo's architecture after the fact.

T3 Turbo includes a complete Expo application with Expo SDK 54, React Native 0.81, Expo Router for navigation, and NativeWind v5 for Tailwind-style styling in React Native. The Expo app imports from the same packages/api and packages/auth packages as the Next.js app. Your mobile app and web app share the same tRPC procedures, the same database schema types, and the same auth logic.

If you know you need a mobile app, starting with T3 Turbo saves weeks of restructuring later. If you are web-only and might never need mobile, the Expo app is dead weight.

Build System and CI

T3 Stack uses Next.js's built-in build system. Run next build, get a production bundle. CI is straightforward -- install, lint, build, test. There is nothing to configure beyond what Next.js provides.

T3 Turbo uses Turborepo to orchestrate builds across all apps and packages. Turborepo understands the dependency graph, runs tasks in parallel, and caches outputs. If packages/db has not changed since the last build, Turborepo skips it entirely. On large monorepos with a team pushing frequent changes, this caching reduces CI times by as much as 85%.

But for a single developer or a small team, Turborepo's benefits rarely outweigh its configuration overhead. You need to define pipelines in turbo.json, manage workspace dependencies, and understand how caching interacts with environment variables. When something goes wrong, you are debugging Turborepo's task graph, not just a Next.js build.

Shared Code and Package Boundaries

T3 Stack puts everything in one app. Code sharing means importing from different directories within the same project. There is no package boundary enforcement -- any file can import from any other file.

T3 Turbo enforces boundaries through packages. The packages/api package exports tRPC routers but cannot reach into packages/auth internals. The packages/ui package exports components but does not know about the database. These boundaries mean changes in one package have explicit, visible effects on consuming apps.

For a growing team, these boundaries prevent the "everything imports everything" problem that makes large codebases unmaintainable. For a solo developer, they add indirection without much benefit.

Developer Experience

Getting Started

T3 Stack takes about five minutes. Run the CLI, answer the interactive prompts, and you have a running Next.js app with the tools you selected. The docs at create.t3.gg are excellent -- clear guides for each tool and how they integrate.

T3 Turbo takes 15-30 minutes. Clone the template repo, install dependencies across all workspaces, set up Supabase, configure environment variables for both the web and mobile apps, run database migrations, generate the Better Auth schema, and start the dev server. The setup is well-documented but involves more moving parts.

Day-to-Day Development

With T3 Stack, you run next dev and your entire app is available. Hot module replacement works on everything. There is one set of logs, one dev server, one terminal.

With T3 Turbo, you typically run turbo dev which starts both the Next.js and Expo dev servers simultaneously. Package changes are picked up through workspace linking, but you may need to restart the dev server when modifying shared package exports. You are managing multiple terminal outputs and potentially multiple simulators for mobile testing.

Adding New Features

In T3 Stack, you create new files in the appropriate src/ directory and start using them. There is no question about which package to put them in.

In T3 Turbo, you need to decide: Does this new feature belong in packages/api as a shared procedure? In packages/db as a new schema? In apps/nextjs as web-specific logic? In packages/ui as a shared component? These decisions are valuable for maintaining clean architecture, but they add friction to every feature.

When to Choose T3 Stack

You are building web-only. No mobile app on the roadmap, no secondary web app, no CLI that needs to share types. A single Next.js app covers everything.
You are a solo developer or a small team (1-3 people). Monorepo overhead does not pay for itself until multiple developers are working on separate apps that share code.
You want maximum flexibility. The interactive CLI lets you pick exactly which tools you want. You are not locked into Better Auth, Drizzle, or Supabase.
You want the largest community. 28K+ GitHub stars, Theo Browne's YouTube content, active Discord, and hundreds of community-built extensions. If you hit a problem, someone has solved it before.
Speed to first deploy matters most. Five minutes to a running app. No workspace configuration, no Turborepo pipeline setup, no mobile simulator.
You are learning the T3 ecosystem. Start with the simpler architecture. Understanding tRPC, Prisma, and NextAuth in a single-app context is easier than learning those tools plus Turborepo, workspaces, and package boundaries simultaneously.

Best for: SaaS MVPs, indie hacker projects, web applications, developer tools, any project where one Next.js app covers the full scope.

Time to productive development: 5-10 minutes.

When to Choose T3 Turbo

You need both web and mobile. If a React Native app is on your roadmap, starting with T3 Turbo saves weeks of restructuring versus migrating a T3 Stack project into a monorepo later.
You want shared typed packages. Multiple apps consuming the same tRPC routers, database schema, and auth logic with compile-time safety across all consumers.
Your team has 3+ developers. When developers specialize (one on web, one on mobile, one on the shared API layer), package boundaries prevent stepping on each other's work. Turborepo's caching makes CI tolerable as the codebase grows.
You are building a platform with multiple surfaces. A customer-facing web app, an internal admin dashboard, a mobile app for field workers -- all sharing the same API and database layer.
You want to experiment with alternative web frameworks. T3 Turbo now includes a TanStack Start app alongside Next.js, and the shared package architecture means adding a Vite app, an Electron app, or any other consumer is straightforward.
You value enforced code boundaries. Package separation prevents the architectural drift that happens in large single-app codebases where any file can import from anywhere.

Best for: Multi-platform products, teams building web + mobile, platform projects with multiple applications, organizations that want enforced package boundaries.

Time to productive development: 15-30 minutes.

The Migration Question

One of the most common questions in the T3 Discord: "Can I migrate from T3 Stack to T3 Turbo later?"

Yes, but it is not trivial. Migration means extracting your tRPC routers into a packages/api directory, moving your database schema into packages/db, pulling auth logic into packages/auth, setting up Turborepo configuration, updating all imports, and testing that nothing broke. Blog posts and community guides exist for this migration, and it typically takes two to five days depending on project size.

The reverse migration -- going from T3 Turbo to a single app -- is simpler. You flatten the monorepo by moving shared package code into your app directory and remove Turborepo configuration.

The practical takeaway: if there is any realistic chance you will need mobile or multiple apps, start with T3 Turbo. The cost of setting up the monorepo on day one is a few extra hours. The cost of migrating into a monorepo after six months of development is a week of refactoring with risk of regressions.

Common Misconceptions

"T3 Turbo is the upgraded version of T3 Stack." No. They are different architectures for different use cases. T3 Turbo is not "T3 Stack but better" -- it is "T3 Stack but split across a monorepo with mobile support." If you do not need that split, T3 Stack is the better choice.

"You need Turborepo for a serious production app." No. Thousands of production applications run on single-app T3 Stack projects. Turborepo solves build orchestration across multiple packages, not application quality.

"T3 Turbo uses the same tech as T3 Stack." Not exactly. As of early 2026, they have diverged. T3 Stack defaults to NextAuth + Prisma. T3 Turbo uses Better Auth + Drizzle + Supabase. The shared philosophy (type safety, tRPC) is the same, but the specific libraries differ.

"Monorepos are always better for teams." Not always. A monorepo adds value when multiple apps share code. If your team is building one web application, a monorepo adds coordination overhead without the benefit of shared packages. Team size alone does not justify a monorepo -- shared code across multiple deploy targets does.

The Honest Answer

T3 Stack and T3 Turbo are not competing products. They are different tools from the same ecosystem that answer different architectural questions.

T3 Stack answers: "What is the fastest way to start a type-safe Next.js web application?" It gives you an interactive scaffold, the largest community in the T3 ecosystem, and zero monorepo overhead. For the vast majority of new projects -- especially solo developer and small team projects -- this is the right starting point.

T3 Turbo answers: "How do I share a type-safe backend across a web app and a mobile app from day one?" It gives you Turborepo, shared packages, an Expo mobile app, and enforced code boundaries. If you know you are building for multiple platforms, this saves significant restructuring later.

If you are building a web-only project, start with T3 Stack. The simplicity advantage is real and the migration path to a monorepo exists if you need it later.

If you are building web plus mobile, or you are a team of 3+ developers building a platform with multiple applications, start with T3 Turbo. The upfront complexity pays for itself through shared packages and compile-time safety across all your apps.

When in doubt, ask yourself one question: Will more than one application consume my backend? If yes, T3 Turbo. If no, T3 Stack.

Methodology

This comparison is based on the official GitHub repositories for both projects (t3-oss/create-t3-app and t3-oss/create-t3-turbo), their documentation, and community resources as of March 2026. T3 Stack was evaluated at version 7.40.0. T3 Turbo was evaluated from the main branch, which includes Next.js 15, Expo SDK 54, tRPC v11, Drizzle, Better Auth, and Supabase.

Architecture and developer experience assessments reflect hands-on evaluation of both templates. Time estimates are based on a mid-level full-stack developer working solo. We have no affiliate relationship with either project. Both are free, open-source, and MIT-licensed.

Looking for more boilerplate comparisons? StarterPick has side-by-side feature breakdowns, community reviews, and stack analysis for dozens of SaaS boilerplates -- so you can find the right one without the research rabbit hole.

Comments