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

2.18.d — File-Based Routing in Next.js

In one sentence: URLs map to the app directory tree; special files add layouts, loading states, and HTTP handlers—convention replaces a central route configuration file.

Navigation: ← Setting Up · Next → Layouts

1. File-based routing in the App Router

The URL path is derived from the folder tree under app/:

app/page.tsx           → /
app/about/page.tsx     → /about
app/blog/[slug]/page.tsx → /blog/:slug

Special files (non-routes) coexist: layout.tsx, loading.tsx, error.tsx, route.ts, etc.

1.1 Route groups `(folder)`

Folders wrapped in parentheses do not appear in the URL — useful for organizing marketing vs app surfaces.

1.2 Dynamic segments

[id], [...slug], [[...optional]] — param shapes differ; always validate and return notFound() when invalid.

1.3 Colocation

You may place non-route modules beside routes when using private folders or structured components/ trees—pick a team rule and keep imports tidy.

1.4 Middleware

middleware.ts runs before rendering for matched paths — auth redirects, A/B, geo headers.

Part 2 — Deep Encyclopedia (File-Based Routing in Next.js)

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: Optional catch-all `[[...slug]]` for docs site.

Scenario: Optional catch-all [[...slug]] for docs site. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E002 — Drill 2: Parallel routes for dashboard + modal pattern.

Scenario: Parallel routes for dashboard + modal pattern. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E003 — Drill 3: Intercepting routes for photo gallery modal.

Scenario: Intercepting routes for photo gallery modal. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E004 — Drill 4: Colocation of `page.tsx` and `route.ts` under same segment.

Scenario: Colocation of page.tsx and route.ts under same segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E005 — Drill 5: Route groups `(marketing)` without URL segment.

Scenario: Route groups (marketing) without URL segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E006 — Drill 6: Private `_components` folder convention.

Scenario: Private _components folder convention. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E007 — Drill 7: Dynamic `[id]` validation returning `notFound()`.

