2.19.b — Static Site Generation (SSG)

In one sentence: SSG precomputes pages so the runtime path is mostly CDN-fast static delivery—ideal for stable public content until scale or freshness forces ISR or SSR.

Navigation: ← SSR · Next → ISR

---

1. What “Static Site Generation” Means

SSG means HTML (and RSC payload where applicable) is produced at build time (next build) or otherwise precomputed, then served as static files or from a CDN with high cache hit rates. Each visitor receives the same bytes for a given URL — unless you add ISR, middleware rewrites, or client-side personalization.

1.1 Why SSG is fast

The request path is:

CDN edge → static asset (HTML/JSON) → browser

No database on the critical path for the happy path. TTFB can approach a few tens of milliseconds globally when cached.

1.2 getStaticProps mental model (Pages Router)

export async function getStaticProps() {
  const posts = await loadAllPosts();
  return { props: { posts }, revalidate: false };
}

Interview: "Static" implies predictable content at build. If content changes often, pure SSG without ISR becomes a deploy bottleneck.

1.3 App Router static generation

Use generateStaticParams to enumerate dynamic routes to prebuild. For fully static marketing pages, omit dynamic APIs entirely and allow default static behavior per Next version docs.

1.4 SEO benefits and limits

SSG is excellent for stable content: blogs, docs, landing pages. If auth-gated content is accidentally statically generated, you leak data — always verify segment static vs dynamic behavior.

1.5 Build-time scale

Posts	Build cost
100	trivial
10,000	CI minutes matter
1,000,000	need partial static + ISR/on-demand

1.6 Export mode (output: 'export')

Fully static hosting (S3/CloudFront) — no Route Handlers, no ISR as traditionally implemented on Vercel serverless. Interviewers may ask: know the constraints.

1.7 Pairing with client hydration

Static HTML can still hydrate rich components. The static part is the initial snapshot; client state can diverge after mount.

1.8 Checklist

• No secrets in static HTML
• Canonical URLs and meta tags validated at build
• 404/410 behavior for removed content

---

Part 2 — Deep Encyclopedia (Static Site Generation (SSG))

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 — SSG drill 1: Blog with 5k posts

Scenario: Blog with 5k posts — full static build exceeds CI time limit. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E002 — SSG drill 2: Legal copy pages

Scenario: Legal copy pages — must never accidentally show stale compliance text. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E003 — SSG drill 3: OpenGraph images pre-rendered at build for top 100 URLs only.

Scenario: OpenGraph images pre-rendered at build for top 100 URLs only. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E004 — SSG drill 4: Multi-tenant marketing site

Scenario: Multi-tenant marketing site — same route, different content per host. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E005 — SSG drill 5: Preview mode for CMS editors without rebuilding production.

Scenario: Preview mode for CMS editors without rebuilding production. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E006 — SSG drill 6: Sitemap.xml generation

Scenario: Sitemap.xml generation — static file vs dynamic route. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E007 — SSG drill 7: Internationalization: static paths per locale explode combinatorially.

Scenario: Internationalization: static paths per locale explode combinatorially. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E008 — SSG drill 8: Image optimization

Scenario: Image optimization — next/image with static export constraints. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E009 — SSG drill 9: CDN cache hit ratio monitoring for SSG assets.

Scenario: CDN cache hit ratio monitoring for SSG assets. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E010 — SSG drill 10: Partial prerender (conceptual) vs classic SSG split.

Scenario: Partial prerender (conceptual) vs classic SSG split. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E011 — SSG drill 11: Blog with 5k posts

Scenario: Blog with 5k posts — full static build exceeds CI time limit. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E012 — SSG drill 12: Legal copy pages

Scenario: Legal copy pages — must never accidentally show stale compliance text. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E013 — SSG drill 13: OpenGraph images pre-rendered at build for top 100 URLs only.

Scenario: OpenGraph images pre-rendered at build for top 100 URLs only. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E014 — SSG drill 14: Multi-tenant marketing site

Scenario: Multi-tenant marketing site — same route, different content per host. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E015 — SSG drill 15: Preview mode for CMS editors without rebuilding production.

Scenario: Preview mode for CMS editors without rebuilding production. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E016 — SSG drill 16: Sitemap.xml generation

