T3 Turbo Review 2026: The Monorepo Edition of T3 Stack

TL;DR

T3 Turbo is the best free monorepo boilerplate for web + mobile TypeScript apps. It shares the tRPC API between Next.js and React Native, eliminating code duplication. The architecture is clean and the TypeScript sharing is genuinely impressive. Trade-off: significant complexity overhead — only worth it if you actually need mobile.

What You Get (Free)

git clone https://github.com/t3-oss/create-t3-turbo

Structure:

apps/
  nextjs/           ← Next.js web app (Pages Router)
  expo/             ← Expo React Native
packages/
  api/              ← tRPC router (shared)
  auth/             ← NextAuth config (shared)
  db/               ← Prisma schema + client (shared)
  ui/               ← Shared components (web only)
  validators/       ← Zod schemas (shared between all)
turbo.json

---

The Code Sharing Magic

The key value: one tRPC router serves both web and mobile:

// packages/api/src/router/post.ts — defined ONCE
export const postRouter = createTRPCRouter({
  all: protectedProcedure.query(({ ctx }) => {
    return ctx.db.post.findMany({
      where: { authorId: ctx.session.user.id },
      orderBy: { id: 'desc' },
    });
  }),

  create: protectedProcedure
    .input(z.object({ content: z.string().min(1) }))
    .mutation(({ ctx, input }) => {
      return ctx.db.post.create({
        data: { content: input.content, authorId: ctx.session.user.id },
      });
    }),
});

// apps/nextjs/src/app/page.tsx — web usage
import { api } from '@/trpc/server';
const posts = await api.post.all();  // Server Component

// apps/expo/src/app/(tabs)/index.tsx — mobile usage
const { data: posts } = api.post.all.useQuery();  // React Query on mobile

Same procedure, same TypeScript types, same validation — no duplication.

---

Turborepo Build Orchestration

// turbo.json — parallel builds with caching
{
  "tasks": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": [".next/**", "!.next/cache/**", "dist/**"]
    },
    "typecheck": {
      "dependsOn": ["^typecheck"],
      "outputs": []
    },
    "lint": {},
    "dev": {
      "cache": false,
      "persistent": true
    }
  }
}

# Run everything
pnpm dev

# Run only web
pnpm --filter nextjs dev

# Build and cache — subsequent builds are fast
pnpm build  # First time: 120s
pnpm build  # Second time: 8s (cache hit)

Turborepo's caching means CI builds go from 2 minutes to 10 seconds when packages haven't changed.

---

Expo React Native Integration

// apps/expo/src/app/(tabs)/post/[id].tsx
import { api } from '~/utils/api';

export default function PostPage({ id }: { id: string }) {
  const { data: post, isLoading } = api.post.byId.useQuery({ id });

  if (isLoading) return <ActivityIndicator />;
  if (!post) return <Text>Post not found</Text>;

  return (
    <View className="flex-1 p-4">
      <Text className="text-2xl font-bold">{post.title}</Text>
      <Text className="mt-2 text-gray-600">{post.content}</Text>
    </View>
  );
}

The mobile app uses the same API client as the web app. Change a procedure's return type once → TypeScript errors on both web and mobile simultaneously.

---

The Setup Reality

T3 Turbo has more moving parts than T3 Stack:

# Setup requires:
pnpm install           # Install all workspace dependencies
pnpm db:push           # Push Prisma schema to database
pnpm db:generate       # Generate Prisma client

# Run web + expo simultaneously
pnpm dev               # Starts Next.js + Expo bundler

# Mobile: also need Expo app on device or simulator
npx expo start

For developers new to monorepos, the initial setup and mental model require 1-2 days to internalize.

---

The Not-So-Good

1. Pages Router Not App Router

T3 Turbo uses Next.js Pages Router by default. App Router migration is in progress but the main branch is still Pages Router. Some boilerplate patterns (server components, server actions) aren't in the official version.

2. Expo Updates Lag Next.js

Keeping Expo and Next.js in sync across a monorepo means both need to update together. React Native updates slower than Next.js, so your web app may lag on new React features.

3. Complexity Without Mobile Isn't Worth It

If you're only building a web app, T3 Turbo's monorepo overhead isn't justified. Use the regular T3 Stack.

4. No SaaS Features

Like T3 Stack, T3 Turbo is a foundation — no billing, email, or marketing pages.

---

Who Should Use T3 Turbo

Good fit:

• Teams building web + mobile simultaneously (the primary use case)
• Products where type-safe shared API is critical
• Teams who know they'll add mobile within 6 months
• Developers learning full-stack TypeScript monorepo patterns

Bad fit:

• Web-only products (monorepo overhead without the benefit)
• Teams who need SaaS features quickly
• Developers new to monorepos (steep learning curve)

---

Final Verdict

Rating: 4/5

T3 Turbo is the best free solution for web + mobile TypeScript apps. The code sharing is genuinely impressive and saves significant development time when you're maintaining both platforms. The complexity is real but justified if mobile is in your roadmap.

---

Compare T3 Turbo with alternatives on StarterPick.