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
Stripe · Redux
Practice Redux questions specifically asked in Stripe interviews – ideal for online test preparation, technical rounds and final HR discussions.
Questions
10
Tagged for this company + subject
Company
Stripe
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 Stripe Redux round.
A reducer must always return a new state object rather than mutating the existing state, following the principle of immutability. Reducers are pure functions that take the previous state and an action, and return the next state. If the reducer doesn't recognize the action type, it should return the previous state unchanged.
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.
Immer wraps your reducer in a produce function that provides a draft state you can safely mutate, and Immer tracks all changes to produce an immutable updated state using structural sharing for efficiency. You can write either mutating logic or return new state, but never both in the same reducer case because returning a new value tells Immer to ignore the draft mutations. Be careful not to return the draft state itself, avoid mutating state from outside the produce wrapper, and remember that async code or callbacks might not work as expected since they execute outside Immer's tracking context.
Redux-thunk middleware allows you to dispatch functions (thunks) instead of plain action objects, where these functions receive dispatch and getState as arguments and can contain async logic or conditional dispatching. This enables you to write action creators that return functions which can perform side effects like API calls, dispatch multiple actions sequentially, or dispatch actions conditionally based on current state. Thunks are the simplest and most common way to handle async logic in Redux applications.
Custom middleware follows the pattern store goes to next goes to action arrow, where you can inspect the action, call next with action to pass it along, dispatch other actions, access state with store.getState, or add side effects like logging or analytics. You would create custom middleware for cross-cutting concerns like authentication token injection, request/response logging, crash reporting, analytics tracking, action validation, or implementing complex side effect patterns not covered by existing middleware. The middleware receives the store API with dispatch and getState, the next middleware function, and the action, giving you full control over action flow.
Test reducers as pure functions by passing in a known state and action, then asserting that the returned state matches your expectations, without any mocking or complex setup required. Since reducers are pure functions, they are very easy to test in isolation by simply calling them with test data and checking the output. You can test initial state, individual action handlers, edge cases, and state transitions independently, making reducer tests fast, reliable, and maintainable.
Design Redux state to be normalized with entities stored by ID to eliminate duplication, keep it minimal by deriving computed data in selectors rather than storing it, organize by domain or data type rather than UI structure, and keep related data together in slices for easier updates. Avoid deeply nested structures that make updates complex, don't put UI state that doesn't need sharing in Redux, maintain a clear separation between domain data and UI state, and ensure state structure supports efficient updates and lookups. Consider using TypeScript to define state shape explicitly, think about how data will be accessed and updated, and remember that flat structures are easier to work with than deep trees.
An action creator is a function that creates and returns an action object, encapsulating the logic of creating actions and making the code more maintainable and reusable. Instead of manually creating action objects everywhere in your code, action creators provide a consistent way to create actions with the correct type and payload structure. They also make it easier to change action structure later since you only need to update the action creator function rather than finding all places where actions are created.
createSlice automatically generates action creators and action types that correspond to the reducer functions you define, eliminating the need to write them manually. It takes a slice name, initial state, and an object of reducer functions, and returns a slice object containing the reducer and auto-generated action creators. This dramatically reduces boilerplate and makes the code more maintainable since actions and reducers are defined together.
Queries are endpoints used for reading data and have automatic caching and refetching behavior, typically corresponding to GET requests, while mutations are for creating, updating, or deleting data and trigger cache invalidation without automatic refetching, typically using POST, PUT, PATCH, or DELETE. Queries can be triggered automatically when components mount or dependencies change, whereas mutations must be manually triggered by user actions. RTK Query treats these differently to optimize data management and performance.
RTK Query uses a tag-based system where queries declare what tags they provide using providesTags, and mutations declare what tags they invalidate using invalidatesTags, creating automatic relationships between data operations. For example, a getPosts query might provide tags Posts and each individual Post with ID, while a createPost mutation invalidates the Posts list tag to trigger a refetch. Tags can be simple strings for entire collections or objects with type and id for individual items, enabling granular control like invalidating only specific posts or all posts in a category. This declarative approach eliminates manual refetch logic and keeps your UI synchronized with backend state automatically.