App Router

The routing system built on the app/ directory, React Server Components, layouts, and nested routing — the current default for new Next.js projects

Pages Router

The original routing system built on the pages/ directory, where every file maps to a route and data is fetched via getServerSideProps/getStaticProps

Server Component

A component that renders on the server and sends only its output (HTML plus a serialized description) to the client — the default for everything under app/

Client Component

A component marked with 'use client' that is hydrated and can run interactive JavaScript (state, effects, event handlers) in the browser

Server Action

An async function marked 'use server' that runs on the server but can be called directly from client code, typically to perform a mutation

Route Handler

A route.ts file that defines request-method functions (GET, POST, etc.) to build a real API endpoint, the App Router equivalent of a Pages Router API route

Hydration

The process of attaching React's event listeners and interactive behavior to server-rendered HTML already present in the page, making it interactive

RSC Payload

The compact, serialized description of rendered Server Components that Next.js sends to the client so it can reconcile the tree without re-fetching everything

Streaming

Sending a page to the browser in pieces as each part becomes ready, instead of waiting for the entire page to finish rendering before sending anything

Suspense Boundary

A <Suspense> wrapper around a slow piece of UI that lets the rest of the page render and stream immediately while that piece's fallback shows in its place

ISR (Incremental Static Regeneration)

A caching strategy where a static page is regenerated in the background after a configured time interval, so it stays static but does not go stale forever

SSG (Static Site Generation)

Rendering a page to HTML at build time, once, so every request is served the same pre-built file

SSR (Server-Side Rendering)

Rendering a page to HTML on the server for every incoming request, so the content reflects the latest data at request time

Middleware

Code in middleware.ts that runs before a request completes routing, used for redirects, rewrites, header manipulation, and auth checks

Edge Runtime

A lightweight JavaScript runtime (not full Node.js) that can run Middleware and some Route Handlers closer to the user, at the cost of a smaller API surface

generateStaticParams

A function exported from a dynamic route segment that returns the list of param values to pre-render at build time

Data Cache

Next.js's persistent cache for fetch results across requests and deployments, controlled by a request's cache and next.revalidate options

Full Route Cache

A build-time cache of the rendered HTML and RSC payload for static routes, served without re-rendering until invalidated

Router Cache

A client-side, in-memory cache the App Router keeps of visited route segments, enabling instant back/forward navigation without a fresh server request

Request Memoization

React deduplicating identical fetch calls made multiple times during a single render pass, so the same request is not sent to the network twice

Route Segment

One level of a URL path represented by a folder in app/ — app/blog/[slug]/page.tsx has segments blog and [slug]

Dynamic Route

A route segment named with square brackets, like [id], that matches any value at that position in the URL and exposes it via params

Catch-All Route

A dynamic segment written as [...slug] that matches any number of remaining path segments and exposes them as an array

Route Group

A folder wrapped in parentheses, like (marketing), used to organize routes or apply a shared layout without adding a segment to the URL

Parallel Route

A named slot, defined with an @folder convention, that renders alongside its sibling routes inside the same layout — used for things like independently-loading dashboard panels

Intercepting Route

A route defined with (..) style conventions that renders a different UI (often a modal) when navigated to from within the app, while still resolving to its own full page on a direct visit or refresh