2.14.a — Introduction: what Redux is, when/why to use it, and state libraries

<< 2.14 Overview

---

Learning outcomes

1. Define Redux in one precise paragraph (not buzzwords).
2. Explain when Redux is worth the complexity vs local state, URL state, or React Context.
3. Compare Redux to other state management libraries at a high level.

---

What is Redux?

Redux is a small library for managing predictable global client state in JavaScript apps. The core idea:

• You keep application state in a single store object tree.
• The only way to change that state is to dispatch an action (a plain object describing what happened).
• Reducers are pure functions that compute the next state from the previous state and an action.

Redux is not React-specific, but it is commonly used with React via react-redux.

---

When Redux tends to help

Strong signals:

• Many distant components read/write the same cross-cutting client state (session UI flags, complex wizard progress, multi-route filters that must remain consistent).
• You need strict update rules and auditability (action logs for support debugging).
• You want replayable state transitions (devtools time travel, reproducing user flows from action logs).
• Your team values explicit architecture over ad-hoc mutation.

---

When Redux is probably too much

Weak signals (often better alternatives exist):

• State is owned by one screen or two siblings (lift state, colocate).
• Mostly server state (prefer TanStack Query / RTK Query / SWR patterns).
• You only need simple global theme/auth without complex transitions (Context + careful splitting may suffice).
• Team cannot maintain conventions (Redux without discipline becomes a junk drawer).

---

Why use state management libraries at all?

React excels at UI composition. As apps grow, you still need answers for:

• Where does this state live?
• Who may mutate it?
• How do we reproduce bugs involving state?

Libraries like Redux, Zustand, MobX, and Recoil provide patterns and guardrails for those questions—each with different ergonomics and trade-offs.

---

Redux in one diagram (mental)

User event
  → dispatch(action)
    → middleware (optional side effects / async)
      → reducer(previousState, action)
        → nextState
          → store notifies subscribers
            → React re-renders connected components

---

Interview framing (honest)

Redux is not “modern” because it is new—it is modern because it is boring, explicit, and teachable when adopted with Redux Toolkit defaults.

---

---

Appendix — Scenario bank (basic → advanced)

Use these as design-review flashcards: what breaks, why Redux helps or hurts, what you change, what you say in an interview.

RX0-001 — Redux introduction & library choice scenario #1

• Level: Beginner
• Symptom: inconsistent UI state across routes after 13 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-002 — Redux introduction & library choice scenario #2

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 26 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-003 — Redux introduction & library choice scenario #3

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 39 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-004 — Redux introduction & library choice scenario #4

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 52 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-005 — Redux introduction & library choice scenario #5

• Level: Advanced
• Symptom: inconsistent UI state across routes after 65 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-006 — Redux introduction & library choice scenario #6

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 78 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-007 — Redux introduction & library choice scenario #7

• Level: Beginner
• Symptom: inconsistent UI state across routes after 91 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-008 — Redux introduction & library choice scenario #8

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 104 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-009 — Redux introduction & library choice scenario #9

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 117 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-010 — Redux introduction & library choice scenario #10

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 130 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-011 — Redux introduction & library choice scenario #11

• Level: Advanced
• Symptom: inconsistent UI state across routes after 143 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-012 — Redux introduction & library choice scenario #12

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 156 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-013 — Redux introduction & library choice scenario #13

• Level: Beginner
• Symptom: inconsistent UI state across routes after 169 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-014 — Redux introduction & library choice scenario #14

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 182 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-015 — Redux introduction & library choice scenario #15

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 195 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-016 — Redux introduction & library choice scenario #16

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 8 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-017 — Redux introduction & library choice scenario #17

• Level: Advanced
• Symptom: inconsistent UI state across routes after 21 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-018 — Redux introduction & library choice scenario #18

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 34 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-019 — Redux introduction & library choice scenario #19

• Level: Beginner
• Symptom: inconsistent UI state across routes after 47 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-020 — Redux introduction & library choice scenario #20

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 60 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-021 — Redux introduction & library choice scenario #21

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 73 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-022 — Redux introduction & library choice scenario #22

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 86 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-023 — Redux introduction & library choice scenario #23

• Level: Advanced
• Symptom: inconsistent UI state across routes after 99 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-024 — Redux introduction & library choice scenario #24

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 112 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-025 — Redux introduction & library choice scenario #25

