Episode 2 — React Frontend Architecture NextJS / 2.18 — Getting Started with NextJS

2.18.a — Why Next.js Is Widely Used

In one sentence: Teams adopt Next.js because it packages routing, rendering, and deployment-friendly server patterns around React—reducing integration work and improving defaults for performance and SEO.

Navigation: ← 2.18 Overview · Next → Framework vs Library

1. The problem Next.js sells a solution to

Modern product teams want:

Fast first paint for SEO and conversion (rendering strategies).
Sensible routing that matches URLs to UI ownership (file system).
Incremental adoption of server logic without a separate deploy for every tiny API (Route Handlers, Server Actions).
Operational defaults that work on major hosts (build, start, edge options).

React answers: “How should we describe interactive UI?”
Next answers: “How should that UI be delivered, routed, and operated as a web application?”

1.1 Adoption drivers (what hiring managers mean)

Driver	Plain language
Full-stack ergonomics	One codebase for UI + HTTP + server rendering
Performance budgets	Image/font helpers, streaming, code splitting conventions
SEO / sharing	Metadata APIs, predictable HTML for crawlers
Team velocity	Conventions reduce bike-shedding (“where does this go?”)

1.2 Who it is not for (credible senior answer)

Tiny embeds where a full framework is overhead.
Non-web targets (though React Native is separate).
Teams that already standardized on another meta-framework and will not migrate.

1.3 Ecosystem gravity

Large tutorial surface, hiring pool, third-party integrations (auth, CMS, analytics) target Next first. That gravity is a real—not purely technical—reason teams pick it.

1.4 Version awareness

Next evolves quickly (App Router, Turbopack, caching changes). “We use Next” in interviews should include which major version and Pages vs App Router clarity.

Part 2 — Deep Encyclopedia (Why Next.js Is Widely Used)

How to use: Each drill = scenario → interview prompt → model answer → optional code sketch. Answers emphasize trade-offs and what you would verify in a real repo.

E001 — Drill 1: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo.

