v0.1.1 — MERN · PERN · Hono · Go Fiber

Full-stack apps,
scaffolded right.

stackit is the create-next-app for backends — pick MERN, PERN, Hono or Go Fiber and get a best-practice monorepo with layered APIs, validation, Docker and docs. In one command.

Scaffold my app Read the docs

terminal — zsh

$ bunx create-stackit-app@latest create my-app --stack mern -y
✔ Environment looks good
✔ Scaffolded 33 files → ./my-app
✔ Done! my-app (mern, typescript, bun)
$ cd my-app && bun run dev  # → client :5173 + api :5000

▊ zero config · prompts when you want them · flags when you don't

production stacks

files per scaffold

30s

idea → running app

config to write

MERNPERNHono + PostgresGo + FiberBun-firstTypeScriptVite + ReactMongoDBPostgreSQLDockerzod validationCI-ready -y

$ stacks

One CLI. Four production stacks.

Every stack ships a Vite + React frontend and a layered backend with validation, env handling and Docker. Pick a tab to see exactly what you get.

most popularTS-first

MERN

MongoDB + Express + React — the classic, minus the boilerplate pain.

Backend

Express + Mongoose

Database

MongoDB

Runtime

Bun / Node

client/src/App.tsx— demo page wired to the API
server/src/app.ts— app factory + middleware
server/src/models/user.ts— mongoose schema
server/src/routes/users.ts— CRUD routes + zod
docker-compose.yml— one-command Mongo

scaffold it · via bunx, no install

terminal — mernbash

bunx create-stackit-app@latest create my-app --stack mern --language typescript --runtime bun --pm bun -y

# then

$ cd my-app

$ docker compose up -d

$ bun run dev

→ frontend :5173 · api :5000 · health /api/health

$ features

Everything a real project needs. Nothing it doesn't.

No 200-line tutorials to follow, no decisions to agonize over. The boring-but-critical parts are already done — correctly.

Best-practice layouts

Layered backends — routes, controllers, models, middlewares, config, utils. No dumping everything in index.js, ever.

server/src/

├── app.ts

├── routes/

├── controllers/

├── models/

└── middlewares/

▊ no index.js dumping ground

Bun-first, Node-friendly

Bun gets --hot reload and native TS. Node gets tsx watch + tsc builds. The template adapts scripts per runtime automatically.

Validation baked in

Every write endpoint ships with zod validation, a central error handler, 404s and an async wrapper. 400s, not 500s.

Databases with one command

docker-compose.yml for Mongo or Postgres in every scaffold. Copy .env.example, compose up, done.

Flags-first CLI

Fully non-interactive with -y and --stack/--language/--runtime/--pm. Perfect for scripts, CI and dotfiles.

Monorepo that just runs

client/ + server/ with concurrently wired dev. One command boots the full stack, Vite proxy already pointing at the API.

$ bun run dev

client :5173api :5000

$ workflow

Idea to running app in 30 seconds.

Three steps. No Yeoman generators to debug, no wiki pages to read, no 'now wire up CORS' left as an exercise.

Answer 4 questions

Stack, language, runtime, package manager. Or skip it all with -y and flags — CI-friendly by design.

CLI checks your machine

Node, Bun, Go versions verified before a single file is written. Missing something? You get the exact install hint.

Code, install, git — done

33 best-practice files, dependencies installed, repo initialized. cd in and run dev. That's the whole workflow.

terminal — create my-apptext

✔ Environment looks good
✔ Scaffolded 33 files → /home/you/test-mern
✔ Done! test-mern (mern, typescript, bun)

Next steps:
  $ cd test-mern
  $ bun run dev  # runs client + server

client/src/lib/api.tsts

// client/src/lib/api.ts — generated
export function getHealth(): Promise<Health> {
  return req<Health>("/api/health"); // → { status: "ok", uptime: 12 }
}

$ faq

Questions? Answered.

Those give you one frontend. stackit scaffolds the whole full-stack repo — Vite + React client, a layered API backend, database wiring, Docker and env files — across 4 backend stacks, 2 languages and 2 runtimes, from one CLI.

No — bunx/npx runs the published binary with plain Node. You only need Bun if you run the CLI from source. Generated projects run on whatever you pick — Node 20+, Bun 1.2+, or Go 1.24+. The CLI even checks your machine first and tells you exactly what's missing.

Your call, per scaffold. TypeScript gets strict tsconfigs, typed API helpers and tsc builds; JavaScript stays lean with zero build step. Go stacks always use Go for the backend with a TypeScript frontend.

Yes by default — root, client and server (or go mod tidy + npm for Go stacks), plus git init. Pass --no-install / --no-git to skip either. Offline? Scaffold first, install later.

That's what -y is for. Every prompt has a flag: --stack, --language, --runtime, --pm. Invalid combos are rejected with a clear error instead of generating something broken.

Yes! No setup needed: bunx create-stackit-app@latest create my-app --stack mern -y (or npx). Prefer a global install? npm install -g create-stackit-app gives you the stackit command everywhere. Source runners can still git clone + bun install from cli/.

$ stop configuring · start shipping

Your next full-stack app is one command away.

Clone, install, scaffold. The backend boilerplate you've written a hundred times — done right, in seconds.

terminalbash

bunx create-stackit-app@latest create my-app --stack mern -y

Read the quickstart

Full-stack apps,scaffolded right.