Middle State Management Interview Questions (50 MCQs)

Question 1

Why did Zustand become popular?

Accepted Answer

Minimal API, selectors, little boilerplate

Answer

Requiring a complex Provider

Answer

Removing React entirely

Answer

Vue only

Question 2

What did Redux Toolkit simplify?

Accepted Answer

Building slices/stores and async with less boilerplate

Answer

Removing state entirely

Answer

Mandating class components

Answer

Styling only

Question 3

Where is server state usually better managed?

Accepted Answer

Libraries like React Query / SWR / RTK Query

Answer

Only in one `useState` with no cache

Answer

Only CSS variables

Answer

It should never be cached

Question 4

Which is NOT allowed inside a reducer?

Accepted Answer

Calling an API or `Math.random()`

Answer

Returning a new object

Answer

Reading `action.payload`

Answer

Switching on `action.type`

Question 5

What role does Redux middleware play?

Accepted Answer

Intercepts actions between dispatch and reducer for async, logging, etc.

Answer

Rendering components

Answer

Defining routes

Answer

Styling

Question 6

What is an optimistic update?

Accepted Answer

Update the UI before the server confirms, roll back on error

Answer

Update only after page refresh

Answer

Ignoring server errors

Answer

Permanent caching

Question 7

What does Immer do?

Accepted Answer

You write mutable-style code and get immutable results

Answer

Stores state on the server

Answer

Compiles React faster

Answer

Types actions

Question 8

What characterizes the atom model in Jotai/Recoil?

Accepted Answer

Small state units that re-render only their own consumers

Answer

A mandatory single big store

Answer

Only for server state

Answer

No derived values possible

Question 9

What is stale-while-revalidate?

Accepted Answer

Show cached data immediately and refetch in the background

Answer

Always wait for fresh data

Answer

Never refetch

Answer

Clear cache every render

Question 10

A Provider uses `<Ctx.Provider value={{ user, setUser }}>` and consumers keep re-rendering even when `user` is unchanged. Why?

Accepted Answer

A new object is created on every parent render; stabilize it with `useMemo`

Answer

Because `setUser` changes every render and can't be stabilized

Answer

Because Context re-renders consumers every second

Answer

Because you must wrap `user` in `useCallback`

Question 11

In the `useReducer` + Context pattern, why put `state` and `dispatch` in separate Contexts?

Accepted Answer

`dispatch` is stable, so dispatch-only components don't re-render on state changes

Answer

Because a Context can't hold functions

Answer

Because `dispatch` only works in a second Context

Answer

So state is automatically persisted

Question 12

Which actions does `createAsyncThunk("users/fetch", ...)` dispatch automatically?

Accepted Answer

`users/fetch/pending`, `users/fetch/fulfilled`, and `users/fetch/rejected`

Answer

`users/fetch/start` and `users/fetch/end`

Answer

Only `users/fetch` after the request completes

Answer

`users/fetch/loading` and `users/fetch/error`

Question 13

What is `extraReducers` in `createSlice` for?

Accepted Answer

Responding to actions defined outside this slice (e.g. thunks)

Answer

Defining new action creators for the slice

Answer

Adding middleware to the store

Answer

Persisting the slice

Question 14

What does `createEntityAdapter` in RTK provide?

Accepted Answer

A normalized `ids`/`entities` shape plus ready CRUD reducers and selectors

Answer

Automatic REST API connection

Answer

An ORM for the server database

Answer

Form generation from a schema

Question 15

In RTK Query, what do `providesTags` and `invalidatesTags` do?

Accepted Answer

Queries get tagged, and a mutation invalidating a tag triggers their automatic refetch

Answer

They categorize endpoints for documentation

Answer

They set HTTP headers

Answer

They decide which components render

Question 16

What's wrong with `useSelector(s => ({ a: s.a, b: s.b }))`?

Accepted Answer

It returns a new object each time, so the component re-renders on every dispatch

Answer

`useSelector` can't return objects

Answer

It mutates the state

Answer

Nothing is wrong

Question 17

In Zustand v5, how do you select multiple fields like `s => ({ a: s.a, b: s.b })` without extra re-renders?

Accepted Answer

Wrap the selector with `useShallow`

Answer

Use `JSON.stringify` on the result

Answer

Split the store into two stores

Answer

Wrap the whole store in `useMemo`

Question 18

In Zustand's `persist` middleware, what does `partialize` do?

Accepted Answer

Chooses which parts of state get persisted

Answer

