T3 Stack vs Epic Stack: TypeScript-First Boilerplates Compared

TL;DR

T3 Stack is a modular CLI scaffold built on Next.js that gives you tRPC, Prisma or Drizzle, NextAuth, and Tailwind CSS — pick what you want, leave what you do not. Epic Stack is a comprehensive Remix-based starter from Kent C. Dodds that ships with SQLite, Prisma, Conform, full testing infrastructure (Playwright, Vitest, MSW), CI/CD, and production-ready deployment to Fly.io. Both are free, both are TypeScript-first, both community-driven. Choose T3 for a minimal, flexible scaffold with end-to-end type safety via tRPC. Choose Epic Stack for an opinionated, production-hardened foundation with testing, monitoring, and deployment already solved.

Key Takeaways

Both are free and open-source. No paywall, no license key, no commercial tier. T3 is MIT-licensed. Epic Stack is MIT-licensed.
Different frameworks, different ecosystems. T3 builds on Next.js and deploys naturally to Vercel. Epic Stack builds on Remix (now React Router v7) and deploys to Fly.io with multi-region SQLite.
T3 is minimal by design. It scaffolds a project and gets out of the way. Epic Stack is maximal by design — it ships everything Kent thinks a production application needs, including things most developers skip.
T3 has the type safety edge. tRPC gives you end-to-end types from database to frontend with zero code generation or schemas. Epic Stack uses Remix loaders and actions — type-safe, but not as seamless across the full stack.
Epic Stack has the testing edge. End-to-end tests with Playwright, unit tests with Vitest, API mocking with MSW, and a pre-configured test database ship out of the box. T3 includes no testing setup at all.
Community size differs significantly. T3 has 28,000+ GitHub stars and Theo's massive content ecosystem. Epic Stack has 5,500+ stars and Kent's EpicWeb.dev educational platform.

Head-to-Head Comparison

Feature	T3 Stack	Epic Stack
Price	Free (MIT)	Free (MIT)
Type	CLI scaffold	Full starter template
Framework	Next.js 15	Remix / React Router v7
TypeScript	Strict	Strict
API Layer	tRPC (optional)	Remix loaders/actions
Database ORM	Prisma or Drizzle (optional)	Prisma
Database	Any SQL (you configure)	SQLite (LiteFS for multi-region)
Auth	NextAuth.js (optional)	Custom (cookie-based sessions)
Forms	None (you choose)	Conform (progressive enhancement)
Styling	Tailwind CSS (optional)	Tailwind CSS + Radix UI
Testing	None	Playwright + Vitest + MSW + Testing Library
CI/CD	None	GitHub Actions (pre-configured)
Monitoring	None	Sentry + Grafana
Email	None	Resend
Image Hosting	None	Tigris
Deployment	You configure (Vercel typical)	Fly.io (Dockerfile included)
GitHub Stars	28,000+	5,500+
Creator	Theo Browne	Kent C. Dodds
Documentation	create.t3.gg	epicweb.dev + repo docs

Philosophy: Scaffold vs Full Stack Starter

This comparison is not really about features. It is about two fundamentally different answers to the same question: "What should a starter give you?"

T3 Stack: Solve Problems, Not Puzzles

T3 Stack follows three axioms defined by its creator, Theo Browne: solve specific problems, bleed responsibly, and typesafety is not optional. When you run npm create t3-app@latest, the CLI walks you through a set of choices — do you want tRPC? Prisma or Drizzle? NextAuth? Tailwind? It generates a clean project with your selections configured and integrated. Then it stops.

No testing framework. No CI pipeline. No monitoring. No deployment configuration. The T3 philosophy says those decisions depend on what you are building, and the scaffold should not make them for you.

This is not laziness. It is a deliberate architectural stance. A solo developer shipping to Vercel has different testing needs than a team deploying to AWS. A real-time application needs different monitoring than a content site. T3 trusts developers to make those calls.

The result: a project that is clean, fast to understand, and free of opinions you will need to undo later. The cost is that you are responsible for everything the scaffold does not include.

Epic Stack: Ship With Confidence From Day One

Epic Stack takes the opposite position. Kent C. Dodds built it based on years of consulting with development teams, and his thesis is clear: most developers skip the hard parts. They skip testing. They skip monitoring. They skip CI/CD. They skip accessibility. They skip progressive enhancement. And then they pay for it in production.

