Episode 2 — React Frontend Architecture NextJS / 2.16 — Performance Optimization in React

2.16.f — Debugging re-renders with DevTools

<< 2.16 Overview

Learning outcomes

Use React DevTools Profiler to locate expensive commits.
Interpret “why did this render?” signals (where available).
Separate React render issues from layout/paint issues using the browser Performance panel.

Profiler workflow (repeatable)

Install React DevTools browser extension.
Open Profiler tab → start recording.
Perform the slow interaction once, slowly and consistently.
Stop recording.
Rank by time; inspect worst components.
Determine: props change vs state change vs context vs parent.

Highlight updates (teaching aid)

DevTools can flash updated boundaries. Useful for demos; for deep debugging, prefer Profiler recordings with notes.

Console logging: disciplined temporary probes

import { useRef } from "react";

export function useWhyRender(name: string, props: Record<string, unknown>) {
  const prev = useRef(props);
  // NOTE: dev-only pattern; remove before shipping noisy logs
  // Compare prev.current keys to props and log diffs
  prev.current = props;
}

Prefer removing logs after debugging; consider dedicated dev tooling in large repos.

Performance panel (Chrome)

Use the browser’s Performance trace when:

Commit time dominates.
You see long “Recalculate Style” or “Layout” blocks.
You suspect forced synchronous layouts from reading layout after writes.

Mental model: render vs commit

Render: React computes what should change.
Commit: DOM updates and effects run (conceptually; exact scheduling is internal).

Optimizing the wrong layer wastes weeks.

Appendix — Scenario bank (basic → advanced)

These scenarios are intentionally repetitive in shape but varied in forces so you build reflexes. For each one, practice saying: symptom → root cause → fix → how you prove it in DevTools.

DT-001 — DevTools rerender debugging scenario #1

Level: Beginner
User-visible symptom: UI jank when parent state updates every 13 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-002 — DevTools rerender debugging scenario #2

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 26 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-003 — DevTools rerender debugging scenario #3

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 39 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-004 — DevTools rerender debugging scenario #4

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 52 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-005 — DevTools rerender debugging scenario #5

Level: Advanced
User-visible symptom: UI jank when parent state updates every 65 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-006 — DevTools rerender debugging scenario #6

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 78 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-007 — DevTools rerender debugging scenario #7

Level: Beginner
User-visible symptom: UI jank when parent state updates every 91 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-008 — DevTools rerender debugging scenario #8

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 7 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-009 — DevTools rerender debugging scenario #9

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 20 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-010 — DevTools rerender debugging scenario #10

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 33 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-011 — DevTools rerender debugging scenario #11

Level: Advanced
User-visible symptom: UI jank when parent state updates every 46 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-012 — DevTools rerender debugging scenario #12

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 59 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-013 — DevTools rerender debugging scenario #13

Level: Beginner
User-visible symptom: UI jank when parent state updates every 72 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-014 — DevTools rerender debugging scenario #14

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 85 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-015 — DevTools rerender debugging scenario #15

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 1 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-016 — DevTools rerender debugging scenario #16

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 14 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-017 — DevTools rerender debugging scenario #17

Level: Advanced
User-visible symptom: UI jank when parent state updates every 27 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-018 — DevTools rerender debugging scenario #18

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 40 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-019 — DevTools rerender debugging scenario #19

Level: Beginner
User-visible symptom: UI jank when parent state updates every 53 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-020 — DevTools rerender debugging scenario #20

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 66 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-021 — DevTools rerender debugging scenario #21

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 79 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-022 — DevTools rerender debugging scenario #22

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 92 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-023 — DevTools rerender debugging scenario #23

Level: Advanced
User-visible symptom: UI jank when parent state updates every 8 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-024 — DevTools rerender debugging scenario #24

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 21 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-025 — DevTools rerender debugging scenario #25

Level: Beginner
User-visible symptom: UI jank when parent state updates every 34 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-026 — DevTools rerender debugging scenario #26

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 47 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-027 — DevTools rerender debugging scenario #27

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 60 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-028 — DevTools rerender debugging scenario #28

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 73 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-029 — DevTools rerender debugging scenario #29

Level: Advanced
User-visible symptom: UI jank when parent state updates every 86 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-030 — DevTools rerender debugging scenario #30

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 2 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-031 — DevTools rerender debugging scenario #31