Scenario: Sitemap.xml generation — static file vs dynamic route. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E017 — SSG drill 17: Internationalization: static paths per locale explode combinatorially.

Scenario: Internationalization: static paths per locale explode combinatorially. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E018 — SSG drill 18: Image optimization

Scenario: Image optimization — next/image with static export constraints. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E019 — SSG drill 19: CDN cache hit ratio monitoring for SSG assets.

Scenario: CDN cache hit ratio monitoring for SSG assets. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E020 — SSG drill 20: Partial prerender (conceptual) vs classic SSG split.

Scenario: Partial prerender (conceptual) vs classic SSG split. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E021 — SSG drill 21: Blog with 5k posts

Scenario: Blog with 5k posts — full static build exceeds CI time limit. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E022 — SSG drill 22: Legal copy pages

Scenario: Legal copy pages — must never accidentally show stale compliance text. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E023 — SSG drill 23: OpenGraph images pre-rendered at build for top 100 URLs only.

Scenario: OpenGraph images pre-rendered at build for top 100 URLs only. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E024 — SSG drill 24: Multi-tenant marketing site

Scenario: Multi-tenant marketing site — same route, different content per host. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E025 — SSG drill 25: Preview mode for CMS editors without rebuilding production.

Scenario: Preview mode for CMS editors without rebuilding production. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E026 — SSG drill 26: Sitemap.xml generation

Scenario: Sitemap.xml generation — static file vs dynamic route. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E027 — SSG drill 27: Internationalization: static paths per locale explode combinatorially.

Scenario: Internationalization: static paths per locale explode combinatorially. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E028 — SSG drill 28: Image optimization

Scenario: Image optimization — next/image with static export constraints. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E029 — SSG drill 29: CDN cache hit ratio monitoring for SSG assets.

Scenario: CDN cache hit ratio monitoring for SSG assets. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E030 — SSG drill 30: Partial prerender (conceptual) vs classic SSG split.

Scenario: Partial prerender (conceptual) vs classic SSG split. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E031 — SSG drill 31: Blog with 5k posts

Scenario: Blog with 5k posts — full static build exceeds CI time limit. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E032 — SSG drill 32: Legal copy pages

Scenario: Legal copy pages — must never accidentally show stale compliance text. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E033 — SSG drill 33: OpenGraph images pre-rendered at build for top 100 URLs only.

Scenario: OpenGraph images pre-rendered at build for top 100 URLs only. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E034 — SSG drill 34: Multi-tenant marketing site

Scenario: Multi-tenant marketing site — same route, different content per host. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E035 — SSG drill 35: Preview mode for CMS editors without rebuilding production.

Scenario: Preview mode for CMS editors without rebuilding production. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E036 — SSG drill 36: Sitemap.xml generation

Scenario: Sitemap.xml generation — static file vs dynamic route. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E037 — SSG drill 37: Internationalization: static paths per locale explode combinatorially.

Scenario: Internationalization: static paths per locale explode combinatorially. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E038 — SSG drill 38: Image optimization

Scenario: Image optimization — next/image with static export constraints. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E039 — SSG drill 39: CDN cache hit ratio monitoring for SSG assets.

Scenario: CDN cache hit ratio monitoring for SSG assets. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E040 — SSG drill 40: Partial prerender (conceptual) vs classic SSG split.

Scenario: Partial prerender (conceptual) vs classic SSG split. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E041 — SSG drill 41: Blog with 5k posts

Scenario: Blog with 5k posts — full static build exceeds CI time limit. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E042 — SSG drill 42: Legal copy pages

Scenario: Legal copy pages — must never accidentally show stale compliance text. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E043 — SSG drill 43: OpenGraph images pre-rendered at build for top 100 URLs only.

Scenario: OpenGraph images pre-rendered at build for top 100 URLs only. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E044 — SSG drill 44: Multi-tenant marketing site

Scenario: Multi-tenant marketing site — same route, different content per host. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E045 — SSG drill 45: Preview mode for CMS editors without rebuilding production.

Scenario: Preview mode for CMS editors without rebuilding production. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E046 — SSG drill 46: Sitemap.xml generation