Splits state across tabs

Answer

Splits the store into slices

Answer

Enables encryption of stored data

Question 19

How do you read or update Zustand state outside components (e.g. in an interceptor)?

Accepted Answer

With `useStore.getState()` and `useStore.setState()`

Answer

Only by calling `useStore()` in that function

Answer

It's not possible

Answer

By creating a new Provider

Question 20

In Zustand, when does a component using `const { inc } = useStore()` re-render?

Accepted Answer

On any store change, even though `inc` never changes

Answer

Only when `inc` changes

Answer

Never

Answer

Only on initial mount

Question 21

What is `const doubled = atom((get) => get(countAtom) * 2)` in Jotai?

Accepted Answer

A read-only derived atom recomputed when `countAtom` changes

Answer

A writable atom whose initial value is a function

Answer

An effect that runs every render

Answer

An independent copy of `countAtom`

Question 22

In Jotai, what do you use to persist an atom to localStorage?

Accepted Answer

`atomWithStorage` from `jotai/utils`

Answer

`atom.persist()`

Answer

`useAtom(atom, { save: true })`

Answer

Jotai persists all atoms by default

Question 23

What's the difference between `staleTime` and `gcTime` in React Query?

Accepted Answer

`staleTime` sets how long data is fresh; `gcTime` sets how long unused cache stays in memory

Answer

They do the same thing with different names

Answer

`gcTime` sets the polling interval

Answer

`staleTime` is the HTTP request timeout

Question 24

After a successful add-todo mutation, what's the most common way to refresh the list?

Accepted Answer

`queryClient.invalidateQueries({ queryKey: ["todos"] })` in `onSuccess`

Answer

Reloading the whole page

Answer

Creating a new `QueryClient`

Answer

Setting `gcTime` to infinity

Question 25

Why must variables like `page` and `filter` be part of the `queryKey`?

Accepted Answer

So each combination has its own cache entry and changes trigger a new fetch

Answer

Because the queryFn can't access them otherwise

Answer

So the request is sent faster

Answer

Only for display in DevTools

Question 26

How do you make a dependent query (e.g. fetch projects only after `userId` is known)?

Accepted Answer

Set `enabled: !!userId`

Answer

Call `useQuery` inside an `if`

Answer

Use `setTimeout` to delay it

Answer

Call the second query inside `useEffect`

Question 27

In React Query v5 pagination, how do you avoid a blank loading state when moving to the next page?

Accepted Answer

`placeholderData: keepPreviousData` so the previous page shows until new data arrives

Answer

`staleTime: 0`

Answer

`refetchOnWindowFocus: true`

Answer

`gcTime: 0`

Question 28

In `useInfiniteQuery`, what does `getNextPageParam` do?

Accepted Answer

Derives the next page param from the last page, or returns `undefined` to signal the end

Answer

Fetches the total page count from the server

Answer

Removes the previous page from cache

Answer

Reverses the page order

Question 29

When the server returns the full updated object from a mutation, what's a good approach?

Accepted Answer

Write the response directly into the cache with `queryClient.setQueryData`

Answer

Clear the whole cache with `queryClient.clear()`

Answer

Ignore it and reload the page

Answer

Copy it into a separate `useState`

Question 30

In a React Query optimistic update, why call `cancelQueries` first in `onMutate`?

Accepted Answer

So an in-flight refetch doesn't overwrite the optimistic data with stale data

Answer

So the mutation reaches the server faster

Answer

Because `setQueryData` doesn't work without it

Answer

To clear the cache completely

Question 31

What's the difference between `isLoading` and `isFetching` in React Query?

Accepted Answer

`isLoading` is true only for the first fetch with no data; `isFetching` for any fetch including background refetches

Answer

They're exactly the same

Answer

`isFetching` is only for mutations

Answer

`isLoading` becomes true on every refetch

Question 32

What's the benefit of the `select` option in `useQuery`?

Accepted Answer

It transforms data, and the component re-renders only when the selected result changes

Answer

It filters data on the server

Answer

It picks which endpoint to call

Answer

It changes the cache for all components

Question 33

What is React Query's default behavior when a query fails on the client?

Accepted Answer

It retries 3 times with exponential backoff, then exposes the error

Answer

It shows the error immediately

Answer

It retries forever

Answer

It reloads the page

Question 34

In SWR, what does `mutate("/api/user")` without data do?

Accepted Answer

Revalidates that key's cache and refetches the data

Answer

Permanently deletes that key's cache

