The key insight: Successfully serving millions of dynamic pages isn't about raw performance—it's about choosing the right rendering strategy for your specific constraints.
The CNPJ Aberto project demonstrates something most developers never encounter: 55 million dynamically generated pages, each with unique SEO metadata for every Brazilian company. This isn't a theoretical scaling exercise—it's a production system that reveals the practical limits and solutions when Next.js meets massive scale.
The Rendering Strategy Puzzle
With 55 million pages, traditional approaches break down quickly. Static Site Generation (SSG) would require pre-building every page at deployment—imagine the build times and storage requirements. Client-side rendering would deliver empty shells to search crawlers, killing SEO. The solution requires a more nuanced approach.
<> The critical realization: At massive scale, you're not optimizing for perfect performance—you're optimizing for sustainable performance that doesn't collapse under load./>
Next.js 15's Incremental Static Regeneration (ISR) becomes the hero here. ISR lets you generate static pages on-demand when users first request them, then cache those pages until they need updating. For a business directory where company information changes periodically but not constantly, this hits the sweet spot.
1// pages/empresa/[cnpj].tsx
2export async function getStaticPaths() {
3 // Don't pre-generate any paths at build time
4 return {
5 paths: [],
6 fallback: 'blocking' // Generate on first request
7 }
8}This approach means the first visitor to each company page experiences slightly slower load times while Next.js generates the static version, but subsequent visitors get blazing-fast cached pages.
SEO Metadata at Scale
Generating unique metadata for 55 million pages presents its own challenges. Each page needs distinct title tags, meta descriptions, OpenGraph images, and JSON-LD structured data. The key is systematic generation that scales without manual intervention.
1interface CompanyMetadata {
2 cnpj: string
3 name: string
4 activity: string
5 city: string
6}
7
8function generateMetadata(company: CompanyMetadata) {The structured approach ensures consistency across millions of pages while making each one unique enough for search engines to properly index and rank.
Performance Under Pressure
Next.js 15 introduces several features that become crucial at this scale. Partial Prerendering (PPR) allows static page shells to load instantly while dynamic content streams in. For company pages with mostly static information but dynamic elements like recent filings or status updates, this maintains perceived performance.
Streaming metadata in Next.js 15.2 prevents metadata generation from blocking page rendering—critical when you're generating complex metadata for millions of pages. The page skeleton can render immediately while metadata populates asynchronously.
1// app/empresa/[cnpj]/page.tsx
2import { Suspense } from 'react'
3
4export async function generateMetadata({ params }) {
5 // This now streams and doesn't block page rendering
6 const company = await fetchCompanyData(params.cnpj)
7 return generateMetadata(company)
8}The Infrastructure Reality
Serving 55 million pages reveals infrastructure considerations most developers never face. Edge caching becomes essential—not just for performance, but for cost control. Without strategic caching, server costs would be astronomical.
Database queries need optimization at a different level. When any query might run millions of times, even microsecond improvements compound significantly. Connection pooling, query optimization, and strategic denormalization become critical.
<> At 55 million pages, every optimization decision gets multiplied by factors most applications never experience. A 10ms improvement per page saves over 150 hours of total server time./>
Lessons for Smaller Scale
Most developers won't build 55-million-page applications, but the principles scale down effectively:
Choose ISR for content that changes predictably: Product catalogs, blog posts, or any content that updates periodically but not constantly benefits from ISR's balance of performance and freshness.
Systematic metadata generation prevents SEO debt: Even with hundreds of pages, manual metadata becomes unmaintainable. Build systematic generation early.
Monitor Core Web Vitals proactively: Performance degradation often appears gradually. At any scale, monitoring prevents problems before they impact users.
Design for edge cases: What happens when your database is slow? When your API is down? Large-scale applications force you to handle these scenarios gracefully.
Why This Matters
The CNPJ Aberto project demonstrates that Next.js can handle truly massive scale when architected thoughtfully. More importantly, it shows that the principles of good web development—strategic caching, systematic SEO, performance monitoring—become amplified at scale rather than fundamentally different.
For developers building smaller applications, these patterns provide a roadmap for sustainable growth. The rendering strategies, metadata systems, and performance optimizations that work at 55 million pages will certainly work at 55 thousand.
The real insight isn't that Next.js can serve millions of pages—it's that with the right architecture, scaling doesn't require completely rebuilding your approach. It requires refining and optimizing the fundamentals you should be doing anyway.