Epic Stack does not let you skip those things. It ships with Playwright end-to-end tests, Vitest unit tests, MSW for mocking external APIs, Sentry for error monitoring, Grafana for observability, GitHub Actions for CI/CD, and a Dockerfile configured for Fly.io deployment. All of it is pre-configured and working together.

Kent's argument is that a starter template should not just give you the code you want to write — it should give you the code you need but would not write yourself. Testing infrastructure, monitoring hooks, and deployment pipelines are not glamorous, but they are the difference between a hobby project and production software.

The result: a project that is ready for production from the first commit. The cost is more code to understand, more opinions to accept, and more complexity upfront.

Architecture Deep Dive

T3 Stack Architecture

T3 projects center on tRPC as the API layer. You define procedures on the server — queries and mutations with Zod input validation — and call them from the client with full type inference. Change a procedure's return type and TypeScript immediately flags every client call that breaks. No REST endpoints, no GraphQL schemas, no code generation step.

The database layer plugs into tRPC's context system. Whether you choose Prisma or Drizzle, your database client and authenticated user session are available in every procedure through a type-safe context object. This means your entire data flow — from database query to API response to UI render — is covered by a single type system.

With the move to Next.js 15, T3 projects also support React Server Components and Server Actions. The community is actively exploring how tRPC and RSC coexist, with patterns for RSC prefetching already documented. You are not locked into tRPC for everything — you can use Server Actions for simple mutations and reserve tRPC for complex query patterns.

Deployment is up to you, but the natural fit is Vercel. Next.js on Vercel requires zero configuration. If you prefer self-hosting, you can deploy anywhere Node.js runs, but you lose Vercel's optimizations for ISR, edge functions, and image handling.

Epic Stack Architecture

Epic Stack builds on Remix, which has now merged with React Router v7. The data flow follows Remix conventions: loaders fetch data on the server, actions handle mutations, and the framework handles serialization, caching, and revalidation. Progressive enhancement is a core principle — forms work without JavaScript, and the app gracefully degrades if the client-side bundle fails to load.

The database choice is deliberately opinionated: SQLite. Not Postgres, not MySQL — SQLite. Kent's reasoning, documented in the project's architecture decision records, is that SQLite eliminates an entire category of infrastructure complexity. No database server to manage, no connection pooling to configure, no separate backup system to maintain. For production, LiteFS provides multi-region replication on Fly.io, giving you distributed reads with a single-writer architecture.

Forms use Conform, a library built specifically for progressive enhancement in Remix. Conform validates on both client and server, provides accessible error messages, and works without JavaScript enabled. This is a philosophical choice — Epic Stack prioritizes progressive enhancement where T3 Stack assumes JavaScript is always available.

The testing architecture deserves its own section because it is one of Epic Stack's strongest differentiators.

Testing: The Biggest Gap

This is where the two stacks differ most dramatically.

T3 Stack ships no testing infrastructure. No test runner, no test utilities, no example tests, no CI configuration. The reasoning is consistent with T3's philosophy — testing choices depend on your project. But in practice, most T3 projects launch without tests because adding testing from scratch requires effort that does not feel productive when you are trying to ship.

Epic Stack ships a comprehensive testing setup:

Playwright for end-to-end tests. The starter includes example tests that cover user registration, login, and content creation. A test database is automatically provisioned and seeded for each test run.
Vitest with Testing Library for unit and integration tests. Components and utilities have corresponding test files that demonstrate testing patterns.
MSW (Mock Service Worker) for mocking external API calls. Third-party services like email providers are mocked in tests so your test suite does not depend on external availability.
GitHub Actions CI runs the full test suite on every pull request. Linting, type checking, unit tests, and end-to-end tests all run in parallel.
Test database seeding with realistic data. Tests run against a SQLite database populated with users, roles, and content that mirrors production patterns.

For a solo developer or early-stage startup, T3's approach might be fine — you can add tests later. For a team, Epic Stack's testing infrastructure is genuinely valuable. The patterns are established, the CI is configured, and skipping tests requires actively removing code rather than passively never writing it.

Database Philosophy

T3 Stack lets you choose. Prisma gives you a declarative schema language, automatic migrations, and a rich query API. Drizzle gives you a SQL-like TypeScript API with better edge runtime compatibility and smaller bundle sizes. Either way, you pick your own database — Postgres on Supabase, MySQL on PlanetScale, SQLite for local development, whatever fits your project.