Scenario: Dynamic [id] validation returning notFound(). (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E008 — Drill 8: Internationalized `[locale]` segment ordering.

Scenario: Internationalized [locale] segment ordering. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E009 — Drill 9: Middleware matcher performance on high traffic.

Scenario: Middleware matcher performance on high traffic. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E010 — Drill 10: Soft navigation vs full reload when explaining `Link`.

Scenario: Soft navigation vs full reload when explaining Link. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E011 — Drill 11: Optional catch-all `[[...slug]]` for docs site.

Scenario: Optional catch-all [[...slug]] for docs site. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E012 — Drill 12: Parallel routes for dashboard + modal pattern.

Scenario: Parallel routes for dashboard + modal pattern. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E013 — Drill 13: Intercepting routes for photo gallery modal.

Scenario: Intercepting routes for photo gallery modal. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E014 — Drill 14: Colocation of `page.tsx` and `route.ts` under same segment.

Scenario: Colocation of page.tsx and route.ts under same segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E015 — Drill 15: Route groups `(marketing)` without URL segment.

Scenario: Route groups (marketing) without URL segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E016 — Drill 16: Private `_components` folder convention.

Scenario: Private _components folder convention. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E017 — Drill 17: Dynamic `[id]` validation returning `notFound()`.

Scenario: Dynamic [id] validation returning notFound(). (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E018 — Drill 18: Internationalized `[locale]` segment ordering.

Scenario: Internationalized [locale] segment ordering. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E019 — Drill 19: Middleware matcher performance on high traffic.

Scenario: Middleware matcher performance on high traffic. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E020 — Drill 20: Soft navigation vs full reload when explaining `Link`.

Scenario: Soft navigation vs full reload when explaining Link. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E021 — Drill 21: Optional catch-all `[[...slug]]` for docs site.

Scenario: Optional catch-all [[...slug]] for docs site. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E022 — Drill 22: Parallel routes for dashboard + modal pattern.

Scenario: Parallel routes for dashboard + modal pattern. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E023 — Drill 23: Intercepting routes for photo gallery modal.

Scenario: Intercepting routes for photo gallery modal. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E024 — Drill 24: Colocation of `page.tsx` and `route.ts` under same segment.

Scenario: Colocation of page.tsx and route.ts under same segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E025 — Drill 25: Route groups `(marketing)` without URL segment.

Scenario: Route groups (marketing) without URL segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E026 — Drill 26: Private `_components` folder convention.

Scenario: Private _components folder convention. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E027 — Drill 27: Dynamic `[id]` validation returning `notFound()`.

Scenario: Dynamic [id] validation returning notFound(). (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E028 — Drill 28: Internationalized `[locale]` segment ordering.

Scenario: Internationalized [locale] segment ordering. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E029 — Drill 29: Middleware matcher performance on high traffic.

Scenario: Middleware matcher performance on high traffic. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E030 — Drill 30: Soft navigation vs full reload when explaining `Link`.

Scenario: Soft navigation vs full reload when explaining Link. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E031 — Drill 31: Optional catch-all `[[...slug]]` for docs site.

Scenario: Optional catch-all [[...slug]] for docs site. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E032 — Drill 32: Parallel routes for dashboard + modal pattern.

Scenario: Parallel routes for dashboard + modal pattern. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E033 — Drill 33: Intercepting routes for photo gallery modal.

Scenario: Intercepting routes for photo gallery modal. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E034 — Drill 34: Colocation of `page.tsx` and `route.ts` under same segment.

Scenario: Colocation of page.tsx and route.ts under same segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E035 — Drill 35: Route groups `(marketing)` without URL segment.

Scenario: Route groups (marketing) without URL segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E036 — Drill 36: Private `_components` folder convention.

Scenario: Private _components folder convention. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E037 — Drill 37: Dynamic `[id]` validation returning `notFound()`.

Scenario: Dynamic [id] validation returning notFound(). (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E038 — Drill 38: Internationalized `[locale]` segment ordering.

Scenario: Internationalized [locale] segment ordering. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E039 — Drill 39: Middleware matcher performance on high traffic.

Scenario: Middleware matcher performance on high traffic. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E040 — Drill 40: Soft navigation vs full reload when explaining `Link`.

Scenario: Soft navigation vs full reload when explaining Link. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E041 — Drill 41: Optional catch-all `[[...slug]]` for docs site.

Scenario: Optional catch-all [[...slug]] for docs site. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E042 — Drill 42: Parallel routes for dashboard + modal pattern.

Scenario: Parallel routes for dashboard + modal pattern. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E043 — Drill 43: Intercepting routes for photo gallery modal.

Scenario: Intercepting routes for photo gallery modal. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E044 — Drill 44: Colocation of `page.tsx` and `route.ts` under same segment.

Scenario: Colocation of page.tsx and route.ts under same segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E045 — Drill 45: Route groups `(marketing)` without URL segment.

Scenario: Route groups (marketing) without URL segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E046 — Drill 46: Private `_components` folder convention.

Scenario: Private _components folder convention. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E047 — Drill 47: Dynamic `[id]` validation returning `notFound()`.

Scenario: Dynamic [id] validation returning notFound(). (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E048 — Drill 48: Internationalized `[locale]` segment ordering.

Scenario: Internationalized [locale] segment ordering. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E049 — Drill 49: Middleware matcher performance on high traffic.

Scenario: Middleware matcher performance on high traffic. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E050 — Drill 50: Soft navigation vs full reload when explaining `Link`.

Scenario: Soft navigation vs full reload when explaining Link. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E051 — Drill 51: Optional catch-all `[[...slug]]` for docs site.

Scenario: Optional catch-all [[...slug]] for docs site. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E052 — Drill 52: Parallel routes for dashboard + modal pattern.

Scenario: Parallel routes for dashboard + modal pattern. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E053 — Drill 53: Intercepting routes for photo gallery modal.

Scenario: Intercepting routes for photo gallery modal. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E054 — Drill 54: Colocation of `page.tsx` and `route.ts` under same segment.

Scenario: Colocation of page.tsx and route.ts under same segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E055 — Drill 55: Route groups `(marketing)` without URL segment.

Scenario: Route groups (marketing) without URL segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E056 — Drill 56: Private `_components` folder convention.

Scenario: Private _components folder convention. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E057 — Drill 57: Dynamic `[id]` validation returning `notFound()`.

Scenario: Dynamic [id] validation returning notFound(). (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E058 — Drill 58: Internationalized `[locale]` segment ordering.

Scenario: Internationalized [locale] segment ordering. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E059 — Drill 59: Middleware matcher performance on high traffic.

Scenario: Middleware matcher performance on high traffic. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E060 — Drill 60: Soft navigation vs full reload when explaining `Link`.

Scenario: Soft navigation vs full reload when explaining Link. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E061 — Drill 61: Optional catch-all `[[...slug]]` for docs site.

Scenario: Optional catch-all [[...slug]] for docs site. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E062 — Drill 62: Parallel routes for dashboard + modal pattern.

Scenario: Parallel routes for dashboard + modal pattern. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E063 — Drill 63: Intercepting routes for photo gallery modal.

Scenario: Intercepting routes for photo gallery modal. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E064 — Drill 64: Colocation of `page.tsx` and `route.ts` under same segment.

Scenario: Colocation of page.tsx and route.ts under same segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E065 — Drill 65: Route groups `(marketing)` without URL segment.

Scenario: Route groups (marketing) without URL segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E066 — Drill 66: Private `_components` folder convention.

Scenario: Private _components folder convention. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E067 — Drill 67: Dynamic `[id]` validation returning `notFound()`.

Scenario: Dynamic [id] validation returning notFound(). (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E068 — Drill 68: Internationalized `[locale]` segment ordering.

Scenario: Internationalized [locale] segment ordering. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E069 — Drill 69: Middleware matcher performance on high traffic.

Scenario: Middleware matcher performance on high traffic. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E070 — Drill 70: Soft navigation vs full reload when explaining `Link`.

Scenario: Soft navigation vs full reload when explaining Link. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E071 — Drill 71: Optional catch-all `[[...slug]]` for docs site.

Scenario: Optional catch-all [[...slug]] for docs site. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E072 — Drill 72: Parallel routes for dashboard + modal pattern.

Scenario: Parallel routes for dashboard + modal pattern. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E073 — Drill 73: Intercepting routes for photo gallery modal.

Scenario: Intercepting routes for photo gallery modal. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E074 — Drill 74: Colocation of `page.tsx` and `route.ts` under same segment.

Scenario: Colocation of page.tsx and route.ts under same segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E075 — Drill 75: Route groups `(marketing)` without URL segment.

Scenario: Route groups (marketing) without URL segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E076 — Drill 76: Private `_components` folder convention.

Scenario: Private _components folder convention. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E077 — Drill 77: Dynamic `[id]` validation returning `notFound()`.

Scenario: Dynamic [id] validation returning notFound(). (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E078 — Drill 78: Internationalized `[locale]` segment ordering.

Scenario: Internationalized [locale] segment ordering. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E079 — Drill 79: Middleware matcher performance on high traffic.

Scenario: Middleware matcher performance on high traffic. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E080 — Drill 80: Soft navigation vs full reload when explaining `Link`.

Scenario: Soft navigation vs full reload when explaining Link. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E081 — Drill 81: Optional catch-all `[[...slug]]` for docs site.

Scenario: Optional catch-all [[...slug]] for docs site. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E082 — Drill 82: Parallel routes for dashboard + modal pattern.

Scenario: Parallel routes for dashboard + modal pattern. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E083 — Drill 83: Intercepting routes for photo gallery modal.

Scenario: Intercepting routes for photo gallery modal. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E084 — Drill 84: Colocation of `page.tsx` and `route.ts` under same segment.

Scenario: Colocation of page.tsx and route.ts under same segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E085 — Drill 85: Route groups `(marketing)` without URL segment.

Scenario: Route groups (marketing) without URL segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E086 — Drill 86: Private `_components` folder convention.

Scenario: Private _components folder convention. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E087 — Drill 87: Dynamic `[id]` validation returning `notFound()`.

Scenario: Dynamic [id] validation returning notFound(). (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E088 — Drill 88: Internationalized `[locale]` segment ordering.

Scenario: Internationalized [locale] segment ordering. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E089 — Drill 89: Middleware matcher performance on high traffic.

Scenario: Middleware matcher performance on high traffic. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E090 — Drill 90: Soft navigation vs full reload when explaining `Link`.

Scenario: Soft navigation vs full reload when explaining Link. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E091 — Drill 91: Optional catch-all `[[...slug]]` for docs site.

Scenario: Optional catch-all [[...slug]] for docs site. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E092 — Drill 92: Parallel routes for dashboard + modal pattern.

Scenario: Parallel routes for dashboard + modal pattern. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E093 — Drill 93: Intercepting routes for photo gallery modal.

Scenario: Intercepting routes for photo gallery modal. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E094 — Drill 94: Colocation of `page.tsx` and `route.ts` under same segment.

Scenario: Colocation of page.tsx and route.ts under same segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E095 — Drill 95: Route groups `(marketing)` without URL segment.

Scenario: Route groups (marketing) without URL segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E096 — Drill 96: Private `_components` folder convention.

Scenario: Private _components folder convention. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E097 — Drill 97: Dynamic `[id]` validation returning `notFound()`.

Scenario: Dynamic [id] validation returning notFound(). (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E098 — Drill 98: Internationalized `[locale]` segment ordering.

Scenario: Internationalized [locale] segment ordering. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E099 — Drill 99: Middleware matcher performance on high traffic.

Scenario: Middleware matcher performance on high traffic. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E100 — Drill 100: Soft navigation vs full reload when explaining `Link`.

Scenario: Soft navigation vs full reload when explaining Link. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E101 — Drill 101: Optional catch-all `[[...slug]]` for docs site.

Scenario: Optional catch-all [[...slug]] for docs site. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E102 — Drill 102: Parallel routes for dashboard + modal pattern.

Scenario: Parallel routes for dashboard + modal pattern. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E103 — Drill 103: Intercepting routes for photo gallery modal.

Scenario: Intercepting routes for photo gallery modal. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E104 — Drill 104: Colocation of `page.tsx` and `route.ts` under same segment.

Scenario: Colocation of page.tsx and route.ts under same segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

E105 — Drill 105: Route groups `(marketing)` without URL segment.

Scenario: Route groups (marketing) without URL segment. (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.

// app/blog/[slug]/page.tsx
export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params;
  return <article>{slug}</article>;
}

2.18.d — File-Based Routing in Next.js

1. File-based routing in the App Router

1.1 Route groups (folder)

1.2 Dynamic segments

1.3 Colocation

1.4 Middleware

Part 2 — Deep Encyclopedia (File-Based Routing in Next.js)

E001 — Drill 1: Optional catch-all [[...slug]] for docs site.

E002 — Drill 2: Parallel routes for dashboard + modal pattern.

E003 — Drill 3: Intercepting routes for photo gallery modal.

E004 — Drill 4: Colocation of page.tsx and route.ts under same segment.

E005 — Drill 5: Route groups (marketing) without URL segment.

E006 — Drill 6: Private _components folder convention.

E007 — Drill 7: Dynamic [id] validation returning notFound().

E008 — Drill 8: Internationalized [locale] segment ordering.

E009 — Drill 9: Middleware matcher performance on high traffic.

E010 — Drill 10: Soft navigation vs full reload when explaining Link.

E011 — Drill 11: Optional catch-all [[...slug]] for docs site.

E012 — Drill 12: Parallel routes for dashboard + modal pattern.

E013 — Drill 13: Intercepting routes for photo gallery modal.

E014 — Drill 14: Colocation of page.tsx and route.ts under same segment.

E015 — Drill 15: Route groups (marketing) without URL segment.

E016 — Drill 16: Private _components folder convention.

E017 — Drill 17: Dynamic [id] validation returning notFound().

E018 — Drill 18: Internationalized [locale] segment ordering.