• Level: Beginner
• Symptom: inconsistent UI state across routes after 125 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-026 — Redux introduction & library choice scenario #26

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 138 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-027 — Redux introduction & library choice scenario #27

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 151 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-028 — Redux introduction & library choice scenario #28

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 164 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-029 — Redux introduction & library choice scenario #29

• Level: Advanced
• Symptom: inconsistent UI state across routes after 177 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-030 — Redux introduction & library choice scenario #30

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 190 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-031 — Redux introduction & library choice scenario #31

• Level: Beginner
• Symptom: inconsistent UI state across routes after 3 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-032 — Redux introduction & library choice scenario #32

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 16 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-033 — Redux introduction & library choice scenario #33

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 29 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-034 — Redux introduction & library choice scenario #34

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 42 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-035 — Redux introduction & library choice scenario #35

• Level: Advanced
• Symptom: inconsistent UI state across routes after 55 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-036 — Redux introduction & library choice scenario #36

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 68 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-037 — Redux introduction & library choice scenario #37

• Level: Beginner
• Symptom: inconsistent UI state across routes after 81 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-038 — Redux introduction & library choice scenario #38

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 94 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-039 — Redux introduction & library choice scenario #39

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 107 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-040 — Redux introduction & library choice scenario #40

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 120 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-041 — Redux introduction & library choice scenario #41

• Level: Advanced
• Symptom: inconsistent UI state across routes after 133 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-042 — Redux introduction & library choice scenario #42

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 146 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-043 — Redux introduction & library choice scenario #43

• Level: Beginner
• Symptom: inconsistent UI state across routes after 159 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-044 — Redux introduction & library choice scenario #44

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 172 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-045 — Redux introduction & library choice scenario #45

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 185 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-046 — Redux introduction & library choice scenario #46

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 198 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-047 — Redux introduction & library choice scenario #47

• Level: Advanced
• Symptom: inconsistent UI state across routes after 11 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-048 — Redux introduction & library choice scenario #48

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 24 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-049 — Redux introduction & library choice scenario #49

• Level: Beginner
• Symptom: inconsistent UI state across routes after 37 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-050 — Redux introduction & library choice scenario #50

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 50 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-051 — Redux introduction & library choice scenario #51

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 63 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-052 — Redux introduction & library choice scenario #52

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 76 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-053 — Redux introduction & library choice scenario #53

• Level: Advanced
• Symptom: inconsistent UI state across routes after 89 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-054 — Redux introduction & library choice scenario #54

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 102 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-055 — Redux introduction & library choice scenario #55

• Level: Beginner
• Symptom: inconsistent UI state across routes after 115 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-056 — Redux introduction & library choice scenario #56

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 128 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-057 — Redux introduction & library choice scenario #57

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 141 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-058 — Redux introduction & library choice scenario #58

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 154 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-059 — Redux introduction & library choice scenario #59

• Level: Advanced
• Symptom: inconsistent UI state across routes after 167 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-060 — Redux introduction & library choice scenario #60

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 180 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-061 — Redux introduction & library choice scenario #61

• Level: Beginner
• Symptom: inconsistent UI state across routes after 193 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-062 — Redux introduction & library choice scenario #62

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 6 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-063 — Redux introduction & library choice scenario #63

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 19 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-064 — Redux introduction & library choice scenario #64

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 32 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-065 — Redux introduction & library choice scenario #65

• Level: Advanced
• Symptom: inconsistent UI state across routes after 45 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-066 — Redux introduction & library choice scenario #66

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 58 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-067 — Redux introduction & library choice scenario #67

• Level: Beginner
• Symptom: inconsistent UI state across routes after 71 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-068 — Redux introduction & library choice scenario #68

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 84 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-069 — Redux introduction & library choice scenario #69

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 97 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-070 — Redux introduction & library choice scenario #70

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 110 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-071 — Redux introduction & library choice scenario #71

• Level: Advanced
• Symptom: inconsistent UI state across routes after 123 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-072 — Redux introduction & library choice scenario #72

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 136 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-073 — Redux introduction & library choice scenario #73