Epic Stack commits to SQLite and defends the choice. The argument: most applications do not need the complexity of a managed database service. SQLite handles millions of reads per second, supports concurrent writes through WAL mode, and eliminates network latency between your application and your data. With LiteFS on Fly.io, you get multi-region replication that puts your data on the same machine as your application server.

The trade-off is real. If your application needs advanced Postgres features — full-text search with pg_tsvector, JSONB queries, or PostGIS — SQLite will not cover you. Epic Stack's answer is that most applications do not need those features, and developers who do know enough to swap the database layer.

Deployment and Infrastructure

T3 Stack does not include deployment configuration. Most T3 developers deploy to Vercel because the Next.js integration is seamless — push to GitHub and your app is live. But you can deploy anywhere: AWS with SST, Netlify, Railway, a VPS with Docker.

Epic Stack ships a Dockerfile and Fly.io configuration. Run fly launch and your application deploys to a global edge network with SQLite replication, health checks, and automatic TLS. Sentry is pre-configured for error tracking. Grafana dashboards are ready for observability.

If you already have deployment preferences, T3's flexibility is better. If you want to ship without becoming a DevOps engineer, Epic Stack saves days of configuration.

Community and Ecosystem

T3 Stack has one of the largest communities in the React ecosystem. 28,000+ GitHub stars. Theo Browne's YouTube channel has over 1 million subscribers and regularly covers T3-related topics. The T3 Discord is active and well-moderated. There are dozens of community-built extensions, templates, and tutorials. If you hit a problem, someone has written about it.

Epic Stack has a smaller but deeply technical community. 5,500+ GitHub stars. Kent C. Dodds' EpicWeb.dev platform offers comprehensive workshops on full-stack development with the Epic Stack's technologies. The GitHub Discussions section is active, and Kent personally responds to many issues. The community skews toward developers who value testing, accessibility, and software engineering rigor.

Both creators are influential voices in the React ecosystem. Theo emphasizes shipping fast. Kent emphasizes building correctly. Neither is wrong — they are optimizing for different outcomes.

How to Choose

Choose T3 Stack if:

You want Next.js. Your team knows it, your infrastructure supports it, or you want Vercel's deployment experience.
End-to-end type safety is your priority. tRPC's type inference across the full stack is unmatched.
You prefer minimal scaffolds. You want a clean starting point and the freedom to add exactly the tools you need.
You are building something that does not fit a template. Developer tools, real-time apps, custom platforms — T3 gives you the foundation without assumptions about what you are building.
You want the largest community. More stars, more tutorials, more Stack Overflow answers, more Discord members.
You already have testing and deployment preferences. Adding your existing setup to T3 is easier than replacing Epic Stack's.

Best for: SaaS products on Next.js, developer tools, applications with unique requirements, teams that value architectural flexibility.

Choose Epic Stack if:

You want production-grade from day one. Testing, monitoring, CI/CD, and deployment — already configured.
Progressive enhancement matters. Your application needs to work without JavaScript, or you value the resilience it provides.
You believe in Remix's data loading model. Loaders and actions provide a clean, colocated approach to data fetching that avoids the complexity of client-side state management.
You want to ship with SQLite. Fewer moving parts, lower costs, and your data lives next to your application.
Testing is non-negotiable. Epic Stack's test infrastructure means your team writes tests because the patterns are already there, not because someone wrote a Jira ticket about it.
You value Kent's opinions. The architectural decisions are well-documented, thoroughly reasoned, and backed by years of consulting experience.

Best for: Production applications where reliability matters, teams that want testing culture built in, projects deploying to Fly.io.

The Real Question

T3 Stack and Epic Stack represent two valid answers to a question with no universal right answer: how much should a scaffold decide for you?

T3 says: as little as possible. Give developers type-safe building blocks and trust them to assemble the rest. Epic Stack says: as much as possible. Give developers a production-ready application and trust them to customize what they need.

The deciding factor is not which stack is better. It is which kind of developer you are. Do you want a blank canvas with excellent brushes? That is T3. Do you want a finished painting with a palette to make it yours? That is Epic Stack.

Methodology

This comparison is based on publicly available information from both projects' GitHub repositories, official documentation, and creator content as of March 2026. We evaluated architecture, features, testing, deployment, community, and developer experience. We have no affiliate relationship with either project.

Feature claims were verified against official repositories. T3 Stack was evaluated at create-t3-app 7.x with Next.js 15. Epic Stack was evaluated with React Router v7 and React 19.

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

Comments