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

2.16.e — Lighthouse performance testing

Learning outcomes

Read Lighthouse performance scores without cargo-culting single metrics.
Map Lighthouse opportunities to React-level fixes vs asset-level fixes.
Set up repeatable lab tests and interpret them alongside field data.

What Lighthouse is (and is not)

Lighthouse is a lab auditing tool. It runs a controlled page load (and can run broader scripts depending on setup) and reports categories like Performance, Accessibility, Best Practices, and SEO.

It is not a substitute for:

Real-user monitoring (RUM) of Core Web Vitals.
Backend/database performance analysis.
Profiling complex SPA interactions unless you explicitly model them.

Core Web Vitals (performance-relevant)

Conceptual trio most discussed for UX:

LCP: perceived load—large content paint timing.
INP / legacy FID: responsiveness to input (FID is older; INP is the modern interaction metric in many contexts—verify current guidance for your reporting stack).
CLS: visual stability / layout shift.

Use Lighthouse to guide investigations; use field metrics to validate reality.

Typical React fixes surfaced by Lighthouse

Reduce JS payload: code splitting, remove unused deps, tree-shake properly.
Image optimization: responsive images, modern formats, avoid giant unoptimized assets.
Render-blocking resources: defer non-critical CSS/JS strategies depending on hosting.
Main-thread long tasks: investigate heavy synchronous work in event handlers.

CI patterns (high level)

Run Lighthouse against preview URLs on PRs for representative routes.
Fail builds on regressions beyond a threshold (carefully tuned to avoid flakiness).
Store HTML reports as artifacts.

Common pitfalls

Testing only on fast hardware.
Ignoring throttling settings.
Chasing a Lighthouse score while INP in the field remains bad due to real user devices.

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.

LH-001 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-002 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-003 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-004 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-005 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-006 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-007 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-008 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-009 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-010 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-011 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-012 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-013 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-014 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-015 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-016 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-017 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-018 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-019 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-020 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-021 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-022 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-023 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-024 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-025 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-026 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-027 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-028 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-029 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-030 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-031 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-032 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-033 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-034 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-035 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-036 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-037 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-038 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-039 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-040 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-041 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-042 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-043 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-044 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-045 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-046 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-047 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-048 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-049 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-050 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-051 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-052 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-053 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-054 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-055 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-056 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-057 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-058 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-059 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-060 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-061 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-062 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-063 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-064 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-065 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-066 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-067 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-068 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-069 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-070 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-071 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-072 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-073 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-074 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-075 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-076 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-077 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-078 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-079 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-080 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-081 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-082 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-083 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-084 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-085 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-086 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-087 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-088 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-089 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-090 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-091 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-092 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-093 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-094 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-095 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-096 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-097 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-098 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-099 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-100 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-101 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-102 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-103 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-104 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-105 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-106 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-107 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-108 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-109 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-110 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-111 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-112 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-113 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-114 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-115 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-116 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-117 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-118 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-119 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-120 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-121 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-122 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-123 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-124 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-125 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-126 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-127 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-128 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-129 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-130 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-131 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-132 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-133 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-134 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-135 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-136 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-137 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-138 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-139 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-140 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-141 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-142 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-143 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-144 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-145 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-146 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-147 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-148 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-149 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-150 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-151 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-152 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-153 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-154 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-155 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-156 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-157 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-158 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-159 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-160 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-161 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-162 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-163 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-164 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-165 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-166 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-167 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-168 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-169 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-170 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-171 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Defer non-critical third parties; isolate with facades.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-172 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Add scripted flows for SPA navigations where applicable.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-173 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Use Lighthouse treemap + coverage to attack bundle bloat first when JS is the bottleneck.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

LH-174 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Test throttled CPU/network profiles reproducibly.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Lighthouse is a guided lab audit; field data tells you what real users feel.

LH-175 — Lighthouse performance 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: Lab Lighthouse on supercomputer while users are on mid Android—metric mismatch.
Primary remediation: Track Core Web Vitals in the field (RUM) alongside lab audits.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Optimize the critical path: less JS, less layout thrash, fewer blocking resources.

<< 2.16 Overview