Scenario: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo. (variation 1: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #1?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #1, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E002 — Drill 2: Team worries about vendor lock-in to Vercel.

Scenario: Team worries about vendor lock-in to Vercel. (variation 2: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #2?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #2, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E003 — Drill 3: SEO agency demands Lighthouse improvements on LCP for mobile.

Scenario: SEO agency demands Lighthouse improvements on LCP for mobile. (variation 3: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #3?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #3, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E004 — Drill 4: Security wants fewer exposed env vars to browser.

Scenario: Security wants fewer exposed env vars to browser. (variation 4: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #4?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #4, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E005 — Drill 5: Designers want route-based design reviews in preview deploys.

Scenario: Designers want route-based design reviews in preview deploys. (variation 5: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #5?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #5, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E006 — Drill 6: Mobile team wants same API for future React Native

Scenario: Mobile team wants same API for future React Native — does Next help? (variation 6: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #6?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #6, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E007 — Drill 7: Monorepo already has Express

Scenario: Monorepo already has Express — why add Next? (variation 7: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #7?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #7, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E008 — Drill 8: Edge latency requirements for auth check before HTML.

Scenario: Edge latency requirements for auth check before HTML. (variation 8: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #8?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #8, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E009 — Drill 9: Internationalization with locale subpaths.

Scenario: Internationalization with locale subpaths. (variation 9: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #9?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #9, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E010 — Drill 10: Graph of ownership: who maintains next.config?

Scenario: Graph of ownership: who maintains next.config? (variation 10: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #10?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #10, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E011 — Drill 11: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo.

Scenario: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo. (variation 11: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #11?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #11, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E012 — Drill 12: Team worries about vendor lock-in to Vercel.

Scenario: Team worries about vendor lock-in to Vercel. (variation 12: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #12?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #12, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E013 — Drill 13: SEO agency demands Lighthouse improvements on LCP for mobile.

Scenario: SEO agency demands Lighthouse improvements on LCP for mobile. (variation 13: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #13?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #13, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E014 — Drill 14: Security wants fewer exposed env vars to browser.

Scenario: Security wants fewer exposed env vars to browser. (variation 14: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #14?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #14, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E015 — Drill 15: Designers want route-based design reviews in preview deploys.

Scenario: Designers want route-based design reviews in preview deploys. (variation 15: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #15?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #15, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E016 — Drill 16: Mobile team wants same API for future React Native

Scenario: Mobile team wants same API for future React Native — does Next help? (variation 16: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #16?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #16, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E017 — Drill 17: Monorepo already has Express

Scenario: Monorepo already has Express — why add Next? (variation 17: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #17?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #17, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E018 — Drill 18: Edge latency requirements for auth check before HTML.

Scenario: Edge latency requirements for auth check before HTML. (variation 18: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #18?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #18, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E019 — Drill 19: Internationalization with locale subpaths.

Scenario: Internationalization with locale subpaths. (variation 19: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #19?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #19, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E020 — Drill 20: Graph of ownership: who maintains next.config?

Scenario: Graph of ownership: who maintains next.config? (variation 20: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #20?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #20, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E021 — Drill 21: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo.

Scenario: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo. (variation 21: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #21?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #21, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E022 — Drill 22: Team worries about vendor lock-in to Vercel.

Scenario: Team worries about vendor lock-in to Vercel. (variation 22: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #22?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #22, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E023 — Drill 23: SEO agency demands Lighthouse improvements on LCP for mobile.

Scenario: SEO agency demands Lighthouse improvements on LCP for mobile. (variation 23: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #23?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #23, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E024 — Drill 24: Security wants fewer exposed env vars to browser.

Scenario: Security wants fewer exposed env vars to browser. (variation 24: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #24?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #24, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E025 — Drill 25: Designers want route-based design reviews in preview deploys.

Scenario: Designers want route-based design reviews in preview deploys. (variation 25: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #25?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #25, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E026 — Drill 26: Mobile team wants same API for future React Native

Scenario: Mobile team wants same API for future React Native — does Next help? (variation 26: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #26?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #26, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E027 — Drill 27: Monorepo already has Express

Scenario: Monorepo already has Express — why add Next? (variation 27: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #27?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #27, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E028 — Drill 28: Edge latency requirements for auth check before HTML.

Scenario: Edge latency requirements for auth check before HTML. (variation 28: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #28?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #28, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E029 — Drill 29: Internationalization with locale subpaths.

Scenario: Internationalization with locale subpaths. (variation 29: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #29?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #29, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E030 — Drill 30: Graph of ownership: who maintains next.config?

Scenario: Graph of ownership: who maintains next.config? (variation 30: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #30?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #30, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E031 — Drill 31: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo.

Scenario: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo. (variation 31: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #31?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #31, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E032 — Drill 32: Team worries about vendor lock-in to Vercel.

Scenario: Team worries about vendor lock-in to Vercel. (variation 32: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #32?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #32, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E033 — Drill 33: SEO agency demands Lighthouse improvements on LCP for mobile.

Scenario: SEO agency demands Lighthouse improvements on LCP for mobile. (variation 33: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #33?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #33, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E034 — Drill 34: Security wants fewer exposed env vars to browser.

Scenario: Security wants fewer exposed env vars to browser. (variation 34: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #34?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #34, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E035 — Drill 35: Designers want route-based design reviews in preview deploys.

Scenario: Designers want route-based design reviews in preview deploys. (variation 35: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #35?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #35, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E036 — Drill 36: Mobile team wants same API for future React Native

Scenario: Mobile team wants same API for future React Native — does Next help? (variation 36: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #36?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #36, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E037 — Drill 37: Monorepo already has Express

Scenario: Monorepo already has Express — why add Next? (variation 37: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #37?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #37, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E038 — Drill 38: Edge latency requirements for auth check before HTML.

Scenario: Edge latency requirements for auth check before HTML. (variation 38: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #38?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #38, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E039 — Drill 39: Internationalization with locale subpaths.

Scenario: Internationalization with locale subpaths. (variation 39: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #39?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #39, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E040 — Drill 40: Graph of ownership: who maintains next.config?

Scenario: Graph of ownership: who maintains next.config? (variation 40: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #40?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #40, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E041 — Drill 41: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo.

Scenario: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo. (variation 41: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #41?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #41, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E042 — Drill 42: Team worries about vendor lock-in to Vercel.

Scenario: Team worries about vendor lock-in to Vercel. (variation 42: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #42?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #42, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E043 — Drill 43: SEO agency demands Lighthouse improvements on LCP for mobile.

Scenario: SEO agency demands Lighthouse improvements on LCP for mobile. (variation 43: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #43?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #43, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E044 — Drill 44: Security wants fewer exposed env vars to browser.

Scenario: Security wants fewer exposed env vars to browser. (variation 44: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #44?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #44, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E045 — Drill 45: Designers want route-based design reviews in preview deploys.

Scenario: Designers want route-based design reviews in preview deploys. (variation 45: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #45?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #45, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E046 — Drill 46: Mobile team wants same API for future React Native

Scenario: Mobile team wants same API for future React Native — does Next help? (variation 46: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #46?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #46, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E047 — Drill 47: Monorepo already has Express

Scenario: Monorepo already has Express — why add Next? (variation 47: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #47?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #47, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E048 — Drill 48: Edge latency requirements for auth check before HTML.

Scenario: Edge latency requirements for auth check before HTML. (variation 48: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #48?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #48, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E049 — Drill 49: Internationalization with locale subpaths.

Scenario: Internationalization with locale subpaths. (variation 49: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #49?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #49, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E050 — Drill 50: Graph of ownership: who maintains next.config?

Scenario: Graph of ownership: who maintains next.config? (variation 50: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #50?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #50, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E051 — Drill 51: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo.

Scenario: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo. (variation 51: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #51?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #51, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E052 — Drill 52: Team worries about vendor lock-in to Vercel.

Scenario: Team worries about vendor lock-in to Vercel. (variation 52: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #52?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #52, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E053 — Drill 53: SEO agency demands Lighthouse improvements on LCP for mobile.

Scenario: SEO agency demands Lighthouse improvements on LCP for mobile. (variation 53: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #53?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #53, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E054 — Drill 54: Security wants fewer exposed env vars to browser.

Scenario: Security wants fewer exposed env vars to browser. (variation 54: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #54?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #54, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E055 — Drill 55: Designers want route-based design reviews in preview deploys.

Scenario: Designers want route-based design reviews in preview deploys. (variation 55: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #55?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #55, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E056 — Drill 56: Mobile team wants same API for future React Native

Scenario: Mobile team wants same API for future React Native — does Next help? (variation 56: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #56?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #56, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E057 — Drill 57: Monorepo already has Express

Scenario: Monorepo already has Express — why add Next? (variation 57: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #57?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #57, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E058 — Drill 58: Edge latency requirements for auth check before HTML.

Scenario: Edge latency requirements for auth check before HTML. (variation 58: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #58?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #58, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E059 — Drill 59: Internationalization with locale subpaths.

Scenario: Internationalization with locale subpaths. (variation 59: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #59?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #59, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E060 — Drill 60: Graph of ownership: who maintains next.config?

Scenario: Graph of ownership: who maintains next.config? (variation 60: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #60?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #60, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E061 — Drill 61: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo.

Scenario: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo. (variation 61: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #61?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #61, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E062 — Drill 62: Team worries about vendor lock-in to Vercel.

Scenario: Team worries about vendor lock-in to Vercel. (variation 62: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #62?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #62, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E063 — Drill 63: SEO agency demands Lighthouse improvements on LCP for mobile.

Scenario: SEO agency demands Lighthouse improvements on LCP for mobile. (variation 63: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #63?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #63, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E064 — Drill 64: Security wants fewer exposed env vars to browser.

Scenario: Security wants fewer exposed env vars to browser. (variation 64: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #64?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #64, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E065 — Drill 65: Designers want route-based design reviews in preview deploys.

Scenario: Designers want route-based design reviews in preview deploys. (variation 65: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #65?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #65, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E066 — Drill 66: Mobile team wants same API for future React Native

Scenario: Mobile team wants same API for future React Native — does Next help? (variation 66: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #66?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #66, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E067 — Drill 67: Monorepo already has Express

Scenario: Monorepo already has Express — why add Next? (variation 67: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #67?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #67, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E068 — Drill 68: Edge latency requirements for auth check before HTML.

Scenario: Edge latency requirements for auth check before HTML. (variation 68: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #68?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #68, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E069 — Drill 69: Internationalization with locale subpaths.

Scenario: Internationalization with locale subpaths. (variation 69: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #69?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #69, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E070 — Drill 70: Graph of ownership: who maintains next.config?

Scenario: Graph of ownership: who maintains next.config? (variation 70: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #70?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #70, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E071 — Drill 71: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo.

Scenario: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo. (variation 71: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #71?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #71, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E072 — Drill 72: Team worries about vendor lock-in to Vercel.

Scenario: Team worries about vendor lock-in to Vercel. (variation 72: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #72?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #72, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E073 — Drill 73: SEO agency demands Lighthouse improvements on LCP for mobile.

Scenario: SEO agency demands Lighthouse improvements on LCP for mobile. (variation 73: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #73?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #73, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E074 — Drill 74: Security wants fewer exposed env vars to browser.

Scenario: Security wants fewer exposed env vars to browser. (variation 74: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #74?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #74, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E075 — Drill 75: Designers want route-based design reviews in preview deploys.

Scenario: Designers want route-based design reviews in preview deploys. (variation 75: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #75?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #75, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E076 — Drill 76: Mobile team wants same API for future React Native

Scenario: Mobile team wants same API for future React Native — does Next help? (variation 76: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #76?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #76, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E077 — Drill 77: Monorepo already has Express

Scenario: Monorepo already has Express — why add Next? (variation 77: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #77?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #77, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E078 — Drill 78: Edge latency requirements for auth check before HTML.

Scenario: Edge latency requirements for auth check before HTML. (variation 78: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #78?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #78, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E079 — Drill 79: Internationalization with locale subpaths.

Scenario: Internationalization with locale subpaths. (variation 79: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #79?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #79, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E080 — Drill 80: Graph of ownership: who maintains next.config?

Scenario: Graph of ownership: who maintains next.config? (variation 80: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #80?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #80, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E081 — Drill 81: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo.

Scenario: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo. (variation 81: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #81?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #81, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E082 — Drill 82: Team worries about vendor lock-in to Vercel.

Scenario: Team worries about vendor lock-in to Vercel. (variation 82: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #82?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #82, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E083 — Drill 83: SEO agency demands Lighthouse improvements on LCP for mobile.

Scenario: SEO agency demands Lighthouse improvements on LCP for mobile. (variation 83: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #83?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #83, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E084 — Drill 84: Security wants fewer exposed env vars to browser.

Scenario: Security wants fewer exposed env vars to browser. (variation 84: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #84?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #84, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E085 — Drill 85: Designers want route-based design reviews in preview deploys.

Scenario: Designers want route-based design reviews in preview deploys. (variation 85: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #85?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #85, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E086 — Drill 86: Mobile team wants same API for future React Native

Scenario: Mobile team wants same API for future React Native — does Next help? (variation 86: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #86?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #86, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E087 — Drill 87: Monorepo already has Express

Scenario: Monorepo already has Express — why add Next? (variation 87: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #87?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #87, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E088 — Drill 88: Edge latency requirements for auth check before HTML.

Scenario: Edge latency requirements for auth check before HTML. (variation 88: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #88?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #88, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E089 — Drill 89: Internationalization with locale subpaths.

Scenario: Internationalization with locale subpaths. (variation 89: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #89?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #89, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E090 — Drill 90: Graph of ownership: who maintains next.config?

Scenario: Graph of ownership: who maintains next.config? (variation 90: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #90?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #90, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E091 — Drill 91: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo.

Scenario: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo. (variation 91: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #91?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #91, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E092 — Drill 92: Team worries about vendor lock-in to Vercel.

Scenario: Team worries about vendor lock-in to Vercel. (variation 92: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #92?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #92, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E093 — Drill 93: SEO agency demands Lighthouse improvements on LCP for mobile.

Scenario: SEO agency demands Lighthouse improvements on LCP for mobile. (variation 93: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #93?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #93, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E094 — Drill 94: Security wants fewer exposed env vars to browser.

Scenario: Security wants fewer exposed env vars to browser. (variation 94: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #94?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #94, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E095 — Drill 95: Designers want route-based design reviews in preview deploys.

Scenario: Designers want route-based design reviews in preview deploys. (variation 95: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #95?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #95, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E096 — Drill 96: Mobile team wants same API for future React Native

Scenario: Mobile team wants same API for future React Native — does Next help? (variation 96: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #96?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #96, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E097 — Drill 97: Monorepo already has Express

Scenario: Monorepo already has Express — why add Next? (variation 97: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #97?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #97, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E098 — Drill 98: Edge latency requirements for auth check before HTML.

Scenario: Edge latency requirements for auth check before HTML. (variation 98: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #98?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #98, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E099 — Drill 99: Internationalization with locale subpaths.

Scenario: Internationalization with locale subpaths. (variation 99: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #99?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #99, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E100 — Drill 100: Graph of ownership: who maintains next.config?

Scenario: Graph of ownership: who maintains next.config? (variation 100: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #100?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #100, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E101 — Drill 101: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo.

Scenario: CTO asks why not stay on CRA/Vite SPA for a marketing + app combo. (variation 101: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #101?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #101, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E102 — Drill 102: Team worries about vendor lock-in to Vercel.

Scenario: Team worries about vendor lock-in to Vercel. (variation 102: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #102?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #102, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E103 — Drill 103: SEO agency demands Lighthouse improvements on LCP for mobile.

Scenario: SEO agency demands Lighthouse improvements on LCP for mobile. (variation 103: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #103?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #103, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E104 — Drill 104: Security wants fewer exposed env vars to browser.

Scenario: Security wants fewer exposed env vars to browser. (variation 104: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #104?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #104, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}

E105 — Drill 105: Designers want route-based design reviews in preview deploys.

Scenario: Designers want route-based design reviews in preview deploys. (variation 105: assume App Router, TypeScript, and a product team shipping weekly.)

Prompt: What decision do you make, what do you document, and what metric or artifact proves the outcome for case #105?

Model answer: I restate constraints (team size, SEO needs, deploy target, latency budget). I pick the smallest reversible step—often a spike branch or preview deployment—and define one success signal (e.g. p75 LCP, build time, DX survey). For drill #105, I call out risks (lock-in, complexity, training) and mitigations (abstraction layers, coding standards, ADRs). I avoid absolutes: Next fits when routing + rendering + deployment integration reduce total cost versus bolting libraries onto React alone.

// No code required — but sample: app/page.tsx is the entry
export default function Page() {
  return <main>Proof of value: routed server component</main>;
}