Incremental Static Regeneration

The foundational rendering method that ISR extends. SSG pre-builds all HTML pages at build time, serving them directly from a CDN. This provides maximum speed and security but requires a full rebuild to update any content. ISR solves this rigidity by allowing per-page updates without a full redeployment.

• Build Time: All pages generated once.
• Update Trigger: Requires a new git push and full build.
• Use Case: Marketing pages, documentation that rarely changes.

SSR generates HTML on the server for every single request. This ensures content is always fresh but introduces latency as the server must compute the page before responding. ISR offers a middle ground: serving a statically cached page while revalidating it in the background, combining the speed of a CDN with the freshness of SSR.

• Time to First Byte (TTFB): Higher than ISR due to server compute.
• Caching: Typically relies on Cache-Control headers.
• Use Case: User dashboards, shopping carts with real-time data.

The HTTP caching directive that inspired ISR's logic. The Cache-Control: stale-while-revalidate header instructs a CDN to serve a stale cached response immediately while asynchronously fetching a fresh version in the background. ISR implements this pattern at the application framework level, allowing the regeneration of static HTML files rather than just API responses.

• HTTP Header: Cache-Control: max-age=1, stale-while-revalidate=59.
• User Experience: Instant load, never waiting for the server.
• Mechanism: Background update populates the cache for the next visitor.

Serverless functions that run at the edge of the CDN network, close to the user. While ISR handles the regeneration of full pages, Edge Functions can be used to personalize those static shells by injecting dynamic, user-specific data (like authentication state) at the edge without sacrificing the performance benefits of a cached base page.

• Runtime: V8 Isolates or WebAssembly.
• Latency: Single-digit milliseconds.
• Synergy: ISR for the public page shell, Edge Functions for private data.

The process of purging or updating cached content when the origin data changes. ISR provides a programmatic alternative to manual cache invalidation. Instead of purging a CDN cache via an API call, a developer can trigger an on-demand revalidation of a specific page path, ensuring the CDN is updated atomically without complex purge logic.

• Traditional Method: API calls to CDN providers.
• ISR Method: res.revalidate('/path') in Next.js.
• Granularity: Per-page, not entire site.

The client-side process where JavaScript attaches event listeners and state to the static HTML sent by the server. An ISR page is still a fully static HTML file at first; after it loads in the browser, the JavaScript bundle hydrates it to make it interactive. This preserves the fast First Contentful Paint (FCP) of static content while enabling rich client-side functionality.

• Process: React attaches to existing DOM nodes.
• Mismatch Risk: Server and client state must align.
• Performance: ISR optimizes the pre-hydration phase.