Senior State Management Interview Questions (50 MCQs)

Question 1

How does normalizing state help?

Accepted Answer

Less duplication and simpler updates by entity id

Answer

Intentionally increasing duplication

Answer

Removing all ids

Answer

Images only

Question 2

How do selectors reduce re-renders?

Accepted Answer

The component subscribes only to the needed slice

Answer

It force-updates the whole store every time

Answer

It turns React off

Answer

CSS only

Question 3

For undo/redo we typically keep what?

Accepted Answer

past / present / future stacks of snapshots or commands

Answer

Only a boolean

Answer

No history

Answer

Only file names

Question 4

Main benefit of a state machine (e.g. XState)?

Accepted Answer

Explicit states/transitions eliminate impossible states

Answer

Zero bundle size

Answer

Replaces TypeScript

Answer

Removes the need for tests

Question 5

How do you sync state across browser tabs?

Accepted Answer

The `storage` event or `BroadcastChannel`

Answer

A shared `useState`

Answer

`sessionStorage`

Answer

A global variable

Question 6

In SSR, how is the client store initialized?

Accepted Answer

Initial state is serialized on the server and hydrated on the client

Answer

The client always starts empty

Answer

One store is shared by all users on the server

Answer

The whole store is read from a cookie

Question 7

Why memoize a selector returning `state.items.filter(...)`?

Accepted Answer

It creates a new array each time, causing needless re-renders

Answer

Because filter is banned in Redux

Answer

To reduce bundle size

Answer

It doesn't need memoizing

Question 8

What is the core idea of Signals (Solid, Preact, Angular)?

Accepted Answer

Fine-grained reactivity updating only direct dependents

Answer

Re-rendering the whole tree on every change

Answer

Removing state entirely

Answer

Only for server communication

Question 9

What does state colocation say?

Accepted Answer

Keep state as close as possible to where it's used

Answer

Put all state in a global store

Answer

Keep state in CSS

Answer

Copy state into every component

Question 10

What is "tearing" in concurrent rendering and how is it prevented?

Accepted Answer

Different parts of the UI show different values of an external store in one render; fixed with `useSyncExternalStore`

Answer

CSS breaking during animations; fixed with `will-change`

Answer

A Context memory leak; fixed with `useMemo`

Answer

An SSR hydration error; fixed with `suppressHydrationWarning`

Question 11

In the Next.js App Router, why can't a Server Component read a client-side store (Redux/Zustand)?

Accepted Answer

Server Components run on the server before the client and can't use hooks or Context

Answer

Because Redux isn't supported in Next.js

Answer

Because Server Components only render CSS

Answer

It can, as long as it imports the store

Question 12

What's the correct React Query prefetch pattern for SSR?

Accepted Answer

A new `QueryClient` per request, `prefetchQuery`, then `dehydrate` and `HydrationBoundary` on the client

Answer

One global `QueryClient` on the server for all users

Answer

Sending the whole server cache in a cookie

Answer

Disabling the server cache and refetching on the client

Question 13

With SSR prefetching and the default `staleTime` (0), what happens right after hydration?

Accepted Answer

Data is instantly stale and the client refetches it; set `staleTime` above zero

Answer

No fetch happens because data came from the server

Answer

The cache is cleared and the page stays empty

Answer

A hydration error is thrown

Question 14

In live search with `useEffect` + `fetch`, results for "re" sometimes arrive after "react" and overwrite them. Proper fix?

Accepted Answer

Abort the previous request with `AbortController` in cleanup, or ignore stale responses

Answer

Increase request timeouts

Answer

Store all responses in an array

Answer

Use `useLayoutEffect` instead of `useEffect`

Question 15

What's the main trade-off of a normalized cache (e.g. Apollo) vs a query-keyed cache (e.g. React Query)?

Accepted Answer

Normalized auto-updates every query when an entity changes but is more complex; query-keyed is simpler but needs manual invalidation

Answer

A normalized cache is always faster with no cost

Answer

A query-keyed cache can't retain data

Answer

There's no practical difference

Question 16

What does "structural sharing" do in React Query after a refetch?

Accepted Answer

It keeps references for unchanged parts of the data so memos and selectors don't rerun needlessly

Answer

It shares data across tabs

Answer

It shares the cache between users

Answer

It compresses responses to save memory

Question 17

A `createSelector` selector taking an `id` is used by 100 list items with different ids. With classic reselect memoization (cache size 1), what goes wrong?

Accepted Answer

Each call with a different `id` evicts the cache, making memoization useless

Answer

The selector only runs for the first item

Answer

Redux throws a circular dependency error

Answer

Nothing goes wrong

Question 18

How does the Redux style guide recommend modeling actions?

Accepted Answer

As events (`orderSubmitted`), not setters (`setOrderStatus`)

Answer

Always prefixed with `SET_`

Answer

Named after the dispatching component

Answer

With sequential numbers

Question 19

Two concurrent optimistic mutations run on one list and the first fails. What's wrong with a naive rollback to its snapshot?