Level: Beginner
User-visible symptom: UI jank when parent state updates every 15 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-032 — DevTools rerender debugging scenario #32

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 28 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-033 — DevTools rerender debugging scenario #33

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 41 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-034 — DevTools rerender debugging scenario #34

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 54 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-035 — DevTools rerender debugging scenario #35

Level: Advanced
User-visible symptom: UI jank when parent state updates every 67 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-036 — DevTools rerender debugging scenario #36

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 80 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-037 — DevTools rerender debugging scenario #37

Level: Beginner
User-visible symptom: UI jank when parent state updates every 93 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-038 — DevTools rerender debugging scenario #38

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 9 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-039 — DevTools rerender debugging scenario #39

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 22 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-040 — DevTools rerender debugging scenario #40

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 35 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-041 — DevTools rerender debugging scenario #41

Level: Advanced
User-visible symptom: UI jank when parent state updates every 48 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-042 — DevTools rerender debugging scenario #42

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 61 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-043 — DevTools rerender debugging scenario #43

Level: Beginner
User-visible symptom: UI jank when parent state updates every 74 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-044 — DevTools rerender debugging scenario #44

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 87 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-045 — DevTools rerender debugging scenario #45

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 3 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-046 — DevTools rerender debugging scenario #46

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 16 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-047 — DevTools rerender debugging scenario #47

Level: Advanced
User-visible symptom: UI jank when parent state updates every 29 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-048 — DevTools rerender debugging scenario #48

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 42 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-049 — DevTools rerender debugging scenario #49

Level: Beginner
User-visible symptom: UI jank when parent state updates every 55 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-050 — DevTools rerender debugging scenario #50

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 68 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-051 — DevTools rerender debugging scenario #51

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 81 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-052 — DevTools rerender debugging scenario #52

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 94 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-053 — DevTools rerender debugging scenario #53

Level: Advanced
User-visible symptom: UI jank when parent state updates every 10 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-054 — DevTools rerender debugging scenario #54

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 23 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-055 — DevTools rerender debugging scenario #55

Level: Beginner
User-visible symptom: UI jank when parent state updates every 36 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-056 — DevTools rerender debugging scenario #56

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 49 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-057 — DevTools rerender debugging scenario #57

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 62 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-058 — DevTools rerender debugging scenario #58

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 75 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-059 — DevTools rerender debugging scenario #59

Level: Advanced
User-visible symptom: UI jank when parent state updates every 88 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-060 — DevTools rerender debugging scenario #60

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 4 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-061 — DevTools rerender debugging scenario #61

Level: Beginner
User-visible symptom: UI jank when parent state updates every 17 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-062 — DevTools rerender debugging scenario #62

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 30 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-063 — DevTools rerender debugging scenario #63

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 43 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-064 — DevTools rerender debugging scenario #64

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 56 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-065 — DevTools rerender debugging scenario #65

Level: Advanced
User-visible symptom: UI jank when parent state updates every 69 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-066 — DevTools rerender debugging scenario #66

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 82 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-067 — DevTools rerender debugging scenario #67

Level: Beginner
User-visible symptom: UI jank when parent state updates every 95 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-068 — DevTools rerender debugging scenario #68

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 11 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-069 — DevTools rerender debugging scenario #69

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 24 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-070 — DevTools rerender debugging scenario #70

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 37 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-071 — DevTools rerender debugging scenario #71

Level: Advanced
User-visible symptom: UI jank when parent state updates every 50 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-072 — DevTools rerender debugging scenario #72

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 63 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-073 — DevTools rerender debugging scenario #73

Level: Beginner
User-visible symptom: UI jank when parent state updates every 76 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-074 — DevTools rerender debugging scenario #74

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 89 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-075 — DevTools rerender debugging scenario #75

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 5 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-076 — DevTools rerender debugging scenario #76

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 18 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-077 — DevTools rerender debugging scenario #77

Level: Advanced
User-visible symptom: UI jank when parent state updates every 31 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-078 — DevTools rerender debugging scenario #78

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 44 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-079 — DevTools rerender debugging scenario #79

Level: Beginner
User-visible symptom: UI jank when parent state updates every 57 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-080 — DevTools rerender debugging scenario #80

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 70 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-081 — DevTools rerender debugging scenario #81

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 83 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-082 — DevTools rerender debugging scenario #82

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 96 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-083 — DevTools rerender debugging scenario #83

