Redux interview questions and answers

Redux is the library everyone on Twitter declares "basically dead" — right up until the interviewer shares a screen and asks why reducers must be pure. It's a predictable state container for JavaScript apps, most commonly paired with React, and its interviews test the core principles — a single store, actions, pure reducers, and one-way data flow — plus the judgment of when you actually need it. Here are the Redux interview questions that actually get asked, with answers you can say out loud. (See also our React guide.)

Core Redux interview questions

What is Redux, and what problem does it solve?

Redux is a predictable state container: one central store holds shared application state, and the only way to change it is to dispatch an action that a pure reducer turns into new state. It solves two problems that grow with app size — prop drilling (threading data through components that don't use it) and unpredictable updates (many components mutating shared state in different ways). The trade-off is ceremony, which is why the follow-up is always "and when would you not use it?"

What are the three principles of Redux?

Single source of truth — the whole app state lives in one store. State is read-only — the only way to change it is dispatching an action, an object describing what happened. Changes are made with pure functions — reducers take previous state and an action and return the next state without mutating anything.

What are the store, an action, and a reducer?

The store holds state and exposes getState, dispatch, and subscribe. An action is a plain object with a type and optional payload. A reducer is a pure function (state, action) => newState. Interviewers want the sentence-level clarity, then a concrete example:

// A pure reducer: same input, same output — and no mutation
function cartReducer(state = { items: [] }, action) {
  switch (action.type) {
    case 'cart/itemAdded':
      return { ...state, items: [...state.items, action.payload] };
    case 'cart/cleared':
      return { ...state, items: [] };
    default:
      return state;
  }
}

Why must reducers be pure functions?

Purity (no side effects, no mutation, same output for the same input) is what makes Redux predictable: updates can be replayed, tested, and time-travel-debugged, and change detection works by cheap reference equality — if the reducer returned a new object, something changed. Mutate state in a reducer and connected components silently stop re-rendering; that bug is a favourite interview follow-up.

Data flow & middleware questions

Explain the one-way data flow

View dispatches an action → middleware (if any) intercepts → the reducer computes new state → the store saves it and notifies subscribers → the view re-renders from the new state. One direction, no shortcuts — say it as a loop and you've answered half the round.

What is middleware, and Thunk vs Saga?

Middleware sits between dispatch and the reducer — the extension point for logging, crash reporting, and async work. Redux Thunk lets you dispatch functions instead of objects: simple, minimal API, right default for most apps (and built into Redux Toolkit). Redux Saga uses generator functions to model complex, long-running flows — debouncing, cancellation, race conditions. The experienced answer: Thunk until the async logic itself becomes the complexity, then consider Saga (or RTK Query for data fetching, which removes most of that code entirely).

React Redux interview questions (hooks and connect)

The react redux interview questions layer sits on top: how components talk to the store. useSelector reads a slice of state and re-renders the component when that slice changes by reference; useDispatch returns the dispatch function; the older connect(mapStateToProps, mapDispatchToProps) HOC does both for class components. The detail that separates candidates: selector narrowness. Select the smallest value you need, or every unrelated state change re-renders your component.

import { useSelector, useDispatch } from 'react-redux';

function CartBadge() {
  // Select the smallest slice you need — narrow selectors avoid re-renders
  const count = useSelector(state => state.cart.items.length);
  const dispatch = useDispatch();
  return <button onClick={() => dispatch({ type: 'cart/cleared' })}>{count}</button>;
}

Redux Toolkit interview questions

Redux Toolkit (RTK) is the official, standard way to write Redux in 2026, and interviewers expect you to know why: configureStore wires the store with good defaults (DevTools, Thunk, immutability checks), createSlice generates action creators and types from your reducers, and Immer underneath lets you write "mutating" syntax that actually produces immutable updates. RTK Query adds data fetching and caching on top.

import { createSlice } from '@reduxjs/toolkit';

const cartSlice = createSlice({
  name: 'cart',
  initialState: { items: [] },
  reducers: {
    itemAdded(state, action) {
      // Immer lets you "mutate" — it produces an immutable update underneath
      state.items.push(action.payload);
    },
  },
});

export const { itemAdded } = cartSlice.actions;
export default cartSlice.reducer;

Advanced Redux interview questions for experienced developers

Senior rounds move past definitions into advanced react redux interview questions — architecture and judgment:

• Normalizing state: store entities as { ids, entities } maps (RTK's createEntityAdapter) instead of nested arrays — O(1) lookups, no duplicated objects to drift out of sync.
• Memoized selectors: reselect's createSelector caches derived data so an unchanged input skips recomputation and preserves reference equality for useSelector.
• Redux vs Context API: Context is dependency injection for infrequently changing values (theme, locale, current user); Redux is for complex, frequently updated shared state with middleware, DevTools, and predictable updates. Saying "Context replaces Redux" without the frequency caveat is the classic mid-level tell.
• Redux vs Zustand/Jotai: know the honest answer — smaller apps increasingly pick lighter stores; Redux earns its ceremony in large teams that need conventions, middleware, and tooling.
• Debugging: time-travel with Redux DevTools works because reducers are pure — connect the advanced answer back to the fundamentals and you sound like you've operated this in production.

How to prepare

Reading a GeeksforGeeks-style dump of 100 Redux questions feels productive, but Redux rounds are spoken: the interviewer asks why reducers are pure, then follows up on whatever you say. Practise explaining the action-reducer-store cycle out loud. Greenroom runs spoken technical interviews that follow up on your reasoning — and if you're targeting a specific company, the Razorpay frontend interview prep and Flipkart frontend interview prep pages cover how state-management questions show up in those loops. Pair this guide with our React and JavaScript guides.

Frequently asked questions

What are the most common Redux interview questions?

Common Redux questions cover what Redux is and the problem it solves, the three principles, the store/action/reducer concepts, why reducers must be pure, dispatch, the one-way data flow, middleware (Thunk, Saga) and async actions, useSelector and useDispatch, Redux Toolkit, Redux vs Context API, immutability, and memoized selectors.

What are actions and reducers in Redux?

An action is a plain JavaScript object describing what happened, with a type field and optional payload. A reducer is a pure function that takes the current state and an action and returns the new state, without mutating the original. You dispatch actions to the store, the reducer computes the next state, and subscribed views re-render — the heart of Redux's predictable data flow.

When should you use Redux vs the Context API?

Use the Context API for relatively simple or infrequently changing shared state like theme, locale or the current user. Reach for Redux when you have complex, frequently updated global state shared across many components, need predictable updates, time-travel debugging, middleware for async logic, or memoized selectors. With Redux Toolkit reducing boilerplate, Redux is most justified for large applications with substantial shared state.

How should I prepare for a Redux interview?

Focus on the one-way data flow (action to reducer to store to view), why reducers must be pure, how middleware handles async, and the judgment of when Redux is actually needed versus Context. Practise explaining the action-reducer-store cycle out loud with a voice-based mock interview that follows up, since these rounds probe understanding and architectural judgment.

What are advanced Redux interview questions for experienced developers?

Senior rounds cover normalizing state with createEntityAdapter, memoized selectors with reselect, when Context genuinely replaces Redux and when it does not, Redux versus lighter stores like Zustand, middleware order, and why time-travel debugging depends on reducer purity. They test architectural judgment, not definitions.

Is Redux still asked in interviews in 2026?

Yes. Even teams migrating to lighter state libraries maintain large Redux codebases, and Redux Toolkit is the standard in most established React products — so interviews still probe the store/action/reducer model, Redux Toolkit, and the judgment of when Redux is worth its ceremony.