Navigation
// week 1 shouldn't be folder structure

Architecture Chassis
for Vertical Slice.

Every project starts the same: two weeks debating folder structure, wiring up middleware, configuring tests. I've done it enough times to extract the pattern. These are the project templates I wish existed when I started my last three backends.

Node.js · Go · .NET — same architecture, three languages.

// the problem

The first month is always wasted.

I've seen this movie a hundred times. Sprint 1: debating Clean Architecture vs Hexagonal. Sprint 2: wiring up middleware, error handling, and logging. Sprint 3: figuring out test infrastructure. Sprint 4: finally writing business logic — on top of a foundation nobody's confident about. Or the other version: skip the foundation, write features fast, and spend month 4 untangling spaghetti while your PM asks why velocity dropped.

❌ TRADITIONAL LAYERED

src/
  controllers/
    UserController
    OrderController
    ProductController
  services/
    UserService
    OrderService
    ProductService
  repositories/
    UserRepository
    OrderRepository
    ProductRepository

// Change one feature?
// Touch 4 folders and 12 files.

✓ VERTICAL SLICE

src/
  features/
    create-user/
      handler
      validator
      events
      tests
    place-order/
      handler
      validator
      events
      tests

// Change one feature?
// One folder. Done.
JS

Node.js Chassis

TypeScript · Express/Fastify

My opinionated take on Node.js backend architecture. TypeScript, event-driven, with two real features already working. Clone it and start building your feature in the same afternoon.

  • Vertical Slice folder structure
  • Domain events with in-process event bus
  • Repository pattern (Postgres + Prisma/TypeORM)
  • Middleware pipeline (auth, validation, logging)
  • Testing per feature (unit + integration)
  • 2 example features fully implemented
TypeScript Express Prisma PostgreSQL Jest Zod
$179
Buy now
Go

Go Chassis

Go · Standard Library + Chi
Go 1.22+ Chi Router sqlx PostgreSQL testify

Go the way Go was meant to be written. No frameworks pretending to be Spring Boot. Standard library where possible, Chi for routing, sqlx for queries. Boring, explicit, fast.

  • Vertical Slice structure
  • Channel-based event bus
  • Repository pattern + sqlx
  • Middleware pipeline
  • Tests per feature
  • 2 working examples
$179
Buy now
.NET

.NET Chassis

C# · .NET 8 · Minimal APIs

NET 8 without the ceremony. Minimal APIs instead of controllers, a lightweight pipeline instead of MediatR, and Vertical Slices instead of the usual N-layer lasagna. Two features already wired as proof it works.

  • Vertical Slice folder structure
  • Domain events with in-process event dispatcher
  • Repository pattern (Postgres + EF Core)
  • Middleware pipeline (auth, FluentValidation, Serilog)
  • Testing per feature (unit + integration)
  • 2 example features fully implemented
C# 12 .NET 8 Minimal APIs EF Core FluentValidation xUnit
$179
Buy now
ALL 3 STACKS
// polyglot advantage

Full Chassis Bundle

Same architecture, three languages. It's interesting to see how Vertical Slice translates across ecosystems — where Go's explicitness shines, where .NET's type system catches things TypeScript can't, and where Node.js just gets out of the way. Useful for polyglot teams or engineers who think across stacks.

  • Node.js Chassis (TypeScript)
  • Go Chassis (Chi + sqlx)
  • .NET Chassis (C# 12 + Minimal APIs)
$537 if bought separately
$449
save $88
Get All 3 Chassis
// what's inside each chassis

This isn't a scaffold. It runs.

Vertical Slices

One feature = one folder. Handler, validator, events, tests — everything together. Want to change the payment flow? Open one folder. Don't touch anything else. This is the single best architectural decision I've made in 25 years.

Domain Events

"When a user is created, send a welcome email." In most codebases, you'd shove that into the user handler. Here, you add a subscriber. The user feature doesn't know and doesn't care. Decoupling that actually works.

Repository Pattern

Clean data access abstracted behind interfaces. Swap Postgres for MongoDB without touching business logic. Tests run against in-memory implementations.

Middleware Pipeline

Auth, validation, error handling, structured logging — already plugged in. Every request goes through the same pipeline. No more "I forgot to add error handling to the new endpoint."

Tests That Matter

Tests live next to the code they test. Radical concept, I know. Unit tests for logic, integration tests for the full slice. Open the feature folder, everything's there — including what proves it works.

Example Features

User registration and order creation — fully working, fully tested. Not empty folders with a README. Real code that hits the database, publishes events, and validates input. Read it, then replicate the pattern for your own features.

// folder structure

What the project looks like

Every feature is a self-contained folder. No hunting across layers.

src/ features/ create-user/ handler.ts // business logic validator.ts // input validation repository.ts // data access events.ts // domain events handler.test.ts // unit tests handler.integration.ts // integration tests place-order/ handler.ts validator.ts repository.ts events.ts handler.test.ts handler.integration.ts shared/ middleware/ // auth, logging, errors events/ // event bus infrastructure database/ // connection, migrations types/ // shared interfaces
// faq

Questions

What's a Vertical Slice architecture?
Instead of organizing code by technical layers (controllers, services, repositories), you organize by feature. Each feature contains everything it needs — from API handler to database access to tests. When you change a feature, you touch one folder instead of 4.
Is this for solo developers or teams?
Both. Solo developers save weeks of setup. Teams get a consistent architecture that makes onboarding fast and code reviews predictable. Everyone follows the same pattern.
Can I modify the code?
That's the point. The chassis is designed to be forked and extended. Clean, commented code with clear boundaries. Add your features following the example pattern.
Why Vertical Slice instead of Clean Architecture?
Honestly? I used Clean Architecture for years and got tired of maintaining interfaces nobody ever swapped. Layers that exist "for testability" but make everything harder to read. Vertical Slice is simpler: each feature owns its stack. If two features share logic, you extract it when you actually need to — not six months before "just in case." Less architecture astronautics, more shipping.
Is this generated by AI?
No. AI can scaffold a project in seconds. It'll also put your business logic in the controller, create circular dependencies between features, and generate tests that test the mock, not the code. Architecture is about trade-offs — knowing what to put where and why. That comes from building real systems, not from pattern matching on GitHub repos.
Do I need the Infra Kits too?
The chassis covers your application architecture. The Infra Kits cover everything around it — CI/CD, monitoring, security, deployment. They work great together but each stands on its own.
// day one, not month one

Write business logic on day one

The foundation's already laid. The patterns are proven. The tests pass. Open the project, read the example features, and start building yours.

Get All 3 Chassis — $449 See individual stacks