Vercel Microfrontends - Next.js Multi-Zones example

An official Vercel example demonstrating production-ready multi-zone microfrontend architecture

This comprehensive example showcases how to build and deploy a multi-zone microfrontend application using Vercel Microfrontends with Next.js App Router. Learn how to architect independent, deployable frontend applications that work together seamlessly while maintaining team autonomy and deployment independence.

Demo URL: https://vercel-microfrontends-multi-zones.vercel.app/

🚀 Deploy to Vercel

Deploy each microfrontend independently to experience the full power of distributed development:

What You'll Learn

This example demonstrates real-world microfrontend patterns and best practices:

• 🏗️ Multi-zone Architecture: Build independent applications that feel like a single experience
• 🔄 Dynamic Routing: Seamlessly route between different microfrontends based on URL patterns
• ⚡ Development Experience: Hot reload across multiple applications simultaneously
• 📦 Shared Dependencies: Efficiently manage common packages and components
• 🚀 Independent Deployments: Deploy each microfrontend without affecting others
• 🎯 Team Autonomy: Enable teams to work independently while maintaining consistency

Understanding Microfrontends

Microfrontends extend the microservices concept to frontend development, allowing you to:

• Scale Development Teams: Multiple teams can work on different parts of the application independently
• Technology Flexibility: Each microfrontend can use different technologies or versions
• Deployment Independence: Deploy features without coordinating with other teams
• Fault Isolation: Issues in one microfrontend don't affect others
• Incremental Upgrades: Modernize parts of your application gradually

Architecture Overview

This example implements a multi-zone architecture where:

Key Components

1. Marketing Application (apps/marketing/)

   • Primary application handling the main website
   • Contains homepage, pricing, and general marketing content
   • Acts as the shell application orchestrating other microfrontends

2. Documentation Application (apps/docs/)

   • Dedicated documentation microfrontend
   • Handles all /docs routes
   • Can be developed and deployed independently

3. Shared Packages (packages/)

   • Common TypeScript configurations
   • Shared ESLint rules and formatting standards
   • Ensures consistency across all applications

Getting Started

Prerequisites

Ensure you have the following installed:

• Node.js 20.x or later
• pnpm 9.4.0 (recommended package manager)
• Git for version control

Local Development Setup

1. Clone the repository:

   1
   git clone https://github.com/vercel-labs/microfrontends-nextjs-app-multi-zone.git
   2
   cd microfrontends-nextjs-app-multi-zone

2. Install dependencies:

   1
   pnpm install

3. Start the development environment:

   1
   pnpm dev

This command starts both applications simultaneously:

• Marketing app: http://localhost:3000
• Documentation app: http://localhost:3001 (automatically proxied through marketing app)

1. Access the application: Open http://localhost:3024 in your browser and navigate between different sections to see the microfrontend routing in action.

Project Structure Deep Dive

1
microfrontends-nextjs-app-multi-zone/
2
├── apps/
3
│   ├── marketing/              # Main application (shell)
4
│   │   ├── app/               # Next.js App Router pages
5
│   │   ├── components/        # UI components
6
│   │   ├── lib/              # Utilities and helpers
7
│   │   ├── microfrontends.json # Routing configuration
8
│   │   └── next.config.ts    # Next.js configuration with MFE setup
9
│   │
10
│   └── docs/                  # Documentation microfrontend
11
│       ├── app/              # Documentation pages
12
│       ├── components/       # Doc-specific components
13
│       ├── lib/             # Documentation utilities
14
│       └── next.config.ts   # Standalone Next.js configuration
15
│
16
├── packages/
17
│   ├── eslint-config-custom/  # Shared linting configuration
18
│   └── ts-config/            # Shared TypeScript configuration
19
│
20
├── package.json              # Root package.json with workspaces
21
├── pnpm-workspace.yaml       # PNPM workspace configuration
22
└── turbo.json               # Turborepo build pipeline

Configuration Files Explained

1
microfrontends.json

This file defines how microfrontends are discovered and routed:

• Applications mapping: Defines each microfrontend and its ports
• Routing rules: Specifies which URLs should be handled by which microfrontend
• Development settings: Local ports and fallback URLs for development

1
next.config.ts

Each application has its own Next.js configuration enhanced with:

• withMicrofrontends(): Enables microfrontend capabilities
• withVercelToolbar(): Adds development debugging tools
• Standard Next.js optimizations and settings

How Microfrontend Routing Works

The magic happens through the @vercel/microfrontends package:

1. Route Discovery

The marketing application (shell) reads the microfrontends.json configuration to understand which routes should be handled by which microfrontend.

2. Dynamic Proxying

When a user navigates to /docs, Vercel Microfrontends:

• Recognizes this route belongs to the documentation microfrontend
• Proxies the request to the documentation application
• Returns the response seamlessly to the user

All routing between microfrontends is handled dynamically by Vercel Microfrontends, allowing for a smooth user experience without page reloads.

3. Development Magic