• Level: Beginner
• Symptom: inconsistent UI state across routes after 149 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-074 — Redux introduction & library choice scenario #74

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 162 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-075 — Redux introduction & library choice scenario #75

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 175 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-076 — Redux introduction & library choice scenario #76

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 188 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-077 — Redux introduction & library choice scenario #77

• Level: Advanced
• Symptom: inconsistent UI state across routes after 1 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-078 — Redux introduction & library choice scenario #78

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 14 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-079 — Redux introduction & library choice scenario #79

• Level: Beginner
• Symptom: inconsistent UI state across routes after 27 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-080 — Redux introduction & library choice scenario #80

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 40 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-081 — Redux introduction & library choice scenario #81

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 53 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-082 — Redux introduction & library choice scenario #82

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 66 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-083 — Redux introduction & library choice scenario #83

• Level: Advanced
• Symptom: inconsistent UI state across routes after 79 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-084 — Redux introduction & library choice scenario #84

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 92 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-085 — Redux introduction & library choice scenario #85

• Level: Beginner
• Symptom: inconsistent UI state across routes after 105 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-086 — Redux introduction & library choice scenario #86

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 118 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-087 — Redux introduction & library choice scenario #87

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 131 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-088 — Redux introduction & library choice scenario #88

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 144 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-089 — Redux introduction & library choice scenario #89

• Level: Advanced
• Symptom: inconsistent UI state across routes after 157 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-090 — Redux introduction & library choice scenario #90

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 170 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-091 — Redux introduction & library choice scenario #91

• Level: Beginner
• Symptom: inconsistent UI state across routes after 183 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-092 — Redux introduction & library choice scenario #92

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 196 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-093 — Redux introduction & library choice scenario #93

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 9 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-094 — Redux introduction & library choice scenario #94

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 22 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-095 — Redux introduction & library choice scenario #95

• Level: Advanced
• Symptom: inconsistent UI state across routes after 35 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-096 — Redux introduction & library choice scenario #96

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 48 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-097 — Redux introduction & library choice scenario #97

• Level: Beginner
• Symptom: inconsistent UI state across routes after 61 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-098 — Redux introduction & library choice scenario #98

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 74 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-099 — Redux introduction & library choice scenario #99

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 87 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-100 — Redux introduction & library choice scenario #100

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 100 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-101 — Redux introduction & library choice scenario #101

• Level: Advanced
• Symptom: inconsistent UI state across routes after 113 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-102 — Redux introduction & library choice scenario #102

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 126 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-103 — Redux introduction & library choice scenario #103

• Level: Beginner
• Symptom: inconsistent UI state across routes after 139 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-104 — Redux introduction & library choice scenario #104

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 152 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-105 — Redux introduction & library choice scenario #105

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 165 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-106 — Redux introduction & library choice scenario #106

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 178 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-107 — Redux introduction & library choice scenario #107

• Level: Advanced
• Symptom: inconsistent UI state across routes after 191 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-108 — Redux introduction & library choice scenario #108

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 4 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-109 — Redux introduction & library choice scenario #109

• Level: Beginner
• Symptom: inconsistent UI state across routes after 17 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-110 — Redux introduction & library choice scenario #110

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 30 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-111 — Redux introduction & library choice scenario #111

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 43 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-112 — Redux introduction & library choice scenario #112

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 56 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-113 — Redux introduction & library choice scenario #113

• Level: Advanced
• Symptom: inconsistent UI state across routes after 69 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-114 — Redux introduction & library choice scenario #114

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 82 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-115 — Redux introduction & library choice scenario #115

• Level: Beginner
• Symptom: inconsistent UI state across routes after 95 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-116 — Redux introduction & library choice scenario #116

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 108 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-117 — Redux introduction & library choice scenario #117

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 121 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-118 — Redux introduction & library choice scenario #118

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 134 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-119 — Redux introduction & library choice scenario #119

• Level: Advanced
• Symptom: inconsistent UI state across routes after 147 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-120 — Redux introduction & library choice scenario #120

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 160 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-121 — Redux introduction & library choice scenario #121

• Level: Beginner
• Symptom: inconsistent UI state across routes after 173 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-122 — Redux introduction & library choice scenario #122

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 186 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-123 — Redux introduction & library choice scenario #123

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 199 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-124 — Redux introduction & library choice scenario #124

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 12 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-125 — Redux introduction & library choice scenario #125