Scenario: Sitemap.xml generation — static file vs dynamic route. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E047 — SSG drill 47: Internationalization: static paths per locale explode combinatorially.

Scenario: Internationalization: static paths per locale explode combinatorially. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E048 — SSG drill 48: Image optimization

Scenario: Image optimization — next/image with static export constraints. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E049 — SSG drill 49: CDN cache hit ratio monitoring for SSG assets.

Scenario: CDN cache hit ratio monitoring for SSG assets. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E050 — SSG drill 50: Partial prerender (conceptual) vs classic SSG split.

Scenario: Partial prerender (conceptual) vs classic SSG split. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E051 — SSG drill 51: Blog with 5k posts

Scenario: Blog with 5k posts — full static build exceeds CI time limit. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E052 — SSG drill 52: Legal copy pages

Scenario: Legal copy pages — must never accidentally show stale compliance text. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E053 — SSG drill 53: OpenGraph images pre-rendered at build for top 100 URLs only.

Scenario: OpenGraph images pre-rendered at build for top 100 URLs only. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E054 — SSG drill 54: Multi-tenant marketing site

Scenario: Multi-tenant marketing site — same route, different content per host. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E055 — SSG drill 55: Preview mode for CMS editors without rebuilding production.

Scenario: Preview mode for CMS editors without rebuilding production. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E056 — SSG drill 56: Sitemap.xml generation

Scenario: Sitemap.xml generation — static file vs dynamic route. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E057 — SSG drill 57: Internationalization: static paths per locale explode combinatorially.

Scenario: Internationalization: static paths per locale explode combinatorially. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E058 — SSG drill 58: Image optimization

Scenario: Image optimization — next/image with static export constraints. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E059 — SSG drill 59: CDN cache hit ratio monitoring for SSG assets.

Scenario: CDN cache hit ratio monitoring for SSG assets. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E060 — SSG drill 60: Partial prerender (conceptual) vs classic SSG split.

Scenario: Partial prerender (conceptual) vs classic SSG split. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E061 — SSG drill 61: Blog with 5k posts

Scenario: Blog with 5k posts — full static build exceeds CI time limit. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E062 — SSG drill 62: Legal copy pages

Scenario: Legal copy pages — must never accidentally show stale compliance text. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E063 — SSG drill 63: OpenGraph images pre-rendered at build for top 100 URLs only.

Scenario: OpenGraph images pre-rendered at build for top 100 URLs only. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E064 — SSG drill 64: Multi-tenant marketing site

Scenario: Multi-tenant marketing site — same route, different content per host. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E065 — SSG drill 65: Preview mode for CMS editors without rebuilding production.

Scenario: Preview mode for CMS editors without rebuilding production. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E066 — SSG drill 66: Sitemap.xml generation

Scenario: Sitemap.xml generation — static file vs dynamic route. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E067 — SSG drill 67: Internationalization: static paths per locale explode combinatorially.

Scenario: Internationalization: static paths per locale explode combinatorially. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E068 — SSG drill 68: Image optimization

Scenario: Image optimization — next/image with static export constraints. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E069 — SSG drill 69: CDN cache hit ratio monitoring for SSG assets.

Scenario: CDN cache hit ratio monitoring for SSG assets. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E070 — SSG drill 70: Partial prerender (conceptual) vs classic SSG split.

Scenario: Partial prerender (conceptual) vs classic SSG split. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E071 — SSG drill 71: Blog with 5k posts

Scenario: Blog with 5k posts — full static build exceeds CI time limit. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E072 — SSG drill 72: Legal copy pages

Scenario: Legal copy pages — must never accidentally show stale compliance text. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E073 — SSG drill 73: OpenGraph images pre-rendered at build for top 100 URLs only.

Scenario: OpenGraph images pre-rendered at build for top 100 URLs only. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E074 — SSG drill 74: Multi-tenant marketing site

Scenario: Multi-tenant marketing site — same route, different content per host. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E075 — SSG drill 75: Preview mode for CMS editors without rebuilding production.

Scenario: Preview mode for CMS editors without rebuilding production. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E076 — SSG drill 76: Sitemap.xml generation

Scenario: Sitemap.xml generation — static file vs dynamic route. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E077 — SSG drill 77: Internationalization: static paths per locale explode combinatorially.

