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

2.18.b — Next.js vs React — Framework vs Library

In one sentence: React teaches components; Next teaches how those components become a routed, renderable, operable web application with clear server/client boundaries.

Navigation: ← Why Next.js · Next → Setting Up

1. React is a library; Next.js is a framework

Library: You call its APIs (createRoot, components) inside your application architecture.
Framework: It calls your code at defined extension points (page.tsx, layout.tsx, route.ts) inside its lifecycle.

1.1 Dependency direction

React app (CRA/Vite):  YOU orchestrates build, router, SSR if any
Next app:              FRAMEWORK orchestrates; YOU fills route modules

1.2 What you still bring as a React developer

Hooks, component design, state management thinking—all transfer. What is new: routing segments, server vs client boundaries, caching semantics, deployment model.

1.3 “Can we use Next without understanding React?”

You can paste tutorials, but maintenance collapses without React skills. React remains the view layer.

1.4 Comparison table (interview safe)

Topic	React-only SPA	Next.js
URL ↔ UI mapping	Pick router (React Router, etc.)	File-system conventions
First-load HTML	Often empty shell + client fetch	Server components / SSR options
Data for initial render	Client orchestration	Server-first patterns
Deploy story	Bring your own static host + API	First-class Node/edge server patterns

Part 2 — Deep Encyclopedia (Next.js vs React — Framework vs Library)

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: Junior says 'Next is just React with routing'.

Scenario: Junior says 'Next is just React with routing'. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E002 — Drill 2: Explain why `next/link` exists vs `<a href>`.

Scenario: Explain why next/link exists vs <a href>. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E003 — Drill 3: When would you use plain React in a widget embedded elsewhere?

Scenario: When would you use plain React in a widget embedded elsewhere? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E004 — Drill 4: Server Components vs traditional React tree mental load.

Scenario: Server Components vs traditional React tree mental load. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E005 — Drill 5: Who owns build pipeline: Webpack/Turbopack vs Vite defaults.

Scenario: Who owns build pipeline: Webpack/Turbopack vs Vite defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E006 — Drill 6: React 19 features and Next alignment lag concerns.

Scenario: React 19 features and Next alignment lag concerns. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E007 — Drill 7: Teaching hiring bar: React skills sufficient for Next hire?

Scenario: Teaching hiring bar: React skills sufficient for Next hire? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E008 — Drill 8: Micro-frontends vs single Next app trade-off.

Scenario: Micro-frontends vs single Next app trade-off. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E009 — Drill 9: Storybook + Next integration friction points.

Scenario: Storybook + Next integration friction points. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E010 — Drill 10: Testing: Jest vs Vitest with Next defaults.

Scenario: Testing: Jest vs Vitest with Next defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E011 — Drill 11: Junior says 'Next is just React with routing'.

Scenario: Junior says 'Next is just React with routing'. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E012 — Drill 12: Explain why `next/link` exists vs `<a href>`.

Scenario: Explain why next/link exists vs <a href>. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E013 — Drill 13: When would you use plain React in a widget embedded elsewhere?

Scenario: When would you use plain React in a widget embedded elsewhere? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E014 — Drill 14: Server Components vs traditional React tree mental load.

Scenario: Server Components vs traditional React tree mental load. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E015 — Drill 15: Who owns build pipeline: Webpack/Turbopack vs Vite defaults.

Scenario: Who owns build pipeline: Webpack/Turbopack vs Vite defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E016 — Drill 16: React 19 features and Next alignment lag concerns.

Scenario: React 19 features and Next alignment lag concerns. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E017 — Drill 17: Teaching hiring bar: React skills sufficient for Next hire?

Scenario: Teaching hiring bar: React skills sufficient for Next hire? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E018 — Drill 18: Micro-frontends vs single Next app trade-off.

Scenario: Micro-frontends vs single Next app trade-off. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E019 — Drill 19: Storybook + Next integration friction points.

Scenario: Storybook + Next integration friction points. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E020 — Drill 20: Testing: Jest vs Vitest with Next defaults.

