Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
Slack · Redux
Practice Redux questions specifically asked in Slack interviews – ideal for online test preparation, technical rounds and final HR discussions.
Questions
18
Tagged for this company + subject
Company
Slack
View company-wise questions
Subject
Redux
Explore topic-wise practice
Go through each question and its explanation. Use this page for targeted revision just before your Slack Redux round.
State immutability ensures that we never modify the existing state directly but always create new state objects, which enables features like time-travel debugging and proper change detection. Immutability makes state changes predictable, helps React optimize rendering through shallow comparison, and prevents hard-to-track bugs caused by unintended mutations.
For complete preparation, combine this company + subject page with full company-wise practice and subject-wise practice. You can also explore other companies and topics from the links below.
Reducer composition is the pattern of breaking down a large reducer into smaller, focused reducers that each manage their own slice of state independently, making the code more maintainable and testable. The combineReducers function from Redux takes an object where keys are state slice names and values are reducer functions, and creates a root reducer that calls each slice reducer with its portion of state and returns a combined state object. This allows you to organize your reducers by feature or domain while Redux handles calling them appropriately and assembling the final state.
RTK automatically configures Redux DevTools Extension without any setup, providing time-travel debugging, action history inspection, and state diff viewing out of the box. The DevTools integration shows clean, readable action types generated by createSlice like userSlice/login instead of constants, makes it easy to track when and why state changed, and allows you to replay actions or jump to specific states for debugging. The automatic setup means developers can start debugging immediately without configuration, and the clearer action naming makes the debugging process more intuitive.
fetchBaseQuery is RTK Query's recommended lightweight wrapper around the native fetch API that handles common tasks like setting base URLs, adding headers, handling request/response transformations, and parsing responses. It supports features like automatic JSON parsing, adding authentication tokens via prepareHeaders, custom response handlers, and timeout configuration. While fetchBaseQuery covers most use cases, you can also create custom baseQuery functions using axios or other HTTP clients if needed.
Mutation hooks like useCreatePostMutation return a tuple with a trigger function as the first element and a result object as the second, unlike query hooks that automatically fetch on mount. You call the trigger function manually when needed like onClick handlers passing the mutation argument, and the trigger returns a promise allowing you to await the result or use then and catch. The result object provides the same isLoading, isSuccess, isError, data, and error properties as query hooks, plus a reset function to clear the mutation state, but mutations don't cache results by default and must be explicitly triggered rather than running automatically.
Normalized state structure stores entities as objects keyed by ID like users: { byId: { 1: userData }, allIds: [1, 2] } which eliminates duplication, makes updates simpler, and improves performance by avoiding nested updates. This pattern treats your Redux store like a database with lookup tables, where relationships between entities are represented by IDs rather than nesting objects. Normalizr library or RTK's createEntityAdapter can help automate this normalization process.
You compose selectors by creating simple input selectors that extract raw state values, then combining them using createSelector from reselect which takes input selectors as arguments and a result function that transforms their outputs into derived data. Selector composition allows you to build complex selectors from simple reusable pieces, automatically memoizes results so expensive computations only run when inputs change, and maintains separation of concerns by keeping domain logic in selectors rather than components. You can create selector hierarchies where high-level selectors depend on lower-level ones, making your code more maintainable and testable.
Redux provides strict unidirectional data flow patterns that make large applications more predictable, exceptional debugging tools like time-travel debugging, and a massive ecosystem of middleware, tools, and community support. While alternatives like Zustand or Jotai are simpler for small apps with less boilerplate, Redux's structure and tooling become valuable in complex applications with multiple developers where consistency, debuggability, and established patterns prevent mistakes and make onboarding easier.
Start migration by installing Redux Toolkit alongside existing Redux without removing anything, then convert your store creation to use configureStore which automatically includes DevTools and middleware while still accepting your existing reducers. Next, identify a small, isolated slice to convert first, rewrite it using createSlice which generates actions automatically, update components to use the new action creators, and test thoroughly before moving to the next slice. Convert action creators to use createAsyncThunk for async operations, gradually replace hand-written reducers with createSlice reducers, migrate to RTK Query if you have extensive data fetching replacing thunks and hand-written cache logic, and update tests to work with new patterns. Complete the migration by removing old Redux files once all features are converted, cleaning up unused dependencies, and updating documentation with new patterns.
Essential best practices include using Redux Toolkit as the standard approach to reduce boilerplate and follow conventions, keeping state normalized and minimal with derived data in selectors, organizing code by feature rather than type for better maintainability, and using TypeScript for type safety across actions, state, and selectors. Always use memoized selectors for derived data to optimize performance, leverage RTK Query for data fetching to handle caching automatically, write comprehensive tests for reducers and selectors as pure functions, and use Redux DevTools effectively for debugging. Follow the principle of putting only truly global state in Redux while keeping local state in components, and ensure all state is serializable for proper debugging and persistence.
RTK Query is a powerful data fetching and caching tool built on top of Redux Toolkit that can be integrated into your RTK store by adding the API slice reducer and middleware. It leverages RTK's capabilities while providing a comprehensive solution for managing server state, automatic refetching, cache invalidation, and optimistic updates. RTK Query works with any async data source including REST, GraphQL, and other protocols.
RTK Query keeps unused cached data for 60 seconds by default before removing it, which can be configured using the keepUnusedDataFor option at the API level or per endpoint. This automatic cache cleanup prevents memory leaks while ensuring frequently accessed data remains available, and the timer resets if the data gets used again within the window. You can adjust this duration based on your application's needs, using longer times for more stable data or shorter for rapidly changing data.
You customize baseQuery when you need to add authentication headers to all requests using prepareHeaders, handle token refresh logic when auth tokens expire, transform all responses or errors globally, add request interceptors for logging or analytics, or integrate with a different HTTP client like axios instead of fetch. You can wrap fetchBaseQuery with additional logic using a custom baseQuery function that calls the base query and processes results, allowing you to implement patterns like automatic retry on failure, request queuing, or global error handling. Common use cases include adding Bearer tokens from Redux state, refreshing expired tokens transparently, normalizing error responses, and adding request correlation IDs for debugging.
The recommended approach is incremental migration where you convert one feature or slice at a time from vanilla Redux to RTK, allowing the old and new patterns to coexist during the transition. Start by installing Redux Toolkit alongside existing Redux, convert your store setup to configureStore which works with existing reducers, then gradually convert individual reducer files to createSlice while keeping your application running. This minimizes risk, allows for testing each conversion independently, and doesn't require stopping feature development during migration.
createAction is a helper function that generates an action creator for the given action type string, returning a function that takes a payload and returns a formatted action object. While createSlice handles this automatically for slice reducers, createAction is useful when you need standalone action creators or want to share actions across multiple slices. It ensures consistent action object structure and reduces boilerplate.
createAsyncThunk is an RTK function that generates thunks for async operations, automatically dispatching pending, fulfilled, and rejected actions based on the promise returned by your async function. It simplifies async logic by eliminating the need to manually create three action types and three action creators for each async operation, handles promise lifecycle automatically, and provides consistent patterns for loading states and error handling. You define the async function and then handle the generated actions in extraReducers to update state accordingly, making async code more maintainable and reducing boilerplate significantly.
Redux Saga uses ES6 generator functions to handle complex async flows, race conditions, task cancellation, parallel requests, and sophisticated orchestration patterns that are difficult with thunks. Sagas provide better testability since effects are plain objects, support advanced patterns like takeLatest, debounce, throttle, and retry logic declaratively, and make complex async workflows easier to reason about. However, the learning curve is steeper than thunks, making sagas better suited for complex applications while thunks suffice for simpler needs.
Handle errors in createAsyncThunk by using try-catch blocks in your payload creator to catch exceptions, then return rejectWithValue with error data to provide custom error payloads instead of the default rejected action. In your slice's extraReducers, handle the rejected case to store error information in state, optionally including error messages, status codes, or validation errors from the API response. You can also use the thunkAPI.rejectWithValue to pass structured error data that components can use to show specific error messages, implement retry logic using the thunkAPI.dispatch, or handle errors globally in middleware to show notifications or log to error tracking services.