Kitsune Stack logoKitsune Stack
StackDemosQuick StartArchitectureBlog
Start Project
Production Monorepo Foundation

Ship product logic,not setup scripts.

A full-stack starter built for teams that want real momentum: shared UI, typed APIs, auth wired in, database ready, and live demos you can trust on day one.

Scaffold In 5 MinutesView Live Demos

Typed end-to-end from DB to UI

Web + server + worker in one repo

Reusable shadcn-based UI package

terminal

$bun create-turbo@latest --example https://github.com/kitsunekode/template-nextjs-express-trpc-bettera-auth-monorepo my-app
$cd my-app && bun install
$bunx shadcn@latest add button card dialog
$bun dev

Core Stack

Next.js 16tRPCPrismaBetter Auth

Features

  • Auth
  • Real-time
  • Prisma

App Surfaces

3

web, server, worker

Shared Packages

8+

ui, auth, trpc, store, common

Bootstrap Time

<10m

from clone to running stack

Type Coverage

100%

single TS contract across layers

Technology Stack

Opinionated choices that keep velocity high after month twelve.

Every layer is pre-wired for real product work. No toy architecture, no “starter” compromises, no disconnected package decisions.

Type-Safe Everything

End-to-end type safety with tRPC. Catch errors at compile time, not runtime.

const user = await trpc.user.byId.query({ id: '1' });
console.log(user.name); // Typed!

Modern Authentication

Secure authentication flows with Better Auth. Social logins, email magic links, and more.

const session = await auth.api.getSession({
  headers: req.headers
});

Real-Time Ready

Built-in support for real-time features using Upstash Redis and Server-Sent Events.

await redis.publish('chat', JSON.stringify({
  text: 'Hello World!',
  userId: 'user_123'
}));

Database Power

Prisma ORM configured with PostgreSQL. Visual schema editing and type-safe queries.

model User {
  id    String @id @default(cuid())
  email String @unique
  posts Post[]
}

Monorepo Architecture

Scalable Turborepo structure. Share UI components and logic across apps.

apps/
  web/
  server/
packages/
  ui/
  db/

Developer Experience

Hot reload, TypeScript, ESLint, Prettier. Everything configured for speed.

pnpm dev
> Ready in 1234ms

Architecture

A monorepo layout your team can reason about quickly.

Workspace Map

apps/web

Next.js UI + app router

apps/server

Express + tRPC handlers

apps/worker

Background jobs + queues

packages/ui

shadcn-based shared design system

packages/store

Prisma client + schema

packages/auth

Better Auth config + client

Request Flow

  1. 1

    User interacts with web app components from packages/ui.

  2. 2

    Typed procedures call server routers through tRPC.

  3. 3

    Server reads/writes via Prisma and shared store package.

  4. 4

    Realtime updates and async jobs fan out through worker + Redis.

Predictable onboarding: One repo, shared types, and consistent conventions means onboarding new developers is predictable instead of tribal.
Kitsune Stack

Build product features, not monorepo plumbing.

Built for teams who want type safety, coherent architecture, and polished UX from the first commit.

StackDemosQuick StartBlog GitHub
© 2026 KitsuneKode. All rights reserved.
Made with for serious builders.

Quick Start

Copy, run, ship.

This flow mirrors how teams actually onboard the template: scaffold, personalize scope, add UI primitives, then start building features.

1Create a new project using the template
$bun create-turbo@latest --example https://github.com/kitsunekode/template-nextjs-express-trpc-bettera-auth-monorepo my-app
2Install all dependencies
$cd my-app && bun install
3Preview the scope rename (dry run)
$bun run rename-scope:dry
4Rename the package scope to your project name
$bun run rename-scope
5Install reusable shadcn components into the shared UI package
$bunx shadcn@latest add button card dialog dropdown-menu
6Start the development server
$bun dev

shadcn workflow included

Add new components directly into `packages/ui` and consume them in both the app and feature demos.

bootstrap.sh

# 1) Scaffold the repo
bun create-turbo@latest --example https://github.com/kitsunekode/template-nextjs-express-trpc-bettera-auth-monorepo my-app

# 2) Install + rename package scope
cd my-app && bun install
bun run rename-scope

# 3) Add new shadcn components into packages/ui
bunx --bun shadcn@latest add button card dialog dropdown-menu -c apps/web

# 4) Start everything
bun dev

Add Components

$bunx --bun shadcn@latest add button card dialog dropdown-menu -c apps/web

Generate New UI

$bun run generate:component

Functional Proof

This is not just pretty scaffolding.

Click through the demos to verify real interaction patterns before writing your own features.

Live execution environment
Live Chat (Mock)
Local Mode
Bot
Welcome to the chat!
Bot
Try sending a message.
apps/server/src/routers/chat.ts
// Real tRPC implementation
export const chatRouter = {
  list: publicProcedure.query(async () => {
    return prisma.message.findMany({
      orderBy: { createdAt: "asc" },
      include: { sender: true },
    });
  }),

  send: protectedProcedure
    .input(z.object({ content: z.string() }))
    .mutation(async ({ ctx, input }) => {
      return prisma.message.create({
        data: {
          content: input.content,
          senderId: ctx.session.user.id,
        },
      });
    }),
}