Scenario: Testing: Jest vs Vitest with Next defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E021 — Drill 21: Junior says 'Next is just React with routing'.

Scenario: Junior says 'Next is just React with routing'. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E022 — Drill 22: Explain why `next/link` exists vs `<a href>`.

Scenario: Explain why next/link exists vs <a href>. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E023 — Drill 23: When would you use plain React in a widget embedded elsewhere?

Scenario: When would you use plain React in a widget embedded elsewhere? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E024 — Drill 24: Server Components vs traditional React tree mental load.

Scenario: Server Components vs traditional React tree mental load. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E025 — Drill 25: Who owns build pipeline: Webpack/Turbopack vs Vite defaults.

Scenario: Who owns build pipeline: Webpack/Turbopack vs Vite defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E026 — Drill 26: React 19 features and Next alignment lag concerns.

Scenario: React 19 features and Next alignment lag concerns. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E027 — Drill 27: Teaching hiring bar: React skills sufficient for Next hire?

Scenario: Teaching hiring bar: React skills sufficient for Next hire? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E028 — Drill 28: Micro-frontends vs single Next app trade-off.

Scenario: Micro-frontends vs single Next app trade-off. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E029 — Drill 29: Storybook + Next integration friction points.

Scenario: Storybook + Next integration friction points. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E030 — Drill 30: Testing: Jest vs Vitest with Next defaults.

Scenario: Testing: Jest vs Vitest with Next defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E031 — Drill 31: Junior says 'Next is just React with routing'.

Scenario: Junior says 'Next is just React with routing'. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E032 — Drill 32: Explain why `next/link` exists vs `<a href>`.

Scenario: Explain why next/link exists vs <a href>. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E033 — Drill 33: When would you use plain React in a widget embedded elsewhere?

Scenario: When would you use plain React in a widget embedded elsewhere? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E034 — Drill 34: Server Components vs traditional React tree mental load.

Scenario: Server Components vs traditional React tree mental load. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E035 — Drill 35: Who owns build pipeline: Webpack/Turbopack vs Vite defaults.

Scenario: Who owns build pipeline: Webpack/Turbopack vs Vite defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E036 — Drill 36: React 19 features and Next alignment lag concerns.

Scenario: React 19 features and Next alignment lag concerns. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E037 — Drill 37: Teaching hiring bar: React skills sufficient for Next hire?

Scenario: Teaching hiring bar: React skills sufficient for Next hire? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E038 — Drill 38: Micro-frontends vs single Next app trade-off.

Scenario: Micro-frontends vs single Next app trade-off. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E039 — Drill 39: Storybook + Next integration friction points.

Scenario: Storybook + Next integration friction points. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E040 — Drill 40: Testing: Jest vs Vitest with Next defaults.

Scenario: Testing: Jest vs Vitest with Next defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E041 — Drill 41: Junior says 'Next is just React with routing'.

Scenario: Junior says 'Next is just React with routing'. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E042 — Drill 42: Explain why `next/link` exists vs `<a href>`.

Scenario: Explain why next/link exists vs <a href>. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E043 — Drill 43: When would you use plain React in a widget embedded elsewhere?

Scenario: When would you use plain React in a widget embedded elsewhere? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E044 — Drill 44: Server Components vs traditional React tree mental load.

Scenario: Server Components vs traditional React tree mental load. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E045 — Drill 45: Who owns build pipeline: Webpack/Turbopack vs Vite defaults.

Scenario: Who owns build pipeline: Webpack/Turbopack vs Vite defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E046 — Drill 46: React 19 features and Next alignment lag concerns.

Scenario: React 19 features and Next alignment lag concerns. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E047 — Drill 47: Teaching hiring bar: React skills sufficient for Next hire?

Scenario: Teaching hiring bar: React skills sufficient for Next hire? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E048 — Drill 48: Micro-frontends vs single Next app trade-off.

Scenario: Micro-frontends vs single Next app trade-off. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E049 — Drill 49: Storybook + Next integration friction points.

