Next.js 16 in Enterprise: Ten Apps, One Monorepo, Five Developers

TLDR

A 10-developer team shipped 10 Next.js applications in a single monorepo faster than anyone expected. The architecture: Server Components communicating with Kotlin/Go microservices via gRPC, shared UI packages, and pnpm catalog configuration for seamless version upgrades. The key insight: consistent architectural patterns made AI tools genuinely helpful instead of chaotic.

The Enterprise Setup

Six months ago, an enterprise greenfield initiative needed someone to shape both architecture and development culture from day one. The goal: build a platform with 10 separate Next.js applications living in a single monorepo.

Each app handled a different subdomain of the product. Behind them sat a shared microservice backend written in Kotlin and Go.

The team: just 10 developers total, with 5 on the Next.js "frontend."

The Monorepo Architecture

The monorepo quickly became the team's biggest strength:

Shared Packages

All 10 apps share:

Central UI package
AI agent toolkit
Markdown processing package
Various cross-project helpers

Result: New features, design updates, and improvements roll out across all applications automatically.

Version Management with pnpm Catalogs

When upgrading to Next.js 16, the team didn't dig through 20+ individual package.json files. Instead, the entire version upgrade was handled by adjusting a single pnpm catalog configuration.

One change. Every app aligned instantly.

Server Components + Microservices

The architecture applies the "API Layer → Service Layer → Data Layer" pattern, but instead of calling a database directly:

Next.js backend communicates with microservices through a typed gRPC interface
Server Components and Server Actions handle the full stack
Data Layer inside Next.js performs gRPC requests to microservice facades

This maintains the same layered architecture patterns while integrating with enterprise microservices.

Why It Worked

Consistent Architecture Enables Speed

Having shared architectural patterns meant that everyone—from new hires to AI tools—could follow the same structure without friction.

Development felt smooth, predictable, and strangely calm for a project of this scale.

AI Agents Became Helpful

The structure made AI agents genuinely helpful instead of chaotic. With consistent patterns across 10 applications:

AI tools understand the codebase structure
Generated code follows established conventions
Code review and refactoring suggestions align with team practices

Small Team, High Velocity

A 5-person frontend team shipped 10 applications that were "already drawing attention from teams across the company."

The secret: consistent patterns that compound. Each new pattern established benefits all 10 apps simultaneously.

Key Architectural Decisions

Monorepo with shared packages: UI components, utilities, and tooling shared across all apps. Change once, deploy everywhere.
pnpm catalog for version management: Single configuration controls all dependency versions. Framework upgrades become single-line changes.
Server Components throughout: Consistent data flow pattern from components to backend services.
Typed gRPC interface: Type safety from frontend to microservices. Errors caught at compile time, not runtime.
Layered architecture pattern: API → Service → Data layer structure applied consistently, even when the "data" is gRPC requests.

Key Takeaways

Monorepo architecture multiplies team velocity. Shared packages mean improvements benefit all applications simultaneously.
Consistent patterns enable AI assistance. When code follows predictable structures, AI tools become helpful rather than disruptive.
Server Components work with microservices. The layered architecture pattern adapts—your Data Layer makes gRPC calls instead of database queries.
pnpm catalogs simplify version management. Framework upgrades across 20+ packages become single-line changes.
Small teams can move fast at enterprise scale. Architecture patterns and tooling choices determine velocity more than headcount.

🔗 Links

The Road to Next: Black Friday