Episode 2 — React Frontend Architecture NextJS / 2.19 — Rendering Strategies in NextJS

2.19.c — Incremental Static Regeneration (ISR)

In one sentence: ISR serves cached static pages but refreshes them on a schedule or on-demand so you avoid full rebuilds while accepting bounded staleness.

Navigation: ← SSG · → 2.19 Overview

1. What ISR Solves

ISR keeps most benefits of SSG (fast CDN, high hit rate) while allowing periodic or on-demand refresh without rebuilding the entire site.

1.1 Stale-while-revalidate mental model

At a high level:

Serve cached static page immediately (fast).
After a revalidate interval, the next request may still get stale HTML while a background regeneration runs.
Once regeneration completes, subsequent visitors get fresh HTML.

Interview phrase: "Users can see slightly stale content bounded by your SLA; you trade absolute freshness for cost and performance."

1.2 Pages Router: `revalidate: N`

export async function getStaticProps() {
  const post = await loadPost();
  return { props: { post }, revalidate: 300 };
}

1.3 App Router equivalents (conceptual)

Caching moved toward fetch options (next: { revalidate: N }), segment config, and tag/path revalidation APIs. Always align explanations with the Next version you deploy.

1.4 On-demand revalidation

CMS publishes → webhook → revalidatePath / revalidateTag. Great for editor expectations ("I clicked publish, it's live").

1.5 Failure modes

Background regen fails → users may keep seeing stale until retry succeeds.
Misconfigured tags → blast radius too wide/narrow.
Thundering herd when many edges miss cache simultaneously.

1.6 ISR vs SSR decision matrix

Need	Lean
Sub-second freshness	SSR or client
Minutes/hours staleness OK	ISR
Legal must be instant	SSR or client-gated

1.7 Observability

Track age of served HTML, revalidation success rate, and origin load during spikes.

1.8 Tag graph design (advanced)

Treat tags like reverse dependencies. If a page shows User, OrderSummary, and PromoBanner, decide whether one tag (user:123) invalidates only profile routes or also any page embedding that widget. Narrow tags reduce unnecessary origin hits; wide tags simplify mental models but increase cache churn.

Pattern	Tag example	When it shines
Entity-centric	`product:SKU-42`	PDP, wishlists, search tiles all refresh together
Route-centric	`path:/blog`	Simple sites; coarse invalidation
Time-window	`prices:2026-04-11`	Intraday pricing batches

1.9 Double invalidation (time-based + on-demand)

Using both a short revalidate window and webhooks is valid when:

Editors need instant updates (webhook path).
Anonymous visitors still get protection if the webhook fails (time-based path eventually heals).

Document precedence: which wins when both fire within the same second? (Depends on platform implementation — say honestly in interviews and point to docs for your deployed version.)

1.10 Deleted content and HTTP semantics

ISR caches success representations. If a CMS deletes an article:

Cached 200 may persist until revalidation.
Mitigation: on delete webhook, call revalidation and optionally push a 410 Gone static replacement on next regen, or move deletes to SSR for sensitive compliance.

1.11 Thundering herd sketch

When many PoPs simultaneously detect expiry, you can stampede the origin.

Mitigations (conceptual):

Jitter revalidation windows per route shard.
Single-flight deduplication at origin (common in data loaders).
Warm critical paths after deploy via synthetic traffic.

1.12 Deploy + ISR interaction

New deployment changes component code while CDN may still serve old HTML referencing old hashed assets briefly. Teams mitigate with immutable asset hosting and consistent versioning so old HTML keeps working until HTML itself refreshes.

1.13 Personalized fragments on ISR pages

Danger: caching HTML that embeds user-specific prices. Patterns:

Keep personalized pieces client-fetched after static shell.
Or use SSR for those segments with no-store.
Or edge personalization (advanced) with strict cache keying.

1.14 ISR for JSON Route Handlers?

Sometimes teams cache GET JSON responses at CDN with s-maxage similar to ISR semantics. Mentally relate: HTTP cache headers on APIs vs page ISR — same CDN physics, different framework knobs.

1.15 SLA template (copy for RFCs)