Answer

Sends a POST request to that URL

Answer

Throws because data is required

Question 35

If ten components call `useSWR("/api/me")` at the same time, how many requests are sent?

Accepted Answer

One; SWR dedupes same-key requests within `dedupingInterval`

Answer

Ten requests

Answer

None until the page refreshes

Answer

Five requests

Question 36

What scenario is RTK's `createListenerMiddleware` suited for?

Accepted Answer

Running side effects in response to specific actions or state changes

Answer

Defining new reducers

Answer

Server-rendering components

Answer

Creating memoized selectors

Question 37

In redux-saga, what does `takeLatest` do?

Accepted Answer

On each new action it cancels the running task and only runs the latest

Answer

Runs all actions in parallel

Answer

Runs only the first action and ignores the rest

Answer

Queues actions and runs them one by one

Question 38

In a `createSlice` case reducer, which causes an error?

Accepted Answer

Both mutating the draft and returning a new object

Answer

Only mutating the draft

Answer

Only returning a new state

Answer

Reading `action.payload`

Question 39

In React Hook Form, when do you use `Controller` instead of `register`?

Accepted Answer

For controlled UI-library components that don't expose a native input ref

Answer

For all plain text inputs

Answer

Only for submitting the form to the server

Answer

To disable validation

Question 40

What's the benefit of using a schema (e.g. Zod) with `zodResolver` in forms?

Accepted Answer

Validation rules live in one place and the form's TypeScript type is inferred from it

Answer

Server-side validation is no longer needed

Answer

The form works without JavaScript

Answer

Form data is auto-saved to localStorage

Question 41

When syncing a search input to the query string on every keystroke, why is `router.replace` better than `router.push`?

Accepted Answer

So browser history isn't flooded with one entry per character

Answer

Because `push` doesn't work with query strings

Answer

Because `replace` never hits the server while `push` always does

Answer

Because `replace` saves state to localStorage

Question 42

What is `useSyncExternalStore` designed for?

Accepted Answer

Safely subscribing to stores outside React under concurrent rendering

Answer

Syncing state between server and database

Answer

Running effects before paint

Answer

Creating faster Contexts

Question 43

What's a common pattern for managing a large Zustand store?

Accepted Answer

The slices pattern: each part is a `(set, get) => ({...})` creator combined into one store

Answer

Copying the whole store into each component

Answer

A separate Context per field

Answer

Putting all logic into a single `set` call

Question 44

In Next.js, a store persisted to localStorage causes a hydration mismatch. Why?

Accepted Answer

The server renders the default while the client's first render reads the stored value

Answer

Because localStorage has a different value on the server

Answer

Because JSON.parse doesn't work on the server

Answer

Because Next.js bans all stores

Question 45

When the shape of persisted state changes, what breaks for existing users and what's the fix?

Accepted Answer

Old data is incompatible with new code; define a `version` and a `migrate` function

Answer

Nothing breaks; storage updates itself

Answer

The browser clears old data automatically

Answer

Ask users to reinstall their browser

Question 46

In MobX, how does an `observer`-wrapped component know when to re-render?

Accepted Answer

It automatically tracks the observables it read during render

Answer

You must define a manual dependency array

Answer

It re-renders once per second

Answer

It re-renders on any change to any observable

Question 47

In React 18+, how many renders do several `setState` calls inside a `setTimeout` or after `await` cause?

Accepted Answer

One render; automatic batching applies everywhere

Answer

One render per call

Answer

No renders

Answer

Always exactly two renders

Question 48

Why shouldn't `const queryClient = new QueryClient()` be written directly in a component body?

Accepted Answer

Every render creates a new client with an empty cache

Answer

Because `QueryClient` only works on the server

Answer

Because it must be defined in a `.env` file

Answer

Because each app may only have one query

Question 49

In RTK Query, how do you pause `useGetUserQuery(id)` until `id` exists?

Accepted Answer

Pass `skipToken` as the argument or use `{ skip: !id }`

Answer

Call the hook inside an `if (id)`

Answer

Pass `undefined`, which auto-skips

Answer

Remove the endpoint from the API

Question 50

In Jotai, what effect does wrapping part of the tree in a separate `<Provider>` have?

Accepted Answer

That subtree gets its own store, isolating atom values from the outside

Answer

Atoms become read-only in that subtree

Answer

All atoms are persisted to localStorage

Answer

No effect, since Jotai is always global

State Management · Middle · 50

Why did Zustand become popular?