During development, both applications run simultaneously, and the routing happens transparently, providing a seamless development experience.

4. Production Deployment

In production, each microfrontend is deployed independently to Vercel, and the routing configuration ensures requests are directed to the correct deployment.

Learn more in the routing documentation.

Development Workflow

Working with Individual Microfrontends

You can develop microfrontends in isolation using the microfrontends local development proxy:

1
# Work on the marketing application only
2
cd apps/marketing
3
pnpm dev
4

5
# Work on the documentation application only
6
cd apps/docs
7
pnpm dev

Building and Testing

1
# Build all applications
2
pnpm build
3

4
# Run linting across all apps
5
pnpm lint
6

7
# Type check all applications
8
pnpm typecheck
9

10
# Run all quality checks
11
pnpm checks

Adding New Microfrontends

1. Create a new application in the apps/ directory
2. Update microfrontends.json to include routing rules
3. Add the new app to the workspace configuration
4. Configure deployment settings for the new microfrontend

Learn more in the Managing Microfrontends documentation.

Deployment Strategy

Independent Deployment Benefits

Each microfrontend can be deployed independently, enabling:

• Faster deployments: Only the changed microfrontend needs redeployment
• Reduced risk: Deployments are isolated and can't break other parts
• Team autonomy: Teams can deploy on their own schedule
• Rollback flexibility: Roll back individual microfrontends without affecting others

Vercel Configuration

Each application includes optimized Vercel configuration:

• Framework detection: Automatic Next.js optimization
• Build settings: Turborepo-aware build commands
• Environment variables: Proper environment isolation
• Edge functions: Optimal performance at the edge

Best Practices Implemented

🎯 Consistent Development Experience

• Shared TypeScript configuration ensures type safety across all apps
• Common ESLint rules maintain code quality standards
• Unified prettier configuration for consistent formatting

🔧 Build Optimization

• Turborepo orchestrates builds efficiently with caching
• Shared dependencies reduce bundle duplication
• Independent builds enable faster CI/CD pipelines

🎨 UI Consistency

• Shared component library (Tailwind CSS + shadcn/ui)
• Consistent design tokens across applications
• Reusable UI components prevent design drift

🚀 Performance Optimization

• Code splitting at the microfrontend level
• Independent bundle optimization
• Edge-optimized routing and caching

Advanced Features

Vercel Toolbar Integration

Development builds include the Vercel Toolbar for enhanced debugging:

• Visual indicators of microfrontend boundaries
• Performance metrics and analytics
• Real-time feature flag management

Analytics and Monitoring

Built-in integration with:

• Vercel Analytics: Track user behavior across microfrontends
• Speed Insights: Monitor performance metrics
• Error tracking: Isolated error reporting per microfrontend

Troubleshooting

Common Issues and Solutions

Port conflicts during development:

1
# Kill processes using the required ports
2
npx kill-port 3000 3001
3
pnpm dev

Routing not working in development:

• Verify microfrontends.json configuration
• Ensure all applications are running
• Check console for proxy errors

Build failures:

• Run pnpm typecheck to identify TypeScript issues
• Verify all dependencies are installed correctly
• Check for circular dependencies between applications

Configuration and Components

Next.js Configuration in This Project

Both applications use withMicrofrontends to enable cross-zone routing:

1
// apps/marketing/next.config.ts & apps/docs/next.config.ts
2
import { withMicrofrontends } from '@vercel/microfrontends/next/config';
3
import { withVercelToolbar } from '@vercel/toolbar/plugins/next';
4

5
export default withVercelToolbar()(
6
  withMicrofrontends(nextConfig, { debug: true }),
7
);

Routing Configuration

The marketing app defines how to route to the docs microfrontend:

1
// apps/marketing/microfrontends.json
2
{
3
  "applications": {
4
    "microfrontends-nextjs-app-multi-zone-marketing": {
5
      "development": {
6
        "local": 3000,
7
        "fallback": "microfrontends-nextjs-app-multi-zone-marketing.vercel.app",
8
      },
9
    },
10
    "microfrontends-nextjs-app-multi-zone-docs": {
11
      "development": { "local": 3001 },
12
      "routing": [{ "group": "docs", "paths": ["/docs", "/docs/:path*"] }],
13
    },
14
  },
15
}

Optimizing Cross-Microfrontend Navigation

The @vercel/microfrontends package can be used to prefetch and prerender links to other microfrontends.

First, embed the PrefetchCrossZoneLinksProvider element in the root layout.tsx of your application.

Then, use the enhanced Link component for seamless optimized navigation between zones:

1
// In marketing app - navigating to docs
2
import { Link } from '@vercel/microfrontends/next/client';
3

4
<Link href="/docs">View Documentation</Link>
5
<Link href="/docs/getting-started">Getting Started Guide</Link>

This setup enables the marketing app to seamlessly route /docs requests to the documentation microfrontend while maintaining a unified user experience.

Learn more in the Optimizing Hard Navigations documentation.