Level: Advanced
User-visible symptom: UI jank when parent state updates every 12 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-084 — DevTools rerender debugging scenario #84

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 25 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-085 — DevTools rerender debugging scenario #85

Level: Beginner
User-visible symptom: UI jank when parent state updates every 38 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-086 — DevTools rerender debugging scenario #86

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 51 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-087 — DevTools rerender debugging scenario #87

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 64 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-088 — DevTools rerender debugging scenario #88

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 77 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-089 — DevTools rerender debugging scenario #89

Level: Advanced
User-visible symptom: UI jank when parent state updates every 90 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-090 — DevTools rerender debugging scenario #90

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 6 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-091 — DevTools rerender debugging scenario #91

Level: Beginner
User-visible symptom: UI jank when parent state updates every 19 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-092 — DevTools rerender debugging scenario #92

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 32 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-093 — DevTools rerender debugging scenario #93

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 45 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-094 — DevTools rerender debugging scenario #94

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 58 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-095 — DevTools rerender debugging scenario #95

Level: Advanced
User-visible symptom: UI jank when parent state updates every 71 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-096 — DevTools rerender debugging scenario #96

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 84 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-097 — DevTools rerender debugging scenario #97

Level: Beginner
User-visible symptom: UI jank when parent state updates every 0 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-098 — DevTools rerender debugging scenario #98

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 13 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-099 — DevTools rerender debugging scenario #99

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 26 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-100 — DevTools rerender debugging scenario #100

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 39 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-101 — DevTools rerender debugging scenario #101

Level: Advanced
User-visible symptom: UI jank when parent state updates every 52 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-102 — DevTools rerender debugging scenario #102

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 65 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-103 — DevTools rerender debugging scenario #103

Level: Beginner
User-visible symptom: UI jank when parent state updates every 78 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-104 — DevTools rerender debugging scenario #104

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 91 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-105 — DevTools rerender debugging scenario #105

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 7 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-106 — DevTools rerender debugging scenario #106

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 20 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-107 — DevTools rerender debugging scenario #107

Level: Advanced
User-visible symptom: UI jank when parent state updates every 33 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-108 — DevTools rerender debugging scenario #108

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 46 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-109 — DevTools rerender debugging scenario #109

Level: Beginner
User-visible symptom: UI jank when parent state updates every 59 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-110 — DevTools rerender debugging scenario #110

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 72 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-111 — DevTools rerender debugging scenario #111

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 85 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-112 — DevTools rerender debugging scenario #112

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 1 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-113 — DevTools rerender debugging scenario #113

Level: Advanced
User-visible symptom: UI jank when parent state updates every 14 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-114 — DevTools rerender debugging scenario #114

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 27 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-115 — DevTools rerender debugging scenario #115

Level: Beginner
User-visible symptom: UI jank when parent state updates every 40 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-116 — DevTools rerender debugging scenario #116

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 53 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-117 — DevTools rerender debugging scenario #117

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 66 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-118 — DevTools rerender debugging scenario #118

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 79 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-119 — DevTools rerender debugging scenario #119

Level: Advanced
User-visible symptom: UI jank when parent state updates every 92 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-120 — DevTools rerender debugging scenario #120

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 8 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-121 — DevTools rerender debugging scenario #121

Level: Beginner
User-visible symptom: UI jank when parent state updates every 21 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-122 — DevTools rerender debugging scenario #122

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 34 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-123 — DevTools rerender debugging scenario #123

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 47 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-124 — DevTools rerender debugging scenario #124

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 60 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-125 — DevTools rerender debugging scenario #125

Level: Advanced
User-visible symptom: UI jank when parent state updates every 73 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-126 — DevTools rerender debugging scenario #126

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 86 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-127 — DevTools rerender debugging scenario #127

Level: Beginner
User-visible symptom: UI jank when parent state updates every 2 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-128 — DevTools rerender debugging scenario #128

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 15 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-129 — DevTools rerender debugging scenario #129

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 28 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-130 — DevTools rerender debugging scenario #130

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 41 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-131 — DevTools rerender debugging scenario #131

