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

2.18.c — Setting Up a New Next.js Project

In one sentence: Scaffolding sets conventions—TypeScript, ESLint, App Router, and env handling—so the team spends time on product rules instead of build plumbing debates.

Navigation: ← Framework vs Library · Next → File-Based Routing

1. Bootstrapping a project (mental checklist)

Pick package manager consistent with monorepo/CI.
Enable TypeScript for long-lived apps unless prototype-only.
Linting — align rules with existing org standards.
App Router default for new work (verify team policy).
Git init, README with scripts, Node engine field or .nvmrc.

1.1 `create-next-app` role

Scaffolds opinionated defaults: ESLint, src/ optional, import aliases (@/*), example routes.

1.2 Scripts you actually run

Script	Purpose
`dev`	Fast refresh local server
`build`	Production compile
`start`	Run production build
`lint`	Static analysis in CI

1.3 Environment files

.env.local for developer secrets (never commit). Align public vs server-only variables (NEXT_PUBLIC_* exposes to browser).

1.4 First production deploy concerns

Output mode if static export needed.
Image domains allowlist.
Region for data residency.

1.5 Editor and DX defaults

Recommended baseline: TypeScript strictness aligned with org (not necessarily strict: true on day one for brownfield ports, but greenfield should start strict). Turn on format-on-save and share VS Code workspace settings only when the whole team agrees—otherwise document in README.

1.6 `next.config` first decisions

Option	Why it matters early
`images.remotePatterns`	Prevents accidental hotlinking / open proxy
`experimental` flags	Pin review dates—upgrade playbook
`redirects` / `rewrites`	Legacy URL compatibility

Ship small: start from defaults; add config only when a requirement fails without it.

1.7 Quality gates in CI

Minimum respectable pipeline:

npm run lint (or pnpm lint)
npm run build (catches type + Next build errors)

Optional: test, bundle analysis on main branch.

1.8 Docker sketch (Node deploy)

Multi-stage: deps → builder (next build) → runner (next start or standalone output per docs). Keep non-root user in final image. Document port (3000) and healthcheck endpoint (/api/health you add).

1.9 Preview deployments

Feature branches → preview URL per PR helps designers and PMs. Environment: mirror production-like auth callbacks using preview OAuth clients where applicable.

1.10 Secrets rotation

When a developer leaves: rotate preview and production secrets that were on their laptop. NEXT_PUBLIC_* values are not secrets—anything truly secret stays server-only.

1.11 Upgrading Next

Read release notes for breaking changes in caching, fetch defaults, and middleware matchers. Maintain an ADR (“Why we skipped 14.x for two sprints”) if the team lags.

1.12 Checklist before calling “setup done”

README: Node version, install, dev, build, start
.env.example with dummy keys documented
CI green on scaffold
First route merged demonstrates layout + metadata pattern

Part 2 — Deep Encyclopedia (Setting Up a New Next.js Project)

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: pnpm vs npm vs yarn in CI cache strategy.

Scenario: pnpm vs npm vs yarn in CI cache strategy. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E002 — Drill 2: TypeScript strict mode breaks scaffold

Scenario: TypeScript strict mode breaks scaffold — policy? (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E003 — Drill 3: ESLint flat config migration on new project.

Scenario: ESLint flat config migration on new project. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E004 — Drill 4: `src/` directory vs root `app/` preference.

Scenario: src/ directory vs root app/ preference. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E005 — Drill 5: Environment variables for preview vs production.

Scenario: Environment variables for preview vs production. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E006 — Drill 6: Dockerfile multi-stage for `next start`.

Scenario: Dockerfile multi-stage for next start. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E007 — Drill 7: Monorepo Turborepo wiring shared UI package.

Scenario: Monorepo Turborepo wiring shared UI package. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E008 — Drill 8: Husky pre-commit on large team adoption.

Scenario: Husky pre-commit on large team adoption. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E009 — Drill 9: Node version pinning with `.nvmrc`.

Scenario: Node version pinning with .nvmrc. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E010 — Drill 10: First deploy: custom domain + HTTPS redirect.

Scenario: First deploy: custom domain + HTTPS redirect. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E011 — Drill 11: pnpm vs npm vs yarn in CI cache strategy.

Scenario: pnpm vs npm vs yarn in CI cache strategy. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E012 — Drill 12: TypeScript strict mode breaks scaffold

Scenario: TypeScript strict mode breaks scaffold — policy? (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E013 — Drill 13: ESLint flat config migration on new project.

Scenario: ESLint flat config migration on new project. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E014 — Drill 14: `src/` directory vs root `app/` preference.

Scenario: src/ directory vs root app/ preference. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E015 — Drill 15: Environment variables for preview vs production.

Scenario: Environment variables for preview vs production. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E016 — Drill 16: Dockerfile multi-stage for `next start`.

Scenario: Dockerfile multi-stage for next start. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E017 — Drill 17: Monorepo Turborepo wiring shared UI package.

Scenario: Monorepo Turborepo wiring shared UI package. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E018 — Drill 18: Husky pre-commit on large team adoption.

Scenario: Husky pre-commit on large team adoption. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E019 — Drill 19: Node version pinning with `.nvmrc`.

Scenario: Node version pinning with .nvmrc. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E020 — Drill 20: First deploy: custom domain + HTTPS redirect.

Scenario: First deploy: custom domain + HTTPS redirect. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E021 — Drill 21: pnpm vs npm vs yarn in CI cache strategy.

Scenario: pnpm vs npm vs yarn in CI cache strategy. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E022 — Drill 22: TypeScript strict mode breaks scaffold

Scenario: TypeScript strict mode breaks scaffold — policy? (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E023 — Drill 23: ESLint flat config migration on new project.

Scenario: ESLint flat config migration on new project. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E024 — Drill 24: `src/` directory vs root `app/` preference.

Scenario: src/ directory vs root app/ preference. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E025 — Drill 25: Environment variables for preview vs production.

Scenario: Environment variables for preview vs production. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E026 — Drill 26: Dockerfile multi-stage for `next start`.

Scenario: Dockerfile multi-stage for next start. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E027 — Drill 27: Monorepo Turborepo wiring shared UI package.

Scenario: Monorepo Turborepo wiring shared UI package. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E028 — Drill 28: Husky pre-commit on large team adoption.

Scenario: Husky pre-commit on large team adoption. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E029 — Drill 29: Node version pinning with `.nvmrc`.

Scenario: Node version pinning with .nvmrc. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E030 — Drill 30: First deploy: custom domain + HTTPS redirect.

Scenario: First deploy: custom domain + HTTPS redirect. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E031 — Drill 31: pnpm vs npm vs yarn in CI cache strategy.

Scenario: pnpm vs npm vs yarn in CI cache strategy. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E032 — Drill 32: TypeScript strict mode breaks scaffold

Scenario: TypeScript strict mode breaks scaffold — policy? (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E033 — Drill 33: ESLint flat config migration on new project.

Scenario: ESLint flat config migration on new project. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E034 — Drill 34: `src/` directory vs root `app/` preference.

Scenario: src/ directory vs root app/ preference. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E035 — Drill 35: Environment variables for preview vs production.

Scenario: Environment variables for preview vs production. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E036 — Drill 36: Dockerfile multi-stage for `next start`.

Scenario: Dockerfile multi-stage for next start. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E037 — Drill 37: Monorepo Turborepo wiring shared UI package.

Scenario: Monorepo Turborepo wiring shared UI package. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E038 — Drill 38: Husky pre-commit on large team adoption.

Scenario: Husky pre-commit on large team adoption. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E039 — Drill 39: Node version pinning with `.nvmrc`.

Scenario: Node version pinning with .nvmrc. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E040 — Drill 40: First deploy: custom domain + HTTPS redirect.

Scenario: First deploy: custom domain + HTTPS redirect. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E041 — Drill 41: pnpm vs npm vs yarn in CI cache strategy.

Scenario: pnpm vs npm vs yarn in CI cache strategy. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E042 — Drill 42: TypeScript strict mode breaks scaffold

Scenario: TypeScript strict mode breaks scaffold — policy? (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E043 — Drill 43: ESLint flat config migration on new project.

Scenario: ESLint flat config migration on new project. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E044 — Drill 44: `src/` directory vs root `app/` preference.

Scenario: src/ directory vs root app/ preference. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E045 — Drill 45: Environment variables for preview vs production.

Scenario: Environment variables for preview vs production. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E046 — Drill 46: Dockerfile multi-stage for `next start`.

Scenario: Dockerfile multi-stage for next start. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E047 — Drill 47: Monorepo Turborepo wiring shared UI package.

Scenario: Monorepo Turborepo wiring shared UI package. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E048 — Drill 48: Husky pre-commit on large team adoption.

Scenario: Husky pre-commit on large team adoption. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E049 — Drill 49: Node version pinning with `.nvmrc`.

Scenario: Node version pinning with .nvmrc. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E050 — Drill 50: First deploy: custom domain + HTTPS redirect.

Scenario: First deploy: custom domain + HTTPS redirect. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E051 — Drill 51: pnpm vs npm vs yarn in CI cache strategy.

Scenario: pnpm vs npm vs yarn in CI cache strategy. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E052 — Drill 52: TypeScript strict mode breaks scaffold

Scenario: TypeScript strict mode breaks scaffold — policy? (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E053 — Drill 53: ESLint flat config migration on new project.

Scenario: ESLint flat config migration on new project. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E054 — Drill 54: `src/` directory vs root `app/` preference.

Scenario: src/ directory vs root app/ preference. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E055 — Drill 55: Environment variables for preview vs production.

Scenario: Environment variables for preview vs production. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E056 — Drill 56: Dockerfile multi-stage for `next start`.

Scenario: Dockerfile multi-stage for next start. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E057 — Drill 57: Monorepo Turborepo wiring shared UI package.

Scenario: Monorepo Turborepo wiring shared UI package. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E058 — Drill 58: Husky pre-commit on large team adoption.

Scenario: Husky pre-commit on large team adoption. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E059 — Drill 59: Node version pinning with `.nvmrc`.

Scenario: Node version pinning with .nvmrc. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E060 — Drill 60: First deploy: custom domain + HTTPS redirect.

Scenario: First deploy: custom domain + HTTPS redirect. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E061 — Drill 61: pnpm vs npm vs yarn in CI cache strategy.

Scenario: pnpm vs npm vs yarn in CI cache strategy. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E062 — Drill 62: TypeScript strict mode breaks scaffold

Scenario: TypeScript strict mode breaks scaffold — policy? (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E063 — Drill 63: ESLint flat config migration on new project.

Scenario: ESLint flat config migration on new project. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E064 — Drill 64: `src/` directory vs root `app/` preference.

Scenario: src/ directory vs root app/ preference. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E065 — Drill 65: Environment variables for preview vs production.

Scenario: Environment variables for preview vs production. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E066 — Drill 66: Dockerfile multi-stage for `next start`.

Scenario: Dockerfile multi-stage for next start. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E067 — Drill 67: Monorepo Turborepo wiring shared UI package.

Scenario: Monorepo Turborepo wiring shared UI package. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E068 — Drill 68: Husky pre-commit on large team adoption.

Scenario: Husky pre-commit on large team adoption. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E069 — Drill 69: Node version pinning with `.nvmrc`.

Scenario: Node version pinning with .nvmrc. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E070 — Drill 70: First deploy: custom domain + HTTPS redirect.

Scenario: First deploy: custom domain + HTTPS redirect. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E071 — Drill 71: pnpm vs npm vs yarn in CI cache strategy.

Scenario: pnpm vs npm vs yarn in CI cache strategy. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E072 — Drill 72: TypeScript strict mode breaks scaffold

Scenario: TypeScript strict mode breaks scaffold — policy? (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E073 — Drill 73: ESLint flat config migration on new project.

Scenario: ESLint flat config migration on new project. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E074 — Drill 74: `src/` directory vs root `app/` preference.

Scenario: src/ directory vs root app/ preference. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E075 — Drill 75: Environment variables for preview vs production.

Scenario: Environment variables for preview vs production. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E076 — Drill 76: Dockerfile multi-stage for `next start`.

Scenario: Dockerfile multi-stage for next start. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E077 — Drill 77: Monorepo Turborepo wiring shared UI package.

Scenario: Monorepo Turborepo wiring shared UI package. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E078 — Drill 78: Husky pre-commit on large team adoption.

Scenario: Husky pre-commit on large team adoption. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E079 — Drill 79: Node version pinning with `.nvmrc`.

Scenario: Node version pinning with .nvmrc. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E080 — Drill 80: First deploy: custom domain + HTTPS redirect.

Scenario: First deploy: custom domain + HTTPS redirect. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E081 — Drill 81: pnpm vs npm vs yarn in CI cache strategy.

Scenario: pnpm vs npm vs yarn in CI cache strategy. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E082 — Drill 82: TypeScript strict mode breaks scaffold

Scenario: TypeScript strict mode breaks scaffold — policy? (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E083 — Drill 83: ESLint flat config migration on new project.

Scenario: ESLint flat config migration on new project. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E084 — Drill 84: `src/` directory vs root `app/` preference.

Scenario: src/ directory vs root app/ preference. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E085 — Drill 85: Environment variables for preview vs production.

Scenario: Environment variables for preview vs production. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E086 — Drill 86: Dockerfile multi-stage for `next start`.

Scenario: Dockerfile multi-stage for next start. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E087 — Drill 87: Monorepo Turborepo wiring shared UI package.

Scenario: Monorepo Turborepo wiring shared UI package. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E088 — Drill 88: Husky pre-commit on large team adoption.

Scenario: Husky pre-commit on large team adoption. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E089 — Drill 89: Node version pinning with `.nvmrc`.

Scenario: Node version pinning with .nvmrc. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E090 — Drill 90: First deploy: custom domain + HTTPS redirect.

Scenario: First deploy: custom domain + HTTPS redirect. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E091 — Drill 91: pnpm vs npm vs yarn in CI cache strategy.

Scenario: pnpm vs npm vs yarn in CI cache strategy. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E092 — Drill 92: TypeScript strict mode breaks scaffold

Scenario: TypeScript strict mode breaks scaffold — policy? (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E093 — Drill 93: ESLint flat config migration on new project.

Scenario: ESLint flat config migration on new project. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E094 — Drill 94: `src/` directory vs root `app/` preference.

Scenario: src/ directory vs root app/ preference. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E095 — Drill 95: Environment variables for preview vs production.

Scenario: Environment variables for preview vs production. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E096 — Drill 96: Dockerfile multi-stage for `next start`.

Scenario: Dockerfile multi-stage for next start. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E097 — Drill 97: Monorepo Turborepo wiring shared UI package.

Scenario: Monorepo Turborepo wiring shared UI package. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E098 — Drill 98: Husky pre-commit on large team adoption.

Scenario: Husky pre-commit on large team adoption. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E099 — Drill 99: Node version pinning with `.nvmrc`.

Scenario: Node version pinning with .nvmrc. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E100 — Drill 100: First deploy: custom domain + HTTPS redirect.

Scenario: First deploy: custom domain + HTTPS redirect. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E101 — Drill 101: pnpm vs npm vs yarn in CI cache strategy.

Scenario: pnpm vs npm vs yarn in CI cache strategy. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E102 — Drill 102: TypeScript strict mode breaks scaffold

Scenario: TypeScript strict mode breaks scaffold — policy? (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E103 — Drill 103: ESLint flat config migration on new project.

Scenario: ESLint flat config migration on new project. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E104 — Drill 104: `src/` directory vs root `app/` preference.

Scenario: src/ directory vs root app/ preference. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app

E105 — Drill 105: Environment variables for preview vs production.

Scenario: Environment variables for preview vs production. (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.

// Typical create (check latest docs for flags)
// npx create-next-app@latest my-app --typescript --eslint --app