Accepted Answer

The old snapshot also wipes out the second mutation's optimistic change

Answer

No problem; the snapshot is always correct

Answer

The second mutation automatically fails too

Answer

The server saves the data twice

Question 20

In an offline-first app, how are mutations made while offline handled?

Accepted Answer

Stored in a durable queue (e.g. IndexedDB), replayed in order when online, with conflict resolution

Answer

They're discarded

Answer

They're kept only in in-memory state

Answer

They're stored in cookies and sent with every request

Question 21

Why use CRDTs for multi-user concurrent editing (like Figma or Google Docs)?

Accepted Answer

Concurrent changes converge to the same state without central coordination

Answer

Because they reduce data size to zero

Answer

Because they remove the need for a network

Answer

Because they keep only the last change and discard the rest

Question 22

A frequently changing Context with hundreds of consumers is slow. Which fix is more fundamental?

Accepted Answer

Have Context pass only a stable store reference, with consumers subscribing via selectors through `useSyncExternalStore`

Answer

Wrapping every consumer in `React.memo`

Answer

Nesting more Providers with the same value

Answer

Using `useLayoutEffect` in the Provider

Question 23

A dashboard's data is fetched with React Query and updated via WebSocket. What's a good integration approach?

Accepted Answer

On each message, `setQueryData` or invalidate the related key, and raise `staleTime`

Answer

Keep messages in a separate `useState` and manually merge with query data

Answer

Also enable polling every 100ms

Answer

Drop WebSocket since it's incompatible with caching

Question 24

After every small mutation, `invalidateQueries()` is called with no filter. What's the consequence?

Accepted Answer

All active queries refetch at once, spiking network and server load

Answer

No query refetches

Answer

Only the mutation-related query refetches

Answer

The cache is permanently disabled

Question 25

What's the benefit of a "query key factory" (e.g. `todoKeys.detail(id)`) in a large codebase?

Accepted Answer

Keys are defined in one hierarchical place, preventing typos and incomplete invalidation

Answer

It makes requests faster

Answer

It removes the need for a queryFn

Answer

It persists the cache to localStorage

Question 26

When persisting with `persistQueryClient` and a 24h `maxAge`, why must `gcTime` also be at least 24h?

Accepted Answer

Otherwise unused queries get garbage-collected early and won't be persisted or restored

Answer

Because `gcTime` controls refetch frequency

Answer

Because data isn't encrypted otherwise

Answer

It isn't required and has no effect

Question 27

Security-wise, what's the risk of keeping an access token in `localStorage` or a persisted store?

Accepted Answer

Any XSS script can read it; an `HttpOnly`, `SameSite` cookie is out of JS reach

Answer

localStorage is cleared on every refresh

Answer

The browser sends the token to every domain

Answer

No risk, since localStorage is encrypted

Question 28

Filters live in both Zustand and the URL, kept in sync by two bidirectional effects. What's the core problem?

Accepted Answer

Two sources of truth, risking update loops and drift on back/forward; derive filters from the URL only

Answer

Zustand can't hold strings

Answer

URLs have no length limit

Answer

No problem; it's the recommended pattern

Question 29

In the Next.js App Router, what's the effect of `useSearchParams` in a Client Component on a statically rendered page?

Accepted Answer

The tree up to the nearest `Suspense` boundary is client-rendered only; wrap it in `Suspense`

Answer

The entire app switches to dynamic server rendering

Answer

`useSearchParams` always returns `null`

Answer

It has no effect

Question 30

What problem of flat state machines do statecharts (nested and parallel states) solve?

Accepted Answer

State explosion when several independent dimensions combine

Answer

They remove the need for JavaScript

Answer

They make the machine non-deterministic

Answer

They eliminate transitions

Question 31

In XState v5, what does the actor model enable?

Accepted Answer

Spawning independent actors with their own state that communicate only via events

Answer

Directly sharing mutable state between machines

Answer

Running machines only on the server

Answer

Removing the need for events

Question 32

In a micro-frontend architecture, how is state best shared between independent apps?

Accepted Answer

Through minimal contracts like custom events, the URL, or a messaging API, not a shared store

Answer

All apps import one shared Redux store directly

Answer

Read data from another app's DOM

Answer

Put all state in global `window` variables

Question 33

In an infinite feed where users scroll thousands of items, `useInfiniteQuery` refetches got slow. Cause and fix?

Accepted Answer

Refetch re-fetches every page sequentially; `maxPages` plus virtualization caps pages and DOM size

Answer

Set `staleTime` to zero

Answer

Keep each page in a separate `useState`

Answer

Remove `getNextPageParam`

Question 34

How does updating an external store (Redux/Zustand) inside `startTransition` behave?

Accepted Answer

React won't make it non-blocking; `useSyncExternalStore` updates render synchronously (blocking)

Answer

It's interruptible and prioritized like internal React state

Answer

The update is ignored entirely

Answer

The store automatically turns into Context

Question 35