• Level: Advanced
• Symptom: inconsistent UI state across routes after 25 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-126 — Redux introduction & library choice scenario #126

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 38 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-127 — Redux introduction & library choice scenario #127

• Level: Beginner
• Symptom: inconsistent UI state across routes after 51 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-128 — Redux introduction & library choice scenario #128

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 64 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-129 — Redux introduction & library choice scenario #129

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 77 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-130 — Redux introduction & library choice scenario #130

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 90 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-131 — Redux introduction & library choice scenario #131

• Level: Advanced
• Symptom: inconsistent UI state across routes after 103 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-132 — Redux introduction & library choice scenario #132

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 116 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-133 — Redux introduction & library choice scenario #133

• Level: Beginner
• Symptom: inconsistent UI state across routes after 129 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-134 — Redux introduction & library choice scenario #134

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 142 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-135 — Redux introduction & library choice scenario #135

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 155 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-136 — Redux introduction & library choice scenario #136

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 168 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-137 — Redux introduction & library choice scenario #137

• Level: Advanced
• Symptom: inconsistent UI state across routes after 181 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-138 — Redux introduction & library choice scenario #138

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 194 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-139 — Redux introduction & library choice scenario #139

• Level: Beginner
• Symptom: inconsistent UI state across routes after 7 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-140 — Redux introduction & library choice scenario #140

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 20 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-141 — Redux introduction & library choice scenario #141

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 33 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-142 — Redux introduction & library choice scenario #142

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 46 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-143 — Redux introduction & library choice scenario #143

• Level: Advanced
• Symptom: inconsistent UI state across routes after 59 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-144 — Redux introduction & library choice scenario #144

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 72 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-145 — Redux introduction & library choice scenario #145

• Level: Beginner
• Symptom: inconsistent UI state across routes after 85 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-146 — Redux introduction & library choice scenario #146

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 98 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-147 — Redux introduction & library choice scenario #147

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 111 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-148 — Redux introduction & library choice scenario #148

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 124 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-149 — Redux introduction & library choice scenario #149

• Level: Advanced
• Symptom: inconsistent UI state across routes after 137 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-150 — Redux introduction & library choice scenario #150

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 150 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-151 — Redux introduction & library choice scenario #151

• Level: Beginner
• Symptom: inconsistent UI state across routes after 163 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-152 — Redux introduction & library choice scenario #152

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 176 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-153 — Redux introduction & library choice scenario #153

• Level: Intermediate
• Symptom: inconsistent UI state across routes after 189 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Context re-render storms because one mega-context value changes frequently.
• Primary remediation: Split contexts or use selector patterns; measure renders before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-154 — Redux introduction & library choice scenario #154

• Level: Intermediate+
• Symptom: inconsistent UI state across routes after 2 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Multiple sources of truth: URL, localStorage, and React state disagree after refresh.
• Primary remediation: Use local state + URL state + forms library first; expand only with evidence.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-155 — Redux introduction & library choice scenario #155

• Level: Advanced
• Symptom: inconsistent UI state across routes after 15 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Prop drilling through 12 layers for cross-feature flags and session-ish client state.
• Primary remediation: Add lint rules + ADR for store module boundaries and naming.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-156 — Redux introduction & library choice scenario #156

• Level: Advanced+
• Symptom: inconsistent UI state across routes after 28 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Global mutable singletons updated from random modules (no single update path).
• Primary remediation: Centralize client state updates behind explicit events; prefer reducer mindset even before Redux.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

RX0-157 — Redux introduction & library choice scenario #157

• Level: Beginner
• Symptom: inconsistent UI state across routes after 41 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Team lacks conventions; any pattern becomes 'Redux-ish' without real reducers.
• Primary remediation: Introduce colocated state or composition first; reserve global store for truly shared state.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: If only two siblings share state, lifting state beats a global store.

RX0-158 — Redux introduction & library choice scenario #158

• Level: Beginner+
• Symptom: inconsistent UI state across routes after 54 rapid user actions.
• Team symptom: impossible reproductions because state updates depend on hidden module globals.
• Root cause class: Adopting Redux for a form that only one screen uses (over-engineering).
• Primary remediation: Pick a single source of truth per concern; sync via explicit adapters.
• Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
• Interview one-liner: Redux shines when many distant components must agree on client state with strict update rules.

---

<< 2.14 Overview