Scenario: Storybook + Next integration friction points. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E050 — Drill 50: Testing: Jest vs Vitest with Next defaults.

Scenario: Testing: Jest vs Vitest with Next defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E051 — Drill 51: Junior says 'Next is just React with routing'.

Scenario: Junior says 'Next is just React with routing'. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E052 — Drill 52: Explain why `next/link` exists vs `<a href>`.

Scenario: Explain why next/link exists vs <a href>. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E053 — Drill 53: When would you use plain React in a widget embedded elsewhere?

Scenario: When would you use plain React in a widget embedded elsewhere? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E054 — Drill 54: Server Components vs traditional React tree mental load.

Scenario: Server Components vs traditional React tree mental load. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E055 — Drill 55: Who owns build pipeline: Webpack/Turbopack vs Vite defaults.

Scenario: Who owns build pipeline: Webpack/Turbopack vs Vite defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E056 — Drill 56: React 19 features and Next alignment lag concerns.

Scenario: React 19 features and Next alignment lag concerns. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E057 — Drill 57: Teaching hiring bar: React skills sufficient for Next hire?

Scenario: Teaching hiring bar: React skills sufficient for Next hire? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E058 — Drill 58: Micro-frontends vs single Next app trade-off.

Scenario: Micro-frontends vs single Next app trade-off. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E059 — Drill 59: Storybook + Next integration friction points.

Scenario: Storybook + Next integration friction points. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E060 — Drill 60: Testing: Jest vs Vitest with Next defaults.

Scenario: Testing: Jest vs Vitest with Next defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E061 — Drill 61: Junior says 'Next is just React with routing'.

Scenario: Junior says 'Next is just React with routing'. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E062 — Drill 62: Explain why `next/link` exists vs `<a href>`.

Scenario: Explain why next/link exists vs <a href>. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E063 — Drill 63: When would you use plain React in a widget embedded elsewhere?

Scenario: When would you use plain React in a widget embedded elsewhere? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E064 — Drill 64: Server Components vs traditional React tree mental load.

Scenario: Server Components vs traditional React tree mental load. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E065 — Drill 65: Who owns build pipeline: Webpack/Turbopack vs Vite defaults.

Scenario: Who owns build pipeline: Webpack/Turbopack vs Vite defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E066 — Drill 66: React 19 features and Next alignment lag concerns.

Scenario: React 19 features and Next alignment lag concerns. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E067 — Drill 67: Teaching hiring bar: React skills sufficient for Next hire?

Scenario: Teaching hiring bar: React skills sufficient for Next hire? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E068 — Drill 68: Micro-frontends vs single Next app trade-off.

Scenario: Micro-frontends vs single Next app trade-off. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E069 — Drill 69: Storybook + Next integration friction points.

Scenario: Storybook + Next integration friction points. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E070 — Drill 70: Testing: Jest vs Vitest with Next defaults.

Scenario: Testing: Jest vs Vitest with Next defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E071 — Drill 71: Junior says 'Next is just React with routing'.

Scenario: Junior says 'Next is just React with routing'. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E072 — Drill 72: Explain why `next/link` exists vs `<a href>`.

Scenario: Explain why next/link exists vs <a href>. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E073 — Drill 73: When would you use plain React in a widget embedded elsewhere?

Scenario: When would you use plain React in a widget embedded elsewhere? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E074 — Drill 74: Server Components vs traditional React tree mental load.

Scenario: Server Components vs traditional React tree mental load. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E075 — Drill 75: Who owns build pipeline: Webpack/Turbopack vs Vite defaults.

Scenario: Who owns build pipeline: Webpack/Turbopack vs Vite defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E076 — Drill 76: React 19 features and Next alignment lag concerns.

Scenario: React 19 features and Next alignment lag concerns. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E077 — Drill 77: Teaching hiring bar: React skills sufficient for Next hire?

Scenario: Teaching hiring bar: React skills sufficient for Next hire? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E078 — Drill 78: Micro-frontends vs single Next app trade-off.