In React 19, when does an optimistic value from `useOptimistic` revert to the real value?

Accepted Answer

When the pending action/transition finishes; then the real state passed to the hook is shown

Answer

Only when you manually call `revert()`

Answer

After a page refresh

Answer

Never; the optimistic value is permanent

Question 36

In Next.js with Server Actions, how is the posts list refreshed after saving a post without a client-side cache?

Accepted Answer

Call `revalidatePath` or `revalidateTag` in the action to refresh server data and the RSC payload

Answer

Manually copying the post into localStorage

Answer

Calling `window.location.reload()` on the server

Answer

It's impossible without React Query

Question 37

In Valtio, what's the correct rule for reading and writing state?

Accepted Answer

Read from `useSnapshot(state)` in render and mutate the proxy itself in handlers

Answer

Mutate the snapshot to update the UI

Answer

Read the proxy directly in render for tracking

Answer

Use `setState` like React

Question 38

What's the cost of an immutable update to a field at `state.a.b.c` with structural sharing?

Accepted Answer

Only objects along the path from root to that field are copied; the rest keep their references

Answer

The whole state tree is deep-cloned

Answer

No new objects are created

Answer

All arrays in state are rebuilt

Question 39

In a Redux app with 500 connected components, why are heavy selectors (like unmemoized sort) slow even without re-renders?

Accepted Answer

Every subscribed selector runs after every dispatch to check for changes

Answer

Selectors run only once on mount

Answer

Redux runs selectors on the server

Answer

Selectors only run when the parent renders

Question 40

In a normalized store, how are paginated results for different filters kept?

Accepted Answer

Entities once in `entities`, plus an ordered id list per query/page

Answer

A full copy of the objects per filter

Answer

Only the last page is kept, others are deleted

Answer

All entities in one array without ids

Question 41

What's the bug in `useEffect(() => { const id = setInterval(() => setCount(count + 1), 1000); return () => clearInterval(id); }, [])`?

Accepted Answer

The closure captures the initial `count`, so it sticks at 1; use `setCount(c => c + 1)`

Answer

The interval is never cleared

Answer

`setInterval` isn't allowed in effects

Answer

The counter increments twice as fast

Question 42

On logout without a page reload, what's needed so the next user doesn't see the previous user's data?

Accepted Answer

Reset all stores, call `queryClient.clear()`, and clear persisted storage

Answer

Removing the token alone is enough

Answer

Only redirecting to the login page

Answer

Raising `staleTime` on all queries

Question 43

Tests pass individually but fail together. With a module-level global store, what's the likely cause?

Accepted Answer

State leaks between tests; create a fresh store per test or reset it

Answer

Jest runs tests on the server

Answer

Stores don't work in test environments

Answer

All tests must be in one file

Question 44

Why is dispatching every keystroke of a large form to Redux usually an anti-pattern?

Accepted Answer

Each character runs every selector and middleware, though the state is transient and local

Answer

Redux can't store strings

Answer

Because controlled inputs are impossible with Redux

Answer

Because DevTools only keeps 10 actions

Question 45

The backend uses read replicas with eventual consistency; after a mutation, the invalidation refetch sometimes returns stale data. A good client-side fix?

Accepted Answer

Write the mutation response into the cache with `setQueryData` and delay or condition the invalidation

Answer

Remove the cache and fetch on every render

Answer

Increase `retry` to 10

Answer

Ignore the mutation response

Question 46

When optimistically creating an item, why use a temporary client ID (e.g. a UUID), and what's the catch?

Accepted Answer

For render keys and references before the server responds; it must later be swapped for the server ID and references updated

Answer

Because the server never returns IDs

Answer

To encrypt the item

Answer

There's no catch; the temp ID is permanent

Question 47

A team fetches with React Query and copies the data into Redux in `onSuccess`. What's the core problem?

Accepted Answer

Two sources of truth; refetches and invalidation update only the cache, leaving Redux stale

Answer

React Query can't hand data to Redux

Answer

Redux rejects server data

Answer

Nothing; it's recommended

Question 48

A parent fetches `user`, and only after it arrives does a child render and fetch `posts`. What's the problem?

Accepted Answer

A request waterfall; independent requests should run in parallel or be prefetched at the route/loader level

Answer

No problem since requests are cached

Answer

It causes a memory leak

Answer

React disallows fetching in children

Question 49

Why is `createSelector([s => s.items.map(i => i.id)], ids => ...)` ineffectively memoized?

Accepted Answer

The input selector returns a new array every time, so the result function always reruns

Answer

Because `createSelector` only works with strings

Answer

Because the result function can't take arrays

Answer

It's memoized perfectly

Question 50

Two users edit the same record and the second save silently overwrites the first. Standard fix?

Accepted Answer

Optimistic concurrency control: send a version/ETag with `If-Match` and reject with 412 if it changed

Answer

Locking the entire database when the form opens

Answer

Auto-saving every 10ms

Answer

Silently accepting last-write-wins

State Management · Senior · 50

How does normalizing state help?