Episode 2 — React Frontend Architecture NextJS / 2.14 — State Management Using Redux

2.14.b — Redux principles, unidirectional data flow, and pure reducers

<< 2.14 Overview

Learning outcomes

State the three principles of Redux and what each buys you.
Trace Redux flow from UI event to updated UI.
Explain why reducers must be pure functions with concrete failure examples.

The three principles (classic Redux)

Single source of truth: one store tree holds application state.
State is read-only: you never mutate state directly; you dispatch actions.
Changes are made with pure functions: reducers compute the next tree.

Unidirectional data flow

Unlike ad-hoc “any module can tweak globals,” Redux forces updates through a narrow door:

UI (or middleware) dispatches actions.
Reducers compute new state deterministically.

This makes reasoning linear: given (state, action) you can compute nextState.

Why reducers must be pure functions

A pure function:

Given the same inputs, returns the same output.
Causes no observable side effects (no API calls, no Date.now() dependence for core logic, no mutations).

If reducers are impure, you lose:

Time-travel debugging (replaying actions yields different results).
Predictable tests (flaky reducer behavior).
Concurrent rendering safety assumptions in React integrations.

Example of an illegal reducer side effect

// BAD: network I/O inside reducer (never do this)
function reducer(state, action) {
  if (action.type === "SAVE") {
    fetch("/api/save", { method: "POST", body: JSON.stringify(state) }); // side effect
  }
  return state;
}

Put IO in middleware, thunks, RTK listener middleware, or UI event handlers—not reducers.

Purity still allows local mutation if you return new root references

With Immer (used inside RTK reducers), you write “mutating” code that is translated into immutable updates safely—within the supported Immer context. The mental rule remains: do not sneak real side effects into reducer bodies.

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.

RX1-001 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-002 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-003 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-004 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-005 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-006 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-007 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-008 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-009 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-010 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-011 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-012 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-013 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-014 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-015 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-016 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-017 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-018 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-019 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-020 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-021 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-022 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-023 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-024 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-025 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-026 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-027 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-028 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-029 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-030 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-031 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-032 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-033 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-034 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-035 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-036 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-037 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-038 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-039 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-040 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-041 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-042 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-043 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-044 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-045 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-046 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-047 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-048 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-049 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-050 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-051 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-052 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-053 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-054 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-055 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-056 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-057 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-058 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-059 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-060 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-061 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-062 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-063 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-064 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-065 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-066 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-067 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-068 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-069 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-070 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-071 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-072 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-073 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-074 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-075 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-076 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-077 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-078 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-079 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-080 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-081 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-082 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-083 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-084 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-085 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-086 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-087 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-088 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-089 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-090 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-091 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-092 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-093 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-094 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-095 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-096 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-097 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-098 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-099 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-100 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-101 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-102 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-103 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-104 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-105 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-106 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-107 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-108 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-109 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-110 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-111 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-112 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-113 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-114 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-115 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-116 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-117 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-118 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-119 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-120 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-121 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-122 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-123 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-124 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-125 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-126 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-127 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-128 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-129 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-130 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-131 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-132 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-133 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-134 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-135 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-136 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-137 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-138 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-139 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-140 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-141 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-142 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-143 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-144 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-145 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-146 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-147 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-148 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-149 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-150 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-151 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-152 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-153 — Principles & purity 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: Derived state stored redundantly drifting from source fields.
Primary remediation: Compute derived data in selectors (memoized) or in view layer when cheap.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-154 — Principles & purity 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: Side effects inside reducers causing network calls during replay.
Primary remediation: Use combineReducers patterns or RTK slices that return full slice state intentionally.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-155 — Principles & purity 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: Dispatching non-plain objects (non-serializable) breaking devtools and debugging.
Primary remediation: Use constants or RTK createSlice action creators to eliminate string typos.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-156 — Principles & purity 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: Reducer mutates state in place breaking time-travel and React change detection assumptions.
Primary remediation: Return new references; treat state as immutable snapshots.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

RX1-157 — Principles & purity 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: Action types as loose strings causing typo collisions.
Primary remediation: Keep actions serializable; move IO to middleware/thunks/listeners.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Redux flow is a contract: actions describe facts, reducers compute next state.

RX1-158 — Principles & purity 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: Reducer returns partial state accidentally merging undefined keys.
Primary remediation: Move async to thunk/listener/RTK async thunk; keep reducer pure.
Measurement / proof: time-travel debug log of actions; reproduce with minimal route flow.
Interview one-liner: Pure reducers make updates predictable and replayable; impurity hides bugs behind order.

<< 2.14 Overview