Incremental Static Regeneration (ISR)

ISR operates on a stale-while-revalidate caching strategy. When a request arrives for a page that is older than the configured revalidate interval, the cached (stale) version is served immediately. Simultaneously, a background process triggers a regeneration of the page. The newly generated page replaces the stale cache entry for all subsequent requests.

• Immediate Response: Users never wait for a build; they always get a fast static response.
• Background Update: The regeneration happens asynchronously, decoupling the user request from the build process.
• Atomic Swap: The cache is updated atomically once the new page is fully generated, preventing partial content flashes.

Beyond time-based intervals, ISR supports on-demand revalidation via a secret API endpoint. When a headless CMS or database triggers a webhook—such as after a content update—the specific page path is purged from the cache and immediately regenerated on the next request.

• Event-Driven: Eliminates the lag of waiting for a fixed time interval to expire.
• Granular Control: Only the affected page is revalidated, not the entire site.
• Sitemap Sync: Ensures that the sitemap reflects the most current URL inventory immediately after a content change.

ISR provides a fallback mechanism for pages that haven't been generated yet. When a request hits a path not in the initial build cache, the server can either serve a fallback state (like a skeleton loader) while generating the page on-demand, or return a 404.

• fallback: true: Serves a loading state and generates the page in the background, adding it to the cache permanently.
• fallback: 'blocking': Waits for the page to be generated on the server before sending the response, with no loading state shown to the user.
• Large Site Efficiency: Allows sites with millions of pages to build only the most critical paths at compile time, generating the long tail on first access.

ISR integrates directly with edge caching infrastructure. When a page is revalidated, the invalidation signal propagates globally across a CDN's points of presence (PoPs). This ensures that users worldwide receive the updated content without waiting for regional cache expiration.

• Global Propagation: Cache invalidation is distributed to all edge nodes, not just the origin.
• Surrogate Key Tagging: Advanced implementations use cache tags to group and purge related pages simultaneously.
• Sitemap Freshness: A dynamic sitemap generated at the edge can query the cache state to list only valid, fresh URLs.

ISR decouples the build time from the data freshness. Pages are generated using getStaticProps which fetches data at build time, but the revalidate property instructs the server to treat that data as a cache with a defined TTL.

• Hybrid Model: Combines the performance of static HTML with the flexibility of server-rendered data.
• Database Independence: The origin database is only queried during regeneration, not on every user request, reducing load.
• Sitemap Alignment: A database-to-sitemap pipeline can use the same revalidate logic to regenerate the sitemap index whenever underlying content records change.

For sites with 100,000+ pages, a full static build is computationally prohibitive. ISR enables an incremental approach where only a subset of pages is pre-rendered at compile time. The remaining pages are generated and cached lazily on first request.

• O(1) Build Times: The initial build time remains constant regardless of the total number of pages.
• Long Tail Coverage: Every dynamically generated page is permanently cached after first access, behaving identically to a pre-rendered page.
• Sitemap Sharding: A sitemap index can reference delta sitemaps that are regenerated incrementally as new pages enter the cache.