Level: Advanced
User-visible symptom: UI jank when parent state updates every 54 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-132 — DevTools rerender debugging scenario #132

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 67 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-133 — DevTools rerender debugging scenario #133

Level: Beginner
User-visible symptom: UI jank when parent state updates every 80 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-134 — DevTools rerender debugging scenario #134

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 93 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-135 — DevTools rerender debugging scenario #135

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 9 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-136 — DevTools rerender debugging scenario #136

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 22 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-137 — DevTools rerender debugging scenario #137

Level: Advanced
User-visible symptom: UI jank when parent state updates every 35 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-138 — DevTools rerender debugging scenario #138

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 48 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-139 — DevTools rerender debugging scenario #139

Level: Beginner
User-visible symptom: UI jank when parent state updates every 61 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-140 — DevTools rerender debugging scenario #140

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 74 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-141 — DevTools rerender debugging scenario #141

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 87 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-142 — DevTools rerender debugging scenario #142

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 3 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-143 — DevTools rerender debugging scenario #143

Level: Advanced
User-visible symptom: UI jank when parent state updates every 16 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-144 — DevTools rerender debugging scenario #144

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 29 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-145 — DevTools rerender debugging scenario #145

Level: Beginner
User-visible symptom: UI jank when parent state updates every 42 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-146 — DevTools rerender debugging scenario #146

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 55 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-147 — DevTools rerender debugging scenario #147

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 68 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-148 — DevTools rerender debugging scenario #148

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 81 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-149 — DevTools rerender debugging scenario #149

Level: Advanced
User-visible symptom: UI jank when parent state updates every 94 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-150 — DevTools rerender debugging scenario #150

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 10 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-151 — DevTools rerender debugging scenario #151

Level: Beginner
User-visible symptom: UI jank when parent state updates every 23 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-152 — DevTools rerender debugging scenario #152

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 36 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-153 — DevTools rerender debugging scenario #153

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 49 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-154 — DevTools rerender debugging scenario #154

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 62 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-155 — DevTools rerender debugging scenario #155

Level: Advanced
User-visible symptom: UI jank when parent state updates every 75 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-156 — DevTools rerender debugging scenario #156

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 88 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-157 — DevTools rerender debugging scenario #157

Level: Beginner
User-visible symptom: UI jank when parent state updates every 4 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-158 — DevTools rerender debugging scenario #158

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 17 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-159 — DevTools rerender debugging scenario #159

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 30 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-160 — DevTools rerender debugging scenario #160

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 43 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-161 — DevTools rerender debugging scenario #161

Level: Advanced
User-visible symptom: UI jank when parent state updates every 56 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-162 — DevTools rerender debugging scenario #162

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 69 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-163 — DevTools rerender debugging scenario #163

Level: Beginner
User-visible symptom: UI jank when parent state updates every 82 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-164 — DevTools rerender debugging scenario #164

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 95 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-165 — DevTools rerender debugging scenario #165

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 11 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-166 — DevTools rerender debugging scenario #166

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 24 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-167 — DevTools rerender debugging scenario #167

Level: Advanced
User-visible symptom: UI jank when parent state updates every 37 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-168 — DevTools rerender debugging scenario #168

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 50 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-169 — DevTools rerender debugging scenario #169

Level: Beginner
User-visible symptom: UI jank when parent state updates every 63 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-170 — DevTools rerender debugging scenario #170

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 76 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-171 — DevTools rerender debugging scenario #171

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 89 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Explain StrictMode semantics to stakeholders when reporting numbers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-172 — DevTools rerender debugging scenario #172

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 5 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Reproduce in production build for render-count baselines.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-173 — DevTools rerender debugging scenario #173

Level: Advanced
User-visible symptom: UI jank when parent state updates every 18 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Use component filters; record short interactions; diff commits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

DT-174 — DevTools rerender debugging scenario #174

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 31 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Split context subscriptions; use selectors.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Profiler tells you where time went; it does not tell you why props changed until you investigate.

DT-175 — DevTools rerender debugging scenario #175

Level: Beginner
User-visible symptom: UI jank when parent state updates every 44 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Misreading Profiler: optimizing render while commit/layout is the bottleneck.
Primary remediation: Separate render vs commit costs; inspect layout thrash in Performance panel.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Treat re-render debugging like any bug: hypothesis, instrument, verify.

<< 2.16 Overview