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
30

generateStaticParams & Pre-Rendering Dynamic Routes

Reading12m
31

Incremental Static Regeneration (ISR)

Reading12m

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 32 of 54Reading16 min

Partial Prerendering (PPR)

#Partial Prerendering (PPR)¶

Partial Prerendering combines a static shell with dynamic "holes" that stream in at request time. It's the closest thing Next.js has to a silver bullet.

What PPR Looks Like¶

Visit a homepage:

0 ms — HTML arrives: navbar, hero, layout — all static, cached on the CDN 50 ms — page is interactive; static content paints 50–250 ms — dynamic holes stream in: user badge, cart count, personalized feed

The user sees something instantly. The dynamic bits arrive a moment later — over the same response stream.

Enabling PPR¶

Per-route in Next.js 16:

ts
2 lines
1// app/page.tsx
2export const experimental_ppr = true;

Or globally:

ts
4 lines
1// next.config.ts
2const config: NextConfig = {
3  experimental: { ppr: "incremental" },
4};

"incremental" means: only routes that explicitly opt in get PPR. true means: all routes.

The Code Pattern¶

The static shell is the page body. Dynamic content goes inside a <Suspense>:

tsx
16 lines
1import { Suspense } from "react";
2
3export const experimental_ppr = true;
4
5export default function HomePage() {
6  return (
7    <main>
8      <Hero />                                      {/* static */}
9      <FeaturedSection />                            {/* static */}
10      <Suspense fallback={<UserBadgeSkeleton />}>
11        <UserBadge />                                {/* dynamic — reads cookies */}
12      </Suspense>
13      <Footer />                                     {/* static */}
14    </main>
15  );
16}

When Next.js builds, it pre-renders everything outside <Suspense> to static HTML. At request time, only the UserBadge work happens — its HTML streams into the document via a <template> tag.

What Counts as Dynamic?¶

Inside a <Suspense> boundary, you can use any dynamic API:

  • cookies(), headers(), draftMode()
  • searchParams access (via props)
  • fetch(url, { cache: "no-store" })
  • Any uncached DB query

Outside the boundary: stick to static.

A Real Pattern — Personalized Marketing Page¶

tsx
16 lines
1export const experimental_ppr = true;
2
3export default function Home() {
4  return (
5    <>
6      <Hero />
7      <ValueProps />
8      <Suspense fallback={<PricingSkeleton />}>
9        <PersonalizedPricing />     {/* fetches per visitor */}
10      </Suspense>
11      <Testimonials />              {/* static */}
12      <FAQ />                       {/* static */}
13      <CTA />
14    </>
15  );
16}

The marketing page can still serve from a CDN at the edge — only the pricing fragment hits the origin.

Caveats¶

  • The route opts in as a whole. You can't PPR-enable half a route file.
  • Layouts must not be dynamic; only pages and components inside Suspense can be.
  • The Edge runtime is supported but has cold-start tradeoffs.

Verifying PPR Is Working¶

After next build watch for the ◐ (partial) symbol next to your route:

Route (app) ◐ / (static shell + dynamic holes)

Open the page in incognito and watch DevTools' Network tab — you'll see a single HTML response stream with multiple sections delivered in chunks.

Previous

Incremental Static Regeneration (ISR)

Next

Edge Runtime vs Node.js Runtime

Use ← → arrow keys to navigate between lessons