CoachnestCoachnest
Sign InGet Started
Back to course

Next.js 16: The Complete Developer Guide

…
—
Contents
1

What's New in Next.js 16

Reading14mFree
2

Installation, CLI & Your First Project

Reading12mFree
3

Project Structure & Conventions Deep Dive

Reading16m
4

Turbopack — The New Default Bundler

Video18m
5

Configuring TypeScript, ESLint & next.config.ts

Reading14m
6

Chapter 1 — Quiz

Quiz10m
7

App Router Fundamentals

Reading16m
8

Dynamic Routes, Catch-Alls & Type-Safe Params

Reading14m
9

Route Groups & Parallel Routes

Reading16m
10

Intercepting Routes & Modal Patterns

Reading12m
11

Loading, Error & Not-Found UI

Reading12m
12

Chapter 2 — Routing Quiz

Quiz12m
13

Understanding the Server/Client Boundary

Reading18m
14

Choosing When to use "use client"

Reading14m
15

Composing Server & Client Components

Reading14m
16

server-only, client-only & Code Splitting

Reading12m
17

Chapter 3 — Quiz

Quiz10m
18

Fetching Data in Server Components

Reading14m
19

The Next.js 16 Cache Model

Reading16m
20

Revalidation: revalidateTag, revalidatePath & On-Demand

Reading12m
21

Cache Components — Building Reusable Cached Functions

Reading14m
22

Search Params, Cookies & Dynamic APIs

Reading12m
23

Chapter 4 — Quiz

Quiz12m
24

Server Actions From First Principles

Reading16m
25

Forms with useActionState & Progressive Enhancement

Reading14m
26

Optimistic UI with useOptimistic

Reading12m
27

Validation with Zod + Server Actions

Reading12m
28

Chapter 5 — Quiz

Quiz10m
29

Static vs Dynamic vs Streaming

Reading14m

generateStaticParams & Pre-Rendering Dynamic Routes

Reading12m
31

Incremental Static Regeneration (ISR)

Reading12m
32

Partial Prerendering (PPR)

Reading16m
33

Edge Runtime vs Node.js Runtime

Reading12m
34

Rendering Strategies Deep Dive

Video22m
35

Chapter 6 — Quiz

Quiz12m
36

Tailwind CSS v4 with Next.js 16

Reading14m
37

CSS Modules, Global Styles & Scoped CSS

Reading10m
38

next/image — Smart, Fast Images

Reading14m
39

Fonts, Icons & Metadata

Reading12m
40

Chapter 7 — Quiz

Quiz10m
41

Middleware Fundamentals

Reading14m
42

Sessions, JWTs & Cookies

Reading16m
43

Protecting Server Components & Server Actions

Reading12m
44

Chapter 8 — Quiz

Quiz10m
45

Prisma with Next.js — The Production Setup

Reading14m
46

Mutations: Server Actions + Database Writes

Reading12m
47

Route Handlers & REST APIs

Reading12m
48

Chapter 9 — Quiz

Quiz10m
49

Unit & Component Testing with Vitest

Reading12m
50

End-to-End Testing with Playwright

Reading14m
51

Deploying to Vercel

Reading12m
52

Self-Hosting with Docker

Reading14m
53

Production Performance Checklist

Reading12m
54

Final Assessment — Next.js 16 Mastery

Quiz20m
←→navigate lessons
Chapter 6 of 10·Chapter 6 — Rendering Strategies: SSG, SSR, ISR & PPR
Lesson 30 of 54Reading12 min

generateStaticParams & Pre-Rendering Dynamic Routes

#generateStaticParams & Pre-Rendering Dynamic Routes¶

For routes like /blog/[slug], you usually want to build all known posts at build time so each is a static HTML file served from a CDN.

The API¶

tsx
11 lines
1// app/blog/[slug]/page.tsx
2export async function generateStaticParams() {
3  const posts = await db.post.findMany({ select: { slug: true } });
4  return posts.map((p) => ({ slug: p.slug }));
5}
6
7export default async function Post({ params }: { params: Promise<{ slug: string }> }) {
8  const { slug } = await params;
9  const post = await getPost(slug);
10  return <Article post={post} />;
11}

At build, Next.js calls generateStaticParams() once, then renders Post for every slug returned. Each becomes a .html file in .next/server/app/blog/<slug>.html.

What About New Slugs After Build?¶

By default (dynamicParams = true), if a user requests an unknown slug, Next.js renders it dynamically — and (if caching is enabled) caches the result for subsequent visitors.

To disallow unknown slugs (404 instead):

ts
1 line
1export const dynamicParams = false;

Multiple Dynamic Segments¶

tsx
5 lines
1// app/blog/[year]/[slug]/page.tsx
2export async function generateStaticParams() {
3  const posts = await db.post.findMany({ select: { year: true, slug: true } });
4  return posts.map((p) => ({ year: String(p.year), slug: p.slug }));
5}

Hierarchical Routes — Build Per Level¶

tsx
8 lines
1// app/[lang]/[category]/[slug]/page.tsx
2export async function generateStaticParams() {
3  return [
4    { lang: "en", category: "tech",   slug: "react-19-is-here"  },
5    { lang: "en", category: "design", slug: "color-systems"      },
6    { lang: "hi", category: "tech",   slug: "react-19-aaya-hai"  },
7  ];
8}

The return is a flat list of {param: value} tuples — Next builds each combination once.

Avoiding Build Times Of Doom¶

For sites with tens of thousands of dynamic pages:

ts
9 lines
1export async function generateStaticParams() {
2  // Pre-render the most popular 1,000 — the long tail renders on-demand
3  return db.post.findMany({
4    where: { status: "PUBLISHED" },
5    orderBy: { views: "desc" },
6    take: 1000,
7    select: { slug: true },
8  });
9}

This is partial pre-rendering of dynamic routes: hot pages are static-fast; rare pages render JIT and then become cached.

generateStaticParams + ISR¶

Combine with a revalidate export to refresh post HTML on a cadence:

ts
1 line
1export const revalidate = 3600;     // hourly

Or use tag-based invalidation from your CMS webhook → revalidateTag(post:${slug}).

Previous

Static vs Dynamic vs Streaming

Next

Incremental Static Regeneration (ISR)

Use ← → arrow keys to navigate between lessons