Freshness SLA:
  - Marketing pages: <= 15 minutes stale (ISR 900)
  - Product price: <= 60 seconds (SSR segment or client overlay)
  - Legal docs: immediate after publish (on-demand revalidate + verify)
Rollback:
  - Increase revalidate window if origin unstable
  - Fall back to SSR for single critical route

1.16 Interview story arc: “Black Friday”

Setup: Product grid ISR 5 minutes; inventory sells out faster.

Answer: Static segment for non-inventory content; inventory badge via short TTL client fetch or SSR micro-segment; optionally edge config feature flag to flip route to SSR under load.

1.17 Metrics dashboard (what to chart)

Staleness histogram (time since last-modified equivalent).
Regeneration failures / minute.
Origin CPU correlated with deploys.
CDN hit ratio per route class.

1.18 Comparison to “pure” SSG + cron rebuild

Approach	Pros	Cons
ISR	Incremental cost	Complex mental model
Nightly full rebuild	Simple	Not real-time; huge builds

1.19 Testing ISR behavior

Use integration tests that:

Request page twice with controlled clocks or webhook triggers.
Assert response headers or embedded build id / data timestamp when you stamp them for tests.

1.20 Glossary (speak precisely)

Origin: Your Next server / serverless function backing regeneration.
PoP: CDN edge point-of-presence serving cached HTML.
SWR (conceptual): Serve stale while fetching fresh — ISR is in this family.

Part 2 — Deep Encyclopedia (Incremental Static Regeneration (ISR))

How to use this section: Read sequentially or jump by drill number. Each block has a scenario, a prompt (what an interviewer might ask), a model answer, and often a code sketch.

E001 — ISR drill 1: Stale content served 10 minutes