Scenario: Internationalization: static paths per locale explode combinatorially. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E078 — SSG drill 78: Image optimization

Scenario: Image optimization — next/image with static export constraints. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E079 — SSG drill 79: CDN cache hit ratio monitoring for SSG assets.

Scenario: CDN cache hit ratio monitoring for SSG assets. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E080 — SSG drill 80: Partial prerender (conceptual) vs classic SSG split.

Scenario: Partial prerender (conceptual) vs classic SSG split. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E081 — SSG drill 81: Blog with 5k posts

Scenario: Blog with 5k posts — full static build exceeds CI time limit. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E082 — SSG drill 82: Legal copy pages

Scenario: Legal copy pages — must never accidentally show stale compliance text. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E083 — SSG drill 83: OpenGraph images pre-rendered at build for top 100 URLs only.

Scenario: OpenGraph images pre-rendered at build for top 100 URLs only. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E084 — SSG drill 84: Multi-tenant marketing site

Scenario: Multi-tenant marketing site — same route, different content per host. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E085 — SSG drill 85: Preview mode for CMS editors without rebuilding production.

Scenario: Preview mode for CMS editors without rebuilding production. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E086 — SSG drill 86: Sitemap.xml generation

Scenario: Sitemap.xml generation — static file vs dynamic route. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E087 — SSG drill 87: Internationalization: static paths per locale explode combinatorially.

Scenario: Internationalization: static paths per locale explode combinatorially. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E088 — SSG drill 88: Image optimization

Scenario: Image optimization — next/image with static export constraints. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E089 — SSG drill 89: CDN cache hit ratio monitoring for SSG assets.

Scenario: CDN cache hit ratio monitoring for SSG assets. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E090 — SSG drill 90: Partial prerender (conceptual) vs classic SSG split.

Scenario: Partial prerender (conceptual) vs classic SSG split. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E091 — SSG drill 91: Blog with 5k posts

Scenario: Blog with 5k posts — full static build exceeds CI time limit. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E092 — SSG drill 92: Legal copy pages

Scenario: Legal copy pages — must never accidentally show stale compliance text. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E093 — SSG drill 93: OpenGraph images pre-rendered at build for top 100 URLs only.

Scenario: OpenGraph images pre-rendered at build for top 100 URLs only. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E094 — SSG drill 94: Multi-tenant marketing site

Scenario: Multi-tenant marketing site — same route, different content per host. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E095 — SSG drill 95: Preview mode for CMS editors without rebuilding production.

Scenario: Preview mode for CMS editors without rebuilding production. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E096 — SSG drill 96: Sitemap.xml generation

Scenario: Sitemap.xml generation — static file vs dynamic route. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E097 — SSG drill 97: Internationalization: static paths per locale explode combinatorially.

Scenario: Internationalization: static paths per locale explode combinatorially. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E098 — SSG drill 98: Image optimization

Scenario: Image optimization — next/image with static export constraints. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E099 — SSG drill 99: CDN cache hit ratio monitoring for SSG assets.

Scenario: CDN cache hit ratio monitoring for SSG assets. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E100 — SSG drill 100: Partial prerender (conceptual) vs classic SSG split.

Scenario: Partial prerender (conceptual) vs classic SSG split. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E101 — SSG drill 101: Blog with 5k posts

Scenario: Blog with 5k posts — full static build exceeds CI time limit. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E102 — SSG drill 102: Legal copy pages

Scenario: Legal copy pages — must never accidentally show stale compliance text. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E103 — SSG drill 103: OpenGraph images pre-rendered at build for top 100 URLs only.

Scenario: OpenGraph images pre-rendered at build for top 100 URLs only. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E104 — SSG drill 104: Multi-tenant marketing site

Scenario: Multi-tenant marketing site — same route, different content per host. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---

E105 — SSG drill 105: Preview mode for CMS editors without rebuilding production.

Scenario: Preview mode for CMS editors without rebuilding production. (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.

// Sketch: static generation at build
export async function generateStaticParams() {
  return slugs.map((slug) => ({ slug }));
}

export default async function Page({ params }) {
  const post = await loadPost(params.slug);
  return <article>{post.title}</article>;
}

---