Scenario: Micro-frontends vs single Next app trade-off. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E079 — Drill 79: Storybook + Next integration friction points.

Scenario: Storybook + Next integration friction points. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E080 — Drill 80: Testing: Jest vs Vitest with Next defaults.

Scenario: Testing: Jest vs Vitest with Next defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E081 — Drill 81: Junior says 'Next is just React with routing'.

Scenario: Junior says 'Next is just React with routing'. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E082 — Drill 82: Explain why `next/link` exists vs `<a href>`.

Scenario: Explain why next/link exists vs <a href>. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E083 — Drill 83: When would you use plain React in a widget embedded elsewhere?

Scenario: When would you use plain React in a widget embedded elsewhere? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E084 — Drill 84: Server Components vs traditional React tree mental load.

Scenario: Server Components vs traditional React tree mental load. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E085 — Drill 85: Who owns build pipeline: Webpack/Turbopack vs Vite defaults.

Scenario: Who owns build pipeline: Webpack/Turbopack vs Vite defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E086 — Drill 86: React 19 features and Next alignment lag concerns.

Scenario: React 19 features and Next alignment lag concerns. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E087 — Drill 87: Teaching hiring bar: React skills sufficient for Next hire?

Scenario: Teaching hiring bar: React skills sufficient for Next hire? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E088 — Drill 88: Micro-frontends vs single Next app trade-off.

Scenario: Micro-frontends vs single Next app trade-off. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E089 — Drill 89: Storybook + Next integration friction points.

Scenario: Storybook + Next integration friction points. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E090 — Drill 90: Testing: Jest vs Vitest with Next defaults.

Scenario: Testing: Jest vs Vitest with Next defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E091 — Drill 91: Junior says 'Next is just React with routing'.

Scenario: Junior says 'Next is just React with routing'. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E092 — Drill 92: Explain why `next/link` exists vs `<a href>`.

Scenario: Explain why next/link exists vs <a href>. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E093 — Drill 93: When would you use plain React in a widget embedded elsewhere?

Scenario: When would you use plain React in a widget embedded elsewhere? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E094 — Drill 94: Server Components vs traditional React tree mental load.

Scenario: Server Components vs traditional React tree mental load. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E095 — Drill 95: Who owns build pipeline: Webpack/Turbopack vs Vite defaults.

Scenario: Who owns build pipeline: Webpack/Turbopack vs Vite defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E096 — Drill 96: React 19 features and Next alignment lag concerns.

Scenario: React 19 features and Next alignment lag concerns. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E097 — Drill 97: Teaching hiring bar: React skills sufficient for Next hire?

Scenario: Teaching hiring bar: React skills sufficient for Next hire? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E098 — Drill 98: Micro-frontends vs single Next app trade-off.

Scenario: Micro-frontends vs single Next app trade-off. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E099 — Drill 99: Storybook + Next integration friction points.

Scenario: Storybook + Next integration friction points. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E100 — Drill 100: Testing: Jest vs Vitest with Next defaults.

Scenario: Testing: Jest vs Vitest with Next defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E101 — Drill 101: Junior says 'Next is just React with routing'.

Scenario: Junior says 'Next is just React with routing'. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E102 — Drill 102: Explain why `next/link` exists vs `<a href>`.

Scenario: Explain why next/link exists vs <a href>. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E103 — Drill 103: When would you use plain React in a widget embedded elsewhere?

Scenario: When would you use plain React in a widget embedded elsewhere? (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E104 — Drill 104: Server Components vs traditional React tree mental load.

Scenario: Server Components vs traditional React tree mental load. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}

E105 — Drill 105: Who owns build pipeline: Webpack/Turbopack vs Vite defaults.

Scenario: Who owns build pipeline: Webpack/Turbopack vs Vite defaults. (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.

// React alone: you wire router, data, HTML shell
// Next: conventions map URL → modules under app/
import Link from 'next/link';

export default function Home() {
  return <Link href="/about">About</Link>;
}