Scenario: Stale content served 10 minutes — support complains 'I published'. (variation 1: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #1.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #1, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E002 — ISR drill 2: On-demand revalidation webhook from CMS

Scenario: On-demand revalidation webhook from CMS — signature verification. (variation 2: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #2.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #2, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E003 — ISR drill 3: `revalidate: 60` vs `revalidatePath` after mutation

Scenario: revalidate: 60 vs revalidatePath after mutation — double invalidation? (variation 3: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #3.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #3, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E004 — ISR drill 4: ISR page deleted in CMS

Scenario: ISR page deleted in CMS — still 200 with stale body until revalidate. (variation 4: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #4.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #4, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E005 — ISR drill 5: High-traffic article

Scenario: High-traffic article — thundering herd on first request after expiry. (variation 5: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #5.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #5, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E006 — ISR drill 6: Tag-based revalidation shared across 50 pages

Scenario: Tag-based revalidation shared across 50 pages — blast radius. (variation 6: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #6.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #6, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E007 — ISR drill 7: Background revalidation fails silently

Scenario: Background revalidation fails silently — how to detect? (variation 7: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #7.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #7, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E008 — ISR drill 8: Deploy new code while old HTML references old chunk hashes.

Scenario: Deploy new code while old HTML references old chunk hashes. (variation 8: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #8.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #8, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E009 — ISR drill 9: ISR + personalized cookie banner

Scenario: ISR + personalized cookie banner — cache poisoning risk. (variation 9: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #9.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #9, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E010 — ISR drill 10: Choosing ISR vs SSR for stock ticker that updates every second.

Scenario: Choosing ISR vs SSR for stock ticker that updates every second. (variation 10: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #10.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #10, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E011 — ISR drill 11: Stale content served 10 minutes

Scenario: Stale content served 10 minutes — support complains 'I published'. (variation 11: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #11.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #11, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E012 — ISR drill 12: On-demand revalidation webhook from CMS

Scenario: On-demand revalidation webhook from CMS — signature verification. (variation 12: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #12.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #12, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E013 — ISR drill 13: `revalidate: 60` vs `revalidatePath` after mutation

Scenario: revalidate: 60 vs revalidatePath after mutation — double invalidation? (variation 13: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #13.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #13, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E014 — ISR drill 14: ISR page deleted in CMS

Scenario: ISR page deleted in CMS — still 200 with stale body until revalidate. (variation 14: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #14.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #14, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E015 — ISR drill 15: High-traffic article

Scenario: High-traffic article — thundering herd on first request after expiry. (variation 15: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #15.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #15, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E016 — ISR drill 16: Tag-based revalidation shared across 50 pages

Scenario: Tag-based revalidation shared across 50 pages — blast radius. (variation 16: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #16.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #16, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E017 — ISR drill 17: Background revalidation fails silently

Scenario: Background revalidation fails silently — how to detect? (variation 17: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #17.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #17, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E018 — ISR drill 18: Deploy new code while old HTML references old chunk hashes.

Scenario: Deploy new code while old HTML references old chunk hashes. (variation 18: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #18.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #18, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E019 — ISR drill 19: ISR + personalized cookie banner

Scenario: ISR + personalized cookie banner — cache poisoning risk. (variation 19: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #19.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #19, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E020 — ISR drill 20: Choosing ISR vs SSR for stock ticker that updates every second.

Scenario: Choosing ISR vs SSR for stock ticker that updates every second. (variation 20: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #20.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #20, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E021 — ISR drill 21: Stale content served 10 minutes

Scenario: Stale content served 10 minutes — support complains 'I published'. (variation 21: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #21.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #21, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E022 — ISR drill 22: On-demand revalidation webhook from CMS

Scenario: On-demand revalidation webhook from CMS — signature verification. (variation 22: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #22.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #22, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E023 — ISR drill 23: `revalidate: 60` vs `revalidatePath` after mutation

Scenario: revalidate: 60 vs revalidatePath after mutation — double invalidation? (variation 23: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #23.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #23, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E024 — ISR drill 24: ISR page deleted in CMS

Scenario: ISR page deleted in CMS — still 200 with stale body until revalidate. (variation 24: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #24.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #24, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E025 — ISR drill 25: High-traffic article

Scenario: High-traffic article — thundering herd on first request after expiry. (variation 25: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #25.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #25, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E026 — ISR drill 26: Tag-based revalidation shared across 50 pages

Scenario: Tag-based revalidation shared across 50 pages — blast radius. (variation 26: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #26.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #26, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E027 — ISR drill 27: Background revalidation fails silently

Scenario: Background revalidation fails silently — how to detect? (variation 27: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #27.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #27, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E028 — ISR drill 28: Deploy new code while old HTML references old chunk hashes.

Scenario: Deploy new code while old HTML references old chunk hashes. (variation 28: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #28.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #28, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E029 — ISR drill 29: ISR + personalized cookie banner

Scenario: ISR + personalized cookie banner — cache poisoning risk. (variation 29: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #29.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #29, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E030 — ISR drill 30: Choosing ISR vs SSR for stock ticker that updates every second.

Scenario: Choosing ISR vs SSR for stock ticker that updates every second. (variation 30: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #30.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #30, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E031 — ISR drill 31: Stale content served 10 minutes

Scenario: Stale content served 10 minutes — support complains 'I published'. (variation 31: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #31.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #31, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E032 — ISR drill 32: On-demand revalidation webhook from CMS

Scenario: On-demand revalidation webhook from CMS — signature verification. (variation 32: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #32.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #32, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E033 — ISR drill 33: `revalidate: 60` vs `revalidatePath` after mutation

Scenario: revalidate: 60 vs revalidatePath after mutation — double invalidation? (variation 33: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #33.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #33, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E034 — ISR drill 34: ISR page deleted in CMS

Scenario: ISR page deleted in CMS — still 200 with stale body until revalidate. (variation 34: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #34.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #34, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E035 — ISR drill 35: High-traffic article

Scenario: High-traffic article — thundering herd on first request after expiry. (variation 35: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #35.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #35, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E036 — ISR drill 36: Tag-based revalidation shared across 50 pages

Scenario: Tag-based revalidation shared across 50 pages — blast radius. (variation 36: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #36.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #36, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E037 — ISR drill 37: Background revalidation fails silently

Scenario: Background revalidation fails silently — how to detect? (variation 37: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #37.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #37, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E038 — ISR drill 38: Deploy new code while old HTML references old chunk hashes.

Scenario: Deploy new code while old HTML references old chunk hashes. (variation 38: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #38.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #38, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E039 — ISR drill 39: ISR + personalized cookie banner

Scenario: ISR + personalized cookie banner — cache poisoning risk. (variation 39: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #39.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #39, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E040 — ISR drill 40: Choosing ISR vs SSR for stock ticker that updates every second.

Scenario: Choosing ISR vs SSR for stock ticker that updates every second. (variation 40: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #40.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #40, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E041 — ISR drill 41: Stale content served 10 minutes

Scenario: Stale content served 10 minutes — support complains 'I published'. (variation 41: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #41.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #41, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E042 — ISR drill 42: On-demand revalidation webhook from CMS

Scenario: On-demand revalidation webhook from CMS — signature verification. (variation 42: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #42.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #42, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E043 — ISR drill 43: `revalidate: 60` vs `revalidatePath` after mutation

Scenario: revalidate: 60 vs revalidatePath after mutation — double invalidation? (variation 43: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #43.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #43, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E044 — ISR drill 44: ISR page deleted in CMS

Scenario: ISR page deleted in CMS — still 200 with stale body until revalidate. (variation 44: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #44.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #44, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E045 — ISR drill 45: High-traffic article

Scenario: High-traffic article — thundering herd on first request after expiry. (variation 45: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #45.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #45, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E046 — ISR drill 46: Tag-based revalidation shared across 50 pages

Scenario: Tag-based revalidation shared across 50 pages — blast radius. (variation 46: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #46.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #46, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E047 — ISR drill 47: Background revalidation fails silently

Scenario: Background revalidation fails silently — how to detect? (variation 47: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #47.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #47, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E048 — ISR drill 48: Deploy new code while old HTML references old chunk hashes.

Scenario: Deploy new code while old HTML references old chunk hashes. (variation 48: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #48.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #48, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E049 — ISR drill 49: ISR + personalized cookie banner

Scenario: ISR + personalized cookie banner — cache poisoning risk. (variation 49: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #49.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #49, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E050 — ISR drill 50: Choosing ISR vs SSR for stock ticker that updates every second.

Scenario: Choosing ISR vs SSR for stock ticker that updates every second. (variation 50: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #50.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #50, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E051 — ISR drill 51: Stale content served 10 minutes

Scenario: Stale content served 10 minutes — support complains 'I published'. (variation 51: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #51.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #51, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E052 — ISR drill 52: On-demand revalidation webhook from CMS

Scenario: On-demand revalidation webhook from CMS — signature verification. (variation 52: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #52.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #52, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E053 — ISR drill 53: `revalidate: 60` vs `revalidatePath` after mutation

Scenario: revalidate: 60 vs revalidatePath after mutation — double invalidation? (variation 53: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #53.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #53, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E054 — ISR drill 54: ISR page deleted in CMS

Scenario: ISR page deleted in CMS — still 200 with stale body until revalidate. (variation 54: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #54.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #54, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E055 — ISR drill 55: High-traffic article

Scenario: High-traffic article — thundering herd on first request after expiry. (variation 55: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #55.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #55, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E056 — ISR drill 56: Tag-based revalidation shared across 50 pages

Scenario: Tag-based revalidation shared across 50 pages — blast radius. (variation 56: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #56.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #56, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E057 — ISR drill 57: Background revalidation fails silently

Scenario: Background revalidation fails silently — how to detect? (variation 57: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #57.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #57, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E058 — ISR drill 58: Deploy new code while old HTML references old chunk hashes.

Scenario: Deploy new code while old HTML references old chunk hashes. (variation 58: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #58.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #58, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E059 — ISR drill 59: ISR + personalized cookie banner

Scenario: ISR + personalized cookie banner — cache poisoning risk. (variation 59: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #59.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #59, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E060 — ISR drill 60: Choosing ISR vs SSR for stock ticker that updates every second.

Scenario: Choosing ISR vs SSR for stock ticker that updates every second. (variation 60: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #60.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #60, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E061 — ISR drill 61: Stale content served 10 minutes

Scenario: Stale content served 10 minutes — support complains 'I published'. (variation 61: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #61.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #61, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E062 — ISR drill 62: On-demand revalidation webhook from CMS

Scenario: On-demand revalidation webhook from CMS — signature verification. (variation 62: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #62.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #62, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E063 — ISR drill 63: `revalidate: 60` vs `revalidatePath` after mutation

Scenario: revalidate: 60 vs revalidatePath after mutation — double invalidation? (variation 63: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #63.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #63, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E064 — ISR drill 64: ISR page deleted in CMS

Scenario: ISR page deleted in CMS — still 200 with stale body until revalidate. (variation 64: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #64.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #64, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E065 — ISR drill 65: High-traffic article

Scenario: High-traffic article — thundering herd on first request after expiry. (variation 65: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #65.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #65, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E066 — ISR drill 66: Tag-based revalidation shared across 50 pages

Scenario: Tag-based revalidation shared across 50 pages — blast radius. (variation 66: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #66.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #66, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E067 — ISR drill 67: Background revalidation fails silently

Scenario: Background revalidation fails silently — how to detect? (variation 67: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #67.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #67, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E068 — ISR drill 68: Deploy new code while old HTML references old chunk hashes.

Scenario: Deploy new code while old HTML references old chunk hashes. (variation 68: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #68.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #68, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E069 — ISR drill 69: ISR + personalized cookie banner

Scenario: ISR + personalized cookie banner — cache poisoning risk. (variation 69: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #69.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #69, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E070 — ISR drill 70: Choosing ISR vs SSR for stock ticker that updates every second.

Scenario: Choosing ISR vs SSR for stock ticker that updates every second. (variation 70: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #70.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #70, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E071 — ISR drill 71: Stale content served 10 minutes

Scenario: Stale content served 10 minutes — support complains 'I published'. (variation 71: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #71.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #71, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E072 — ISR drill 72: On-demand revalidation webhook from CMS

Scenario: On-demand revalidation webhook from CMS — signature verification. (variation 72: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #72.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #72, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E073 — ISR drill 73: `revalidate: 60` vs `revalidatePath` after mutation

Scenario: revalidate: 60 vs revalidatePath after mutation — double invalidation? (variation 73: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #73.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #73, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E074 — ISR drill 74: ISR page deleted in CMS

Scenario: ISR page deleted in CMS — still 200 with stale body until revalidate. (variation 74: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #74.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #74, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E075 — ISR drill 75: High-traffic article

Scenario: High-traffic article — thundering herd on first request after expiry. (variation 75: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #75.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #75, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E076 — ISR drill 76: Tag-based revalidation shared across 50 pages

Scenario: Tag-based revalidation shared across 50 pages — blast radius. (variation 76: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #76.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #76, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E077 — ISR drill 77: Background revalidation fails silently

Scenario: Background revalidation fails silently — how to detect? (variation 77: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #77.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #77, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E078 — ISR drill 78: Deploy new code while old HTML references old chunk hashes.

Scenario: Deploy new code while old HTML references old chunk hashes. (variation 78: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #78.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #78, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E079 — ISR drill 79: ISR + personalized cookie banner

Scenario: ISR + personalized cookie banner — cache poisoning risk. (variation 79: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #79.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #79, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E080 — ISR drill 80: Choosing ISR vs SSR for stock ticker that updates every second.

Scenario: Choosing ISR vs SSR for stock ticker that updates every second. (variation 80: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #80.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #80, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E081 — ISR drill 81: Stale content served 10 minutes

Scenario: Stale content served 10 minutes — support complains 'I published'. (variation 81: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #81.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #81, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E082 — ISR drill 82: On-demand revalidation webhook from CMS

Scenario: On-demand revalidation webhook from CMS — signature verification. (variation 82: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #82.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #82, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E083 — ISR drill 83: `revalidate: 60` vs `revalidatePath` after mutation

Scenario: revalidate: 60 vs revalidatePath after mutation — double invalidation? (variation 83: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #83.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #83, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E084 — ISR drill 84: ISR page deleted in CMS

Scenario: ISR page deleted in CMS — still 200 with stale body until revalidate. (variation 84: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #84.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #84, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E085 — ISR drill 85: High-traffic article

Scenario: High-traffic article — thundering herd on first request after expiry. (variation 85: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #85.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #85, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E086 — ISR drill 86: Tag-based revalidation shared across 50 pages

Scenario: Tag-based revalidation shared across 50 pages — blast radius. (variation 86: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #86.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #86, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E087 — ISR drill 87: Background revalidation fails silently

Scenario: Background revalidation fails silently — how to detect? (variation 87: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #87.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #87, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E088 — ISR drill 88: Deploy new code while old HTML references old chunk hashes.

Scenario: Deploy new code while old HTML references old chunk hashes. (variation 88: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #88.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #88, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E089 — ISR drill 89: ISR + personalized cookie banner

Scenario: ISR + personalized cookie banner — cache poisoning risk. (variation 89: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #89.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #89, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E090 — ISR drill 90: Choosing ISR vs SSR for stock ticker that updates every second.

Scenario: Choosing ISR vs SSR for stock ticker that updates every second. (variation 90: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #90.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #90, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E091 — ISR drill 91: Stale content served 10 minutes

Scenario: Stale content served 10 minutes — support complains 'I published'. (variation 91: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #91.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #91, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E092 — ISR drill 92: On-demand revalidation webhook from CMS

Scenario: On-demand revalidation webhook from CMS — signature verification. (variation 92: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #92.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #92, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E093 — ISR drill 93: `revalidate: 60` vs `revalidatePath` after mutation

Scenario: revalidate: 60 vs revalidatePath after mutation — double invalidation? (variation 93: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #93.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #93, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E094 — ISR drill 94: ISR page deleted in CMS

Scenario: ISR page deleted in CMS — still 200 with stale body until revalidate. (variation 94: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #94.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #94, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E095 — ISR drill 95: High-traffic article

Scenario: High-traffic article — thundering herd on first request after expiry. (variation 95: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #95.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #95, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E096 — ISR drill 96: Tag-based revalidation shared across 50 pages

Scenario: Tag-based revalidation shared across 50 pages — blast radius. (variation 96: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #96.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #96, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E097 — ISR drill 97: Background revalidation fails silently

Scenario: Background revalidation fails silently — how to detect? (variation 97: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #97.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #97, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E098 — ISR drill 98: Deploy new code while old HTML references old chunk hashes.

Scenario: Deploy new code while old HTML references old chunk hashes. (variation 98: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #98.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #98, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E099 — ISR drill 99: ISR + personalized cookie banner

Scenario: ISR + personalized cookie banner — cache poisoning risk. (variation 99: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #99.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #99, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E100 — ISR drill 100: Choosing ISR vs SSR for stock ticker that updates every second.

Scenario: Choosing ISR vs SSR for stock ticker that updates every second. (variation 100: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #100.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #100, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E101 — ISR drill 101: Stale content served 10 minutes

Scenario: Stale content served 10 minutes — support complains 'I published'. (variation 101: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #101.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #101, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E102 — ISR drill 102: On-demand revalidation webhook from CMS

Scenario: On-demand revalidation webhook from CMS — signature verification. (variation 102: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #102.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #102, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E103 — ISR drill 103: `revalidate: 60` vs `revalidatePath` after mutation

Scenario: revalidate: 60 vs revalidatePath after mutation — double invalidation? (variation 103: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #103.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #103, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E104 — ISR drill 104: ISR page deleted in CMS

Scenario: ISR page deleted in CMS — still 200 with stale body until revalidate. (variation 104: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #104.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #104, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version

E105 — ISR drill 105: High-traffic article

Scenario: High-traffic article — thundering herd on first request after expiry. (variation 105: consider deployment on a serverless platform with regional databases.)

Prompt: Explain trade-offs and what you would measure (latency, error rate, cost) before/after a change for case #105.

Model answer: Start by naming the user-visible symptom (SEO, staleness, TTFB, consistency). List hypotheses (N+1 queries, blocking waterfall, wrong cache directive, missing revalidation). Propose one smallest experiment: add logging/timing, reduce sequential awaits, adjust revalidate window, or move work to background job. Define rollback. For #105, emphasize that measurement beats opinions: compare p50/p95 TTFB and conversion where relevant.

// Pages Router style sketch (concept)
export const revalidate = 300;

// App Router: prefer fetch next.revalidate or segment config per docs for your version