100+ React Interview Questions and Answers for Freshers, Experienced & Senior Developers (2026)

hd_admin
Mahendra Solanki
Chief Executive Officer
Share:

Introduction

Most React interview questions look simple on paper. What is JSX? What does useEffect do? Then the interviewer asks, “And what happens if that dependency array is wrong?” and the room goes quiet. The gap between knowing a definition and explaining a trade-off is exactly what this guide is built to close. 

Whether you search for react js interview questions, interview questions in reactjs or simply react questions, the preparation is the same. Below are 120 React interview questions and answers, 15 coding challenges with working solutions, and 10 scenario-based problems that look like real project work. Everything is checked against the current React documentation, so topics such as Actions, Server Components, the React Compiler and View Transitions (stable in React 19.3) are explained for what they are, including where they depend on your framework. 

Interviewers test different things at different stages. A fresher is judged on fundamentals and clear thinking. An experienced developer is judged on how they build and debug real features. A senior engineer is judged on decisions: architecture, trade-offs, security and how they raise the level of a whole team. Every question carries a difficulty label and an experience label, so you can jump straight to your level. These ranges are indicative, not industry standards, and none of the questions claim to come from a specific company’s interview. 

This guide comes from the team at HireDeveloper.dev (Talent Wing of Rightbyte Technologies Pvt Ltd), who work with React developers and with the businesses that hire them. That is why you will find an interviewer’s view throughout: what a strong answer sounds like, and what a weak one gives away.

Your level Experience Start with What interviewers mostly test
Fresher 0-1 years Sections 1 to 3 JSX, props, state, basic Hooks
Junior to mid-level 1-4 years Sections 2 to 4 and 7 Hooks discipline, forms, routing, data fetching
Experienced 4-7 years Sections 4 to 7, 9 and 10 Rendering, performance, scenarios, React 19
Senior 7+ years Sections 5, 6, 8 and 9 Architecture, security, migration, team standards

react interview-ladder

How to use the answers. Each one opens with a direct response you could say out loud in the first ten seconds. The detail after it is what earns follow-up respect. Where you see an orange tip line, that is the point worth saying clearly. 

 

1. Basic React Interview Questions for Freshers

These are the basic interview questions for React JS that almost every first-round screen includes. Keep your answers short, accurate and in your own words. 

Questions: 15 

 

Difficulty: Beginner 

 

Level: Fresher / 0-1 years 

 

Q1. What is React.js? 

BEGINNER | FRESHER / 0-1 YEARS 

React is an open-source JavaScript library for building user interfaces from reusable components. You describe what the UI should look like for a given state, and React works out how to update the screen. 

Q2. What are the main features of React? 

BEGINNER | FRESHER / 0-1 YEARS 

Components, JSX, a declarative model, the Virtual DOM, one-way data flow and Hooks. Together they make a UI predictable: the same state always produces the same screen. React 19 adds Actions and Server Components, the second needing framework support. 

Q3. Why is React called a library rather than a framework? 

BEGINNER | FRESHER / 0-1 YEARS 

React handles the view layer only. Routing, data fetching and build tooling come from other tools, or from a framework such as Next.js built on top of React. You gain flexibility, but your team owns more decisions. 

Q4. What is JSX? 

BEGINNER | FRESHER / 0-1 YEARS 

JSX is a syntax extension that lets you write markup inside JavaScript. A build tool compiles it into plain JavaScript calls, so browsers never see JSX directly. 

Q5. What is the Virtual DOM? 

BEGINNER | FRESHER / 0-1 YEARS 

The Virtual DOM is a lightweight JavaScript description of the UI that React keeps in memory. When state changes, React builds a new description, compares it with the previous one and applies only the differences to the real DOM. 

Interview tip: Avoid saying it is “faster than the DOM”. Its real value is making updates declarative and batched. 

Q6. How does the Virtual DOM work? 

BEGINNER | FRESHER / 0-1 YEARS 

In three steps: render (React calls your components to produce a new element tree), compare (it diffs that tree against the previous one) and commit (it updates only the DOM nodes that changed). 

Q7. What are React components? 

BEGINNER | FRESHER / 0-1 YEARS 

Components are reusable pieces of UI written as JavaScript functions that return JSX. Their names start with a capital letter so React can tell them apart from HTML tags. 

Q8. What is the difference between functional and class components? 

BEGINNER | FRESHER / 0-1 YEARS 

Functional components are plain functions that use Hooks for state and effects. Class components extend React.Component and use this.state and lifecycle methods. New code uses functions. Classes still run, appear in older codebases, and remain the only way to write an error boundary. 

Q9. What are props in React? 

BEGINNER | FRESHER / 0-1 YEARS 

Props are inputs a parent passes to a child component. They are read-only, so a child must never modify its own props. 

Q10. What is state in React? 

BEGINNER | FRESHER / 0-1 YEARS 

State is data a component remembers between renders. Calling the setter schedules a re-render with the new value. useState is the Hook for simple values. 

Q11. What is the difference between props and state? 

BEGINNER | FRESHER / 0-1 YEARS 

Props are passed in from a parent and are read-only. State is owned by the component and changed through its setter. Both can trigger a re-render when they change. 

Aspect Props State
Owned by The parent The component itself
Can the component change it? No Yes, through the setter
Typical use Configure a child Remember user input or UI status

Q12. What is one-way data binding in React? 

BEGINNER | FRESHER / 0-1 YEARS 

Data moves in one direction, from parent to child through props. When a child needs to change the parent’s data, it calls a function the parent passed down. That makes data flow easy to trace and debug. 

Q13. What is conditional rendering? 

BEGINNER | FRESHER / 0-1 YEARS 

Showing different UI depending on a condition, using ternaries, && or early returns. 

Interview tip: Mention the classic trap: {items.length && <List />} renders 0 for an empty array. Use items.length > 0 && instead. 

Q14. What are lists and keys in React? 

BEGINNER | FRESHER / 0-1 YEARS 

You render a list with map() and give every item a stable, unique key so React can tell which items were added, moved or removed. Use database IDs rather than array positions. 

Interview tip: Keys must be stable and unique among siblings, not globally. 

Q15. What is the purpose of the render process in React? 

BEGINNER | FRESHER / 0-1 YEARS 

Rendering is React calling your components to work out what should be on screen. It happens on first load and whenever state or props change. Rendering is separate from committing: React touches the DOM only in the commit step, so render code must be pure.

 

2. React.js Fundamentals Interview Questions

This is where interviewers separate memorised definitions from real understanding. These react javascript interview questions often come with a follow-up that starts with “why”. 

Questions: 15 

 

Difficulty: Beginner to Intermediate 

 

Level: Junior / 1-2 years 

 

Q16. What is the difference between React and ReactDOM? 

INTERMEDIATE | JUNIOR / 1-2 YEARS 

react holds the core: components, Hooks and element creation. react-dom connects that core to the browser through createRoot, hydrateRoot, portals and server rendering APIs. React Native uses the same core with a different renderer. 

import { createRoot } from ‘react-dom/client’; 

createRoot(document.getElementById(‘root’)).render(<App />); 

Q17. What is reconciliation in React? 

INTERMEDIATE | JUNIOR / 1-2 YEARS 

Reconciliation is how React compares the new element tree with the previous one to decide the smallest set of changes. It assumes elements of different types produce different trees, and it uses keys to match list items. 

Q18. How does React update the DOM? 

INTERMEDIATE | JUNIOR / 1-2 YEARS 

React renders, compares, then commits the changes together. During commit it applies only what changed, then runs layout effects, and passive effects such as useEffect run after the browser paints. Treat this as the conceptual model, since React DOM handles browser-level details. 

Q19. What is the purpose of keys in React lists? 

INTERMEDIATE | JUNIOR / 1-2 YEARS 

Keys give each item an identity across renders, so React keeps state with the right item when a list reorders. Changing a key tells React to treat the component as brand new and reset its state. 

Interview tip: The reset trick is a nice bonus: changing key on a form is a clean way to clear it. 

Q20. Why should array indexes generally be avoided as keys? 

INTERMEDIATE | JUNIOR / 1-2 YEARS 

When items are inserted, removed or reordered, an index points to a different item, so React can attach state, such as typed input text, to the wrong row. Indexes are acceptable only for static lists that never change. 

Interview tip: Describe the bug: a deleted row leaves its input text on the row below. 

Q21. What are controlled and uncontrolled components? 

INTERMEDIATE | JUNIOR / 1-2 YEARS 

In a controlled component React state drives the input value through value and onChange. In an uncontrolled one the DOM holds the value and you read it through a ref or FormData. 

<input value={name} onChange={e => setName(e.target.value)} /> 

Q22. What are synthetic events in React? 

INTERMEDIATE | JUNIOR / 1-2 YEARS 

React wraps native browser events in cross-browser event objects that share the native interface, so e.preventDefault() works as expected. Handlers are camelCase props such as onClick, and React listens at the root container. 

Q23. What is component composition? 

INTERMEDIATE | JUNIOR / 1-2 YEARS 

Composition builds complex UI by combining smaller components, often by passing children or other components as props. React recommends composition over inheritance. 

function Card({ title, children }) { 

return <section><h3>{title}</h3>{children}</section>; 

} 

Q24. What is lifting state up? 

INTERMEDIATE | JUNIOR / 1-2 YEARS 

When two components need the same data, move the state to their closest common parent and pass it down as props with callbacks. The parent becomes the single source of truth. 

Q25. What is prop drilling? 

INTERMEDIATE | JUNIOR / 1-2 YEARS 

Passing props through several layers of components that do not use them, only to reach a deep child. Fixes include composition, Context or a state library. Composition often solves it without adding anything. 

Q26. What are fragments in React? 

INTERMEDIATE | JUNIOR / 1-2 YEARS 

Fragments let a component return several elements without adding an extra DOM node. Use <>…</>, or <Fragment key={id}> when mapping a list. 

Q27. What are portals in React? 

INTERMEDIATE | JUNIOR / 1-2 YEARS 

createPortal(children, domNode) renders children into a different DOM node while keeping them in the same React tree, so context and event bubbling still work. It suits modals, tooltips and dropdowns that must escape overflow or z-index traps. 

Interview tip: Remember the detail: events bubble through the React tree, not the DOM tree. 

Q28. What are error boundaries? 

INTERMEDIATE | JUNIOR / 1-2 YEARS 

An error boundary is a class component with getDerivedStateFromError or componentDidCatch that catches rendering errors in its children and shows a fallback UI. It does not catch errors in event handlers or async code. Many teams use the react-error-boundary package to avoid writing classes. React 19 also adds root options such as onCaughtError for reporting. 

Interview tip: Name what they do not catch. That detail signals real experience. 

Q29. What is the difference between mounting, updating and unmounting? 

INTERMEDIATE | JUNIOR / 1-2 YEARS 

Mounting is a component’s first appearance, updating is a re-render caused by new props or state, and unmounting is its removal. Classes use componentDidMount, componentDidUpdate and componentWillUnmount. Function components cover all three with useEffect and its cleanup. 

Interview tip: Do not map every effect to a lifecycle method. Effects synchronise with outside systems. 

Q30. What is the difference between client-side rendering and server-side rendering? 

INTERMEDIATE | JUNIOR / 1-2 YEARS 

With client-side rendering the browser receives a small HTML shell and JavaScript builds the UI. With server-side rendering the server sends ready HTML, and React then hydrates it to make it interactive. SSR improves first paint and crawlability but needs a server and adds hydration cost.

 

3. React Hooks Interview Questions and Answers

Hooks are among the most important React JS interview questions, and they reward precision. Interviewers listen for correct dependency behaviour, cleanup and honesty about when a Hook is unnecessary. 

Questions: 15 

 

Difficulty: Beginner to Advanced 

 

Level: Junior to Mid-level 

 

Q31. What are React Hooks? 

BEGINNER | JUNIOR / 1-2 YEARS 

Hooks are functions whose names start with use that let function components use state, effects and other React features. They must be called at the top level of a component or another Hook. 

Q32. What is the useState Hook? 

BEGINNER | JUNIOR / 1-2 YEARS 

useState returns the current value and a setter. When the next value depends on the previous one, pass an updater function. Objects and arrays must be replaced, not mutated. 

setCount(c => c + 1); 

setUser(u => ({ …u, name: ‘Asha’ }));

Q33. How does the useEffect Hook work? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

useEffect runs after render to synchronise a component with an outside system such as the network, a subscription, a timer or a browser API. It can return a cleanup function. 

useEffect(() => { 

const id = setInterval(tick, 1000); 

return () => clearInterval(id); 

}, []); 

Interview tip: Say “synchronise with an external system”, not “lifecycle method”. 

Q34. What is the dependency array in useEffect? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

It controls when the effect re-runs. No array means after every render, [] means on mount only, and [a, b] means when a or b change. Every reactive value used inside the effect must be listed. The react-hooks lint rule enforces this, and in development Strict Mode runs effects twice to test your cleanup. 

Interview tip: Never suppress the lint rule to “fix” a loop. Restructure the code instead. 

Q35. What is the difference between useEffect and useLayoutEffect? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

useEffect runs after the browser paints. useLayoutEffect runs after DOM changes but before paint, so it blocks the screen. Use it only for measuring layout, such as positioning a tooltip, to avoid flicker. It does not run on the server. 

Interview tip: Default to useEffect and justify any exception. 

Q36. What is useRef and when should it be used? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

useRef holds a mutable value that persists across renders without causing a re-render. It is used for DOM nodes, timer IDs and previous values. Avoid reading or writing ref.current during rendering. 

const inputRef = useRef(null); 

// <input ref={inputRef} /> 

inputRef.current.focus(); 

Q37. What is useMemo? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

useMemo caches the result of a calculation until its dependencies change. It is a performance hint, not a guarantee. Use it for genuinely expensive work or to keep an object stable for a memoised child, and profile first because memoisation has its own cost. 

const sorted = useMemo(() => sortRows(rows), [rows]); 

Interview tip: Say it is a tool, not a default pattern. 

Q38. What is useCallback? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

useCallback caches a function definition between renders. It helps when you pass a function to a React.memo child or use it as another Hook’s dependency. Elsewhere it only adds noise. 

const onSave = useCallback(() => save(id), [id]); 

Q39. What is the difference between useMemo and useCallback? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

useMemo caches a value and useCallback caches a function. useCallback(fn, deps) is equivalent to useMemo(() => fn, deps). Neither speeds anything up unless it prevents real work, so separate memoisation from measurable improvement. 

Q40. What is useContext? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

useContext reads the nearest value from a Context so deep components can use shared data without prop drilling. Every consumer re-renders when the value changes, so split contexts and keep values stable. In React 19 you render <Context value={…}> directly, and use(Context) can read it conditionally. 

Q41. What is useReducer? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

useReducer manages state with a pure function (state, action) => newState. Choose it over useState when updates involve several fields or non-trivial logic. 

default: return state; 

} 

} 

const [items, dispatch] = useReducer(reducer, []); 

Q42. What is the useId Hook? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

useId generates a stable unique ID that matches between server and client rendering. Use it to connect labels and inputs for accessibility, never for list keys. 

const id = useId(); 

// <label htmlFor={id}>Email</label> 

// <input id={id} /> 

Q43. What are custom Hooks?

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

Custom Hooks are functions starting with use that call other Hooks to share stateful logic. They share logic, not state: each call gets its own state. 

function useToggle(initial = false) { 

const [on, setOn] = useState(initial); 

const toggle = useCallback(() => setOn(v => !v), []); 

return [on, toggle]; 

} 

Q44. What are the Rules of Hooks? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

Call Hooks only at the top level, never inside loops, conditions or nested functions, and only from function components or custom Hooks. React matches state to Hooks by call order. The exception is use, which may be called conditionally. 

Q45. How can you prevent unnecessary effects and stale closures in React? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Calculate derived values during render instead of syncing them in an effect, and put user-triggered logic in event handlers. Stale closures happen when an effect or callback captures old values. Fix them by listing dependencies, using updater functions, or useEffectEvent (stable since React 19.2) for logic that should read the latest values without re-triggering the effect. 

// No effect needed: derive during render 

const visible = items.filter(i => i.name.includes(query));

Interview tip: Cite the docs page You Might Not Need an Effect. It shows you know the guidance.

 

4. Intermediate React Interview Questions

At this level, interviewers want to hear how you build real features: sharing state, calling APIs, routing and keeping bundles small. 

Questions: 15 

 

Difficulty: Intermediate 

 

Level: Mid-level / 2-4 years 

 

Q46. What is the Context API? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

Context is React’s built-in way to share values such as theme, locale or the signed-in user across a component tree without passing props by hand. You create it, provide a value, and read it with useContext or use. It suits values that change rarely. 

Q47. When should you use Context API instead of prop drilling? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

Use it when many components at different depths need the same slowly changing value, such as theme, locale or the current user. For two or three levels, plain props are clearer, and composition with children can often remove drilling altogether. 

Q48. What is the difference between Context API and Redux? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

Context only delivers a value. Redux adds a store, predictable updates, middleware, selectors and devtools. Any change to a Context value re-renders all its consumers, while Redux components re-render only when their selected data changes. Use Context for simple shared config, and a store when state is large and updates often. 

Q49. What is Redux and how does it work? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

Redux keeps application state in a single store. Components dispatch actions that describe what happened, pure reducers compute the next state, and subscribed components re-render. The loop is UI, action, reducer, store, UI. 

Q50. What is the difference between Redux and Redux Toolkit? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

Redux Toolkit is the official, recommended way to write Redux. It removes boilerplate with configureStore and createSlice, allows safe-looking mutation through Immer, and includes RTK Query for data fetching. Hand-written switch reducers and manual action types are the legacy style.

Q51. What is React Router? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

React Router is the standard routing library for React. It maps URLs to components without full page reloads and supports nested routes, URL params, loaders and actions. Recent versions also offer a framework mode with server rendering.

Q52. How do protected routes work in React? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

A wrapper route checks authentication state and either renders the child routes or redirects to login. This is a user-experience feature only. The server must still verify every API request. 

Interview tip: Say clearly: hiding a route is not security. 

Q53. How do you fetch API data in React, and how does React talk to a Node.js backend? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

In client components, fetch inside an effect with cleanup, or better, use a data library such as TanStack Query for caching, retries and de-duplication. Frameworks offer loaders or Server Components instead. In React and Node.js interview questions and answers, the key point is the split: React handles presentation, while the Node.js API handles authentication, validation and the database. 

Interview tip: Mention the abort cleanup. It prevents race conditions when id changes quickly. 

Q54. How do you handle API errors and secure data exchange between React and Node.js? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

Check res.ok, keep an error state, show a clear message with a retry option, and use an error boundary for render failures. For security, use HTTPS, validate all input on the server, restrict CORS to known origins, use HttpOnly, Secure and SameSite cookies, and never trust client-side validation. 

Q55. How do you manage forms in React? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

Use controlled inputs for small forms. For large forms, a library such as React Hook Form reduces re-renders and simplifies validation. Always validate on the server as well. React 19 form Actions let <form action={fn}> handle submission with built-in pending state. 

Q56. What is lazy loading in React? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

Lazy loading fetches a component’s code only when it is needed, using React.lazy and Suspense.

Q57. What is code splitting? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

Code splitting divides the bundle into chunks loaded on demand, so users download less up front. Route-level splitting gives the biggest win first, and bundlers create the chunks from dynamic import() calls. 

Q58. What is React.memo? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

React.memo wraps a component so React skips re-rendering it when its props are shallowly equal. It helps when a component is expensive and re-renders often with the same props. It does nothing if you pass a new object or function every render. 

Interview tip: Add that React Compiler can apply this kind of memoisation automatically. 

Q59. What is the difference between state and refs? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

State changes trigger a re-render and hold data shown on screen. Refs hold mutable values that do not affect the output, such as DOM nodes and timer IDs. If the UI should change when the value changes, use state. 

Q60. How do you manage environment variables in a React application? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

Build tools inline them at build time, for example import.meta.env.VITE_API_URL in Vite or NEXT_PUBLIC_ variables in Next.js. Anything in the client bundle is public, so never put secrets in frontend variables. Keep secrets on the server. 

Interview tip: This is a favourite security check. Say “public by design” about client variables.

 

5. Advanced React Interview Questions for Experienced Developers

These are the reactjs interview questions and answers for experienced developers, typically 4 to 7 years in. Definitions are not enough here. Interviewers want mechanism, limits and a real example. 

Questions: 15 

 

Difficulty: Advanced 

 

Level: Experienced / 4-7 years 

 

infographic-2-render-pipeline

Q61. How does React reconciliation work internally? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

React compares the new element tree with the work-in-progress tree. A different type at the same position tears down and rebuilds that subtree. The same type updates props and recurses, and keys match list children. The work runs through Fiber nodes. Follow-up: why does defining a component inside another component reset its state? Because the type is new on every render. 

Interview tip: The follow-up answer shows you have debugged this in real code. 

Q62. What is React Fiber? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Fiber is React’s internal reconciliation engine, introduced in React 16. Each component instance has a fiber node, which is a unit of work that React can pause, resume or discard. That design makes concurrent features possible. You do not control Fiber directly. You influence scheduling with Transitions, Suspense and useDeferredValue. 

Interview tip: Do not claim developers schedule Fiber. Describe the APIs that influence it. 

Q63. What is concurrent rendering in React? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Concurrent rendering means a render can be interrupted: React may start rendering, pause for a more urgent update, then resume or restart. It is not automatic for everything. You opt in by marking updates as Transitions or by using Suspense and deferred values. Pure render functions make this safe. 

Q64. What are transitions in React? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

startTransition and useTransition mark a state update as non-urgent, so React keeps the current UI responsive and may interrupt that update if something urgent arrives.

Q65. What is the difference between urgent and non-urgent updates? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Urgent updates reflect direct interaction, such as typing, clicking and pressing. Non-urgent updates are view changes that can wait, such as filtering a large list or navigating. React prioritises urgent updates and may pause transitions. 

Q66. What are Suspense boundaries? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

<Suspense fallback={…}> shows a fallback while its children wait for lazy-loaded code, use(promise) or a Suspense-enabled data source. Place boundaries where a loading state makes sense for the user, and nest them to reveal content progressively. Suspense does not detect fetches made inside useEffect. 

Interview tip: The useEffect limitation is a common trick question. 

Q67. What are React Server Components? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Server Components render ahead of time on a server or at build time, and only their output is sent to the browser, not their JavaScript. They can read databases and files directly and add nothing to the client bundle. They need framework or bundler support, such as the Next.js App Router, and cannot use state or effects. 

Interview tip: Say plainly that RSC is not available in a plain Vite single-page app by default. 

Q68. What is the difference between Server Components and Client Components? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Server Components run on the server and ship no component code. Client Components run in the browser and are marked with ‘use client’ at the top of a module, which creates the boundary. 

Aspect Server Component Client Component
Runs on Server or at build time Browser (also pre-rendered on the server)
State, effects, browser APIs Not available Available
Direct database or secrets access Yes, server only No
Adds to JS bundle No Yes

Q69. What are Server Functions and React Actions? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

A Server Function is marked ‘use server’, runs on the server, and is called from the client through a framework-managed network request. An Action is any async function used in a transition, such as <form action={fn}>. An Action may be a client function or a Server Function. Unlike a plain event handler, Actions get pending, error and optimistic state support. 

Interview tip: Add that a Server Function is a public endpoint, so validate input and check permissions inside it. 

Q70. How does React handle state updates and batching? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

React batches multiple state updates in the same tick into one re-render. Since React 18 this is automatic everywhere, including timeouts and promises. State is a snapshot per render, so setCount(count + 1) called three times adds only one. Use the updater form to chain.

Q71. What causes unnecessary component re-renders? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

A parent re-render re-renders all children by default. New object, array or function props defeat React.memo. A changed Context value re-renders every consumer, and state placed too high widens the damage. Fix by moving state down, splitting components, stabilising props, or using memoisation where profiling shows a benefit. 

Interview tip: Say “a re-render is not a bug. A slow re-render is.” 

Q72. How do you optimize complex React applications? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Measure first with the React DevTools Profiler and the browser Performance panel. Then fix the largest cost: reduce work per render, virtualise long lists, split code, defer non-urgent updates, cache server data and optimise images. Memoise last. 

Q73. How do you manage global state in large applications? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Separate state by kind. Server state belongs in a query library or framework loaders, URL state in the router, form state in a form library, and UI state locally or in Context. Only a small amount of true client-wide state needs a store such as Zustand or Redux Toolkit. 

Q74. How do you handle authentication and authorization between React and Node.js? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Authentication proves who the user is, and authorization decides what they may do. After login, the Node.js server issues a session or token, ideally in an HttpOnly, Secure, SameSite cookie. React asks a /me endpoint who is signed in and adapts the UI. The server must check permissions on every request. localStorage is readable by any script on the page, so an XSS bug can steal tokens. 

Interview tip: Finish with: hiding a button is UX, enforcing access is the server’s job. 

Q75. How do you organize a scalable React application architecture? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Organise by feature rather than file type, keep components small, and separate UI, data access and business logic with clear boundaries. Enforce conventions with lint rules and path aliases, and standardise data fetching, error handling and tests. Start simple and add layers when real pain appears. 

 

6. React Scenario-Based Interview Questions for Experienced Developers

These react scenario based interview questions for experienced developers mirror problems from professional projects. Interviewers care less about the final answer and more about how you investigate, prioritise and communicate trade-offs. 

Questions: 10 

 

Difficulty: Advanced 

 

Level: Experienced / 4-7 years 

 

Q76. Your React application renders thousands of records and becomes slow. How would you optimize it? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Problem: A table with 5,000 rows lags on scroll and typing. 

Approach: Profile first. Then paginate or filter on the server, virtualise the list with a library such as TanStack Virtual or react-window so only visible rows mount, memoise the row component, and move sorting to the backend. 

What a strong candidate says: “How many rows does the user really need? What did the Profiler show?” They question the requirement before reaching for tools. 

Q77. An API request fails intermittently. How would you handle errors, retries and user feedback? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Problem: Orders sometimes fail to load on poor networks. 

Approach: Separate transient failures (network errors, 5xx, 429) from permanent ones (most 4xx). Retry only safe requests, with exponential backoff and a cap. Keep stale data visible, show an inline message with a Retry button, and log a request ID. 

What a strong candidate says: “Never retry non-idempotent writes blindly.” A query library handles retries cleanly: 

const { data, error, refetch } = useQuery({ 

queryKey: [‘orders’], 

queryFn: fetchOrders, 

retry: 2, 

}); 

Q78. Multiple components need access to the same state. How would you design the state management approach? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Problem: A filter in a sidebar must drive a table and a chart. 

Approach: Classify the state first. Server data goes in the query cache. State shared by siblings is lifted to the parent. Many distant consumers can use Context for rarely changing values or a store with selectors for frequent updates. Put shareable filters in the URL. 

What a strong candidate says: They avoid jumping straight to Redux, and they explain why this state needs sharing at all. 

Q79. A component re-renders unnecessarily after its parent updates. How would you troubleshoot it? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Problem: A heavy chart re-renders on every keystroke in a nearby input. 

Approach: Record in the React DevTools Profiler with “record why each component rendered” enabled. Check for new object or function props, Context changes and state held too high. Move the input state down or pass the chart as children, then memoise with stable props if needed. 

What a strong candidate says: They prove the fix with a before-and-after profile, not by guessing. 

Q80. Your application has authentication and protected routes. How would you implement them securely? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Problem: Admin pages must be visible only to admins. 

Approach: Use server-side sessions or short-lived tokens in HttpOnly cookies, add CSRF protection for cookie auth, and use route guards for experience only. The server checks role and ownership on every request. Handle 401 responses globally by redirecting to login. 

What a strong candidate says: “Client-side role flags are cosmetic. The API is the real gate.” 

Q81. Your React application has a large bundle size. How would you reduce the initial loading time? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Problem: The first load ships 2 MB of JavaScript. 

Approach: Analyse the bundle with a visualiser, split code by route with lazy, swap heavy libraries for lighter ones, import only what you use, defer below-the-fold features, enable Brotli compression and set a size budget in CI. 

What a strong candidate says: They quote what the analyser found rather than listing generic tips. 

Q82. Users report stale data after navigation. How would you investigate caching and data-fetching behavior? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Problem: A user edits a profile, navigates away and sees old values. 

Approach: Find which cache layer is serving old data: browser HTTP cache, client query cache, framework cache or CDN. Check that query keys include every parameter, invalidate related queries after mutations, and set a sensible staleTime. Reproduce with the Network tab. 

What a strong candidate says: They name the layers and ask which one is responsible, instead of adding a refresh button. 

Q83. A form contains multiple dependent fields and complex validation. How would you design it? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Problem: A loan form where country changes the required fields. 

Approach: Use a form library such as React Hook Form with a schema validator, ideally one schema shared with the backend. Model dependencies explicitly by watching the controlling field, calculate derived values instead of storing them, validate on blur and submit, and announce errors accessibly. 

What a strong candidate says: “Client validation helps users. Server validation protects the system.” 

Q84. Your team needs to migrate a large class-component application to modern React. What approach would you follow? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Problem: A five-year-old codebase with hundreds of class components. 

Approach: Do not rewrite. Upgrade React first and clear warnings, add tests around critical flows, convert leaf components first, extract shared logic into custom Hooks, and leave stable classes alone. Error boundaries remain classes. Ship in small releases. 

What a strong candidate says: They talk about risk, rollback and measurable milestones, not enthusiasm for new syntax. 

Q85. A React application has inconsistent behavior across browsers and devices. How would you debug and resolve the issue? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Problem: A layout breaks only on mobile Safari. 

Approach: Reproduce on real devices or a cloud device lab, check console errors, review feature support and polyfills, and look for CSS differences such as mobile viewport units. Check for hydration mismatches and locale or timezone assumptions. Add cross-browser end-to-end tests with Playwright. 

What a strong candidate says: They isolate the variable (browser, device, locale or build) before changing code. 

 

7. React Coding Interview Questions and Challenges

These react coding interview questions and challenges test whether you can turn a requirement into working code while explaining your choices. Every solution uses function components and Hooks, includes its imports, and avoids extra libraries. Where data is assumed, the assumption is stated. Practise saying the explanation out loud, because react interview coding challenges are as much about communication as syntax. 

Questions: 15 

 

Difficulty: Beginner to Intermediate 

 

Level: Fresher to Mid-level 

 

 Q86. Create a counter application using useState 

CHALLENGE 1 | BEGINNER | FRESHER / 0-1 YEARS 

Problem: Build a counter with increment, decrement and reset. The count must not go below zero. 

How it works: The updater form c => c + 1 always works from the latest value. The decrement button is disabled at zero, which makes the rule visible to the user.

Edge cases: Ask whether negative numbers are allowed. Clarifying the rule is part of the answer. 

Q87. Build a searchable list with filtering 

CHALLENGE 2 | BEGINNER | FRESHER / 0-1 YEARS 

Problem: Show a list of fruits and filter it as the user types. Show a message when nothing matches. 

How it works: The filtered list is derived during render from query, so no effect and no second state variable are needed. Trimming and lower-casing makes matching forgiving. 

Q88. Create a reusable modal component 

CHALLENGE 3 | INTERMEDIATE | JUNIOR / 1-2 YEARS 

Problem: Build a modal that closes on Escape, on backdrop click and through a Close button. 

How it works: A portal renders the modal at the end of document.body, escaping parent overflow and z-index. The effect adds the key listener only while the modal is open and removes it on cleanup.

Edge cases: Mention focus trapping, scroll locking and the native <dialog> element as production considerations. 

Q89. Build a debounced search input 

CHALLENGE 4 | INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

Problem: Call a search API only after the user stops typing for 300 ms. Assume /api/search?q= returns [{ id, name }]. 

How it works: useDebounce delays a value change using a timeout that is cleared on every keystroke. The fetch effect depends on the debounced term and aborts the previous request in its cleanup, which prevents out-of-order responses.

Edge cases: Encode the query, handle the empty term, and abort stale requests. Add loading and error states in a real app. 

Q90. Implement pagination in React 

CHALLENGE 5 | INTERMEDIATE | JUNIOR / 1-2 YEARS 

Problem: Show 5 items per page with Previous and Next buttons. Assume items is [{ id, name }]. 

How it works: The page count is derived from the data length. Clamping the current page protects against the list shrinking while the user is on a later page. 

Edge cases: For large data sets, paginate on the server and send page and limit to the API. 

Q91. Create a reusable custom Hook 

CHALLENGE 6 | INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

Problem: Write useLocalStorage that keeps a value in sync with localStorage. 

How it works: The lazy initialiser reads storage once. The effect writes changes back. Both are wrapped in try/catch because storage can be blocked or full. 

Edge cases: Never store sensitive data here, and guard window if the code runs during server rendering. 

Q92. Build a shopping cart with add, remove and quantity update 

CHALLENGE 7 | INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

Problem: Add products, change quantities, remove lines and show a total. A quantity of zero removes the line. 

How it works: A reducer keeps all cart transitions in one testable function. Adding an existing product increments its quantity instead of duplicating the row.

Edge cases: Store money in the smallest currency unit to avoid floating-point errors, and never trust a client-side total at checkout. 

Q93. Implement infinite scrolling 

CHALLENGE 8 | INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

Problem: Load 20 more items whenever the user reaches the bottom, up to 100 items. 

How it works: An IntersectionObserver watches a sentinel element at the end of the list. When it becomes visible, the next batch is appended. The observer is disconnected in cleanup, and the sentinel disappears when there is nothing left to load. 

Edge cases: With a real API, add a loading flag to stop duplicate requests, and consider virtualisation once the list grows large. 

Q94. Create a form with validation 

CHALLENGE 9 | INTERMEDIATE | JUNIOR / 1-2 YEARS 

Problem: Build a sign-up form that validates email format and a password of at least 8 characters on submit. 

How it works: One state object holds all values, and one handleChange uses the input’s name. Validation is a pure function, so it is easy to test and to share with the server. 

Edge cases: Client checks improve usability. The server must validate again because anyone can bypass the browser. 

Q95. Build a tabs component 

CHALLENGE 10 | BEGINNER | JUNIOR / 1-2 YEARS 

Problem: Create a Tabs component that takes tabs as [{ label, content }] and shows the active panel. 

How it works: Only the active index is stored. ARIA roles make the component understandable to screen readers. Labels are used as keys, so they must be unique.

Edge cases: Guard the empty array, and mention arrow-key navigation as the next accessibility step. 

Q96. Create an accordion component 

CHALLENGE 11 | BEGINNER | JUNIOR / 1-2 YEARS 

Problem: Build an accordion where only one section is open at a time. Items are [{ id, title, body }]. 

How it works: Storing the open item’s ID, instead of a boolean per item, guarantees a single open section. Clicking the open item closes it.

Edge cases: For multi-open behaviour, store a Set of open IDs instead. 

Q97. Implement a todo list with filtering and completion states 

CHALLENGE 12 | INTERMEDIATE | JUNIOR / 1-2 YEARS 

Problem: Add todos, toggle completion and filter by All, Active or Done. 

How it works: Todos live in one array, and the filter is a separate piece of state. The visible list is derived during render. Every update creates a new array or object, never a mutation. 

Edge cases: Ignore blank input, and note that crypto.randomUUID() needs a secure context (HTTPS or localhost). 

Q98. Fetch and display API data with loading and error states 

CHALLENGE 13 | INTERMEDIATE | JUNIOR / 1-2 YEARS 

Problem: Fetch users from a public demo API and show loading, error and success states. 

How it works: A single status field avoids impossible combinations such as loading and error at once. The res.ok check turns HTTP failures into errors, and the cleanup aborts the request on unmount. 

Edge cases: Mention a retry button and empty-state handling. In production, a query library replaces most of this code. 

Q99. Create a reusable dropdown with outside-click handling 

CHALLENGE 14 | INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

Problem: Build a dropdown that closes when the user clicks outside it. 

How it works: A ref points at the wrapper. While the menu is open, a document listener checks whether the click target is inside the wrapper, and the cleanup removes it. 

Edge cases: Add Escape-key closing and arrow-key navigation to show accessibility awareness. 

Q100. Build a data table with sorting and filtering 

CHALLENGE 15 | INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

Problem: Show a table that can be filtered by text and sorted by clicking a column header. 

How it works: Filter and sort are state, and the rows are derived from them. The array is copied before sorting because sort mutates. useMemo is optional for three rows but makes sense for thousands. 

Edge cases: Mention server-side sorting and filtering for large data, and numbers versus strings in the comparator. 

 

8. React Interview Questions for Senior Engineers

React for senior engineer roles is less about syntax and more about judgement. These questions test architecture, trade-offs and how you lift a team. If you are on the hiring side, our React developer hiring checklist turns similar signals into an evaluation process. 

Questions: 10 

 

Difficulty: Expert 

 

Level: Senior / 7+ years 

 

Q101. How would you design a scalable React application architecture for an enterprise? 

EXPERT | SENIOR / 7+ YEARS 

Start with domain boundaries: feature modules with explicit public APIs, a shared design system, a consistent data layer, and a rendering strategy that matches the product. Add monorepo tooling, CI gates for types, lint, tests and bundle size, and record decisions as short architecture decision records. More structure slows small teams, so scale it with team size. 

What separates a senior answer: they tie architecture to team ownership and cost of change, not just folder names. 

Q102. How would you identify and resolve performance bottlenecks in a large React application? 

EXPERT | SENIOR / 7+ YEARS 

Define budgets first, such as LCP, INP and bundle size, and collect real-user data. Then profile: the React Profiler for render cost, the browser Performance panel for long tasks, and the network waterfall for request chains. Fix by category (network, bundle, rendering, main thread) and guard against regressions in CI. 

What separates a senior answer: they trust field data over a developer laptop and prevent regressions, not just fix them once. 

Q103. How would you choose between Context API, Redux Toolkit, Zustand and server-state solutions? 

EXPERT | SENIOR / 7+ YEARS 

Classify the state before choosing a tool. Server data belongs in a query library or framework data layer, shareable filters in the URL, local state in useState, rarely changing config in Context, and frequently updated shared client state in Zustand or Redux Toolkit. Choose Redux Toolkit for strict conventions on large teams, and Zustand for a small footprint. No library is the universal answer. 

What separates a senior answer: they pick per kind of state and explain what they would give up. 

infographic-3-state-placement

Q104. How would you establish reusable component architecture and design systems? 

EXPERT | SENIOR / 7+ YEARS 

Build in layers: accessible primitives, composed components, then page patterns. Drive styling from design tokens, document components in Storybook, version the package, and add accessibility and visual regression tests. Prefer composition with children and slots over props that keep multiplying. Define a contribution model and a deprecation policy. 

What separates a senior answer: they cover governance and adoption, because a design system nobody uses is just a folder. 

Q105. How would you manage frontend security in a large React application? 

EXPERT | SENIOR / 7+ YEARS 

Defend in layers. Avoid dangerouslySetInnerHTML or sanitise with a vetted library, set a Content Security Policy (React 19.3 also supports Trusted Types), keep tokens in HttpOnly cookies, keep secrets off the client, audit dependencies, and validate everything on the server. Keep React and framework packages patched, because Server Components have had security advisories that required upgrades. 

What separates a senior answer: they treat the client as untrusted territory and include dependency hygiene in the plan. 

Q106. How would you plan a migration from legacy React architecture to modern React? 

EXPERT | SENIOR / 7+ YEARS 

Use a strangler approach: new features in the modern stack, old screens migrated route by route, adapters around legacy code. Upgrade React first and fix deprecations, add tests before touching critical flows, and set measurable milestones. Avoid a big-bang rewrite. 

What separates a senior answer: they plan rollback, communication and stakeholder expectations, not just code changes. 

Q107. How would you design data-fetching and caching strategies for a complex application? 

EXPERT | SENIOR / 7+ YEARS 

Decide where each piece of data is fetched: on the server for first paint, on the client for interaction. Layer caches deliberately (CDN or HTTP, framework, client query cache), define staleness per resource, invalidate by key or tag after mutations, prefetch likely navigation, fetch in parallel to avoid waterfalls, and handle errors consistently. 

What separates a senior answer: they discuss freshness versus speed per resource instead of one global rule. 

Q108. How would you establish frontend testing standards across a development team? 

EXPERT | SENIOR / 7+ YEARS 

Use unit tests for pure logic, component tests with React Testing Library that check behaviour rather than implementation, and a small set of Playwright end-to-end tests for critical journeys. Vitest or Jest runs the unit layer, and network mocking sits at the boundary. Treat coverage as a signal, write the standards down and enforce them in CI. 

What separates a senior answer: they keep the suite fast and trustworthy, because a flaky suite gets ignored. 

Q109. How would you review React code and improve engineering quality across multiple developers? 

EXPERT | SENIOR / 7+ YEARS 

Review for correctness, readability, accessibility, performance and tests, and keep pull requests small. Let automation (ESLint with the react-hooks rules, TypeScript, Prettier, CI) handle style so human review focuses on design. Explain the reasoning in comments, pair on tricky changes and maintain a shared checklist. 

What separates a senior answer: they raise the team’s level instead of just fixing individual pull requests. 

Q110. How would you make architectural decisions between Next.js, React Router and a Vite-based React application? 

EXPERT | SENIOR / 7+ YEARS 

A Vite single-page app suits internal tools and dashboards behind a login where SEO is irrelevant and hosting should be simple. Next.js suits products that need server rendering, Server Components, caching and SEO. React Router’s framework mode suits teams who prefer web-standard loaders and actions and flexible hosting. Decide on rendering needs, team skills, hosting limits and lock-in. 

What separates a senior answer: they ask about the product’s requirements before naming a tool.

 

9. React Performance and Optimization Interview Questions

Performance questions test whether you can separate a technique from a measurable improvement. 

Questions: 5 

 

Difficulty: Intermediate to Advanced 

 

Level: Mid-level to Experienced 

 

Q111. How do you optimize React application performance? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Measure, find the real cost, apply a targeted fix and measure again. Typical wins come from less JavaScript (code splitting, lighter dependencies), less rendering work (state placement, memoisation, virtualisation) and faster data (caching, parallel requests, compression). Use the React DevTools Profiler for rendering and the browser Performance panel for the rest. 

Interview tip: Always say what you measured and how much it improved. 

Q112. What is the difference between React.memo, useMemo and useCallback? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

All three avoid repeated work, but they cache different things. None is mandatory, and each has a cost. 

Tool Caches Use when Common mistake
React.memo A component’s rendered output An expensive child re-renders with unchanged props Passing new objects or functions as props
useMemo A calculated value A calculation is genuinely costly Wrapping trivial calculations
useCallback A function reference A memoised child or Hook depends on it Using it everywhere by habit

Interview tip: Add that React Compiler can handle much of this automatically when code follows the Rules of React. 

Q113. How do you identify unnecessary re-renders? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Record an interaction in the React DevTools Profiler, enable the option to record why each component rendered, and inspect the flame graph for components that render often with unchanged output. The “highlight updates” option shows re-renders live. Newer React versions also add custom tracks to the Chrome performance timeline. 

Interview tip: Describe a real profiling session, even a small one. 

Q114. How do lazy loading and code splitting improve performance? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

They shrink the JavaScript sent on first load, so the browser parses and runs less before the page becomes usable. That helps load and interaction metrics. Split by route first, prefetch likely next routes, and do not lazy-load content that is visible on first paint. 

Interview tip: Mention that Suspense fallbacks should reserve space to avoid layout shift. 

Q115. How do you optimize large lists and data-heavy React interfaces? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

Virtualise so only visible rows exist in the DOM (TanStack Virtual or react-window), paginate and filter on the server, keep row components cheap and keys stable, and use useDeferredValue for heavy filtering. Move heavy computation to a Web Worker. Check bundle size with an analyser and confirm compression and caching headers on the network side. 

Interview tip: Virtualisation is the big win. Memoisation alone rarely rescues a 10,000-row table.

 

10. Important React 19 and Modern React Interview Questions

Modern React is where many candidates lose points by overclaiming. The safest approach is to say whether a feature is stable, framework-dependent or opt-in. As of this update the current release line is React 19.3, published in September 2026. 

Questions: 5 

 

Difficulty: Intermediate to Advanced 

 

Level: Mid-level to Senior 

 

Q116. What are the key React 19 features? 

INTERMEDIATE | MID-LEVEL / 2-4 YEARS 

React 19 made Actions (async transitions with pending, error and optimistic state) a core idea, alongside useActionState, useOptimistic, the use API, ref as a regular prop, <Context> as a provider, built-in document metadata tags and better error reporting. React 19.2 added <Activity> and useEffectEvent, and React 19.3 made <ViewTransition> and Fragment Refs stable. 

Interview tip: Group features by theme (forms and async, performance, DOM) rather than reciting a list. 

Q117. How do Actions, useActionState, useOptimistic and useFormStatus work together? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

An Action is an async function passed to <form action> or run in a transition. useActionState tracks its result and pending state, useOptimistic shows an instant temporary value while it runs, and useFormStatus (from react-dom) lets a child button read its parent form’s status.

Interview tip: Explain that saveName could be a client function or a Server Function. Actions work in either setup. 

Q118. What is the use API in React? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

use reads a Promise or a Context during render. With a Promise, the component suspends until it resolves. Unlike other Hooks it can be called conditionally, but not inside try/catch. The Promise should come from a cache or a Server Component, because creating one during a Client Component render makes a new Promise every time. 

Interview tip: The new-Promise-per-render warning is exactly what experienced interviewers probe. 

Q119. What is the React Compiler? 

ADVANCED | EXPERIENCED / 4-7 YEARS 

React Compiler is a build-time tool that automatically memoises components and Hooks when your code follows the Rules of React. It reached 1.0 in October 2025 and is opt-in through a build plugin. It reduces the need for manual useMemo, useCallback and memo, but it does not fix slow algorithms, oversized lists or network problems. 

Interview tip: Never say it “makes React fast automatically”. Say it removes a class of manual memoisation. 

Q120. Which modern React features are stable, framework-dependent or opt-in? 

EXPERT | SENIOR / 7+ YEARS 

Features differ by setup, so always check your version and framework. A reliable summary: 

Feature Status What it depends on
Actions, useActionState, useOptimistic, use Stable in React 19 Any React 19 app (Server Functions need a framework)
Server Components and Server Functions Stable, architecture dependent Framework or bundler integration, such as Next.js App Router
React Compiler Stable 1.0, opt-in A build tool plugin and code that follows the Rules of React
Activity and useEffectEvent Stable since 19.2 React 19.2 or later
ViewTransition and Fragment Refs Stable since 19.3 React 19.3 or later; ViewTransition works in the DOM only
Streaming and Suspense on the server Stable A server rendering setup, usually through a framework

 

How to Prepare for a React Developer Interview in 2026

Preparation works best when it matches your level. Use the checklist for your stage, then follow the four-week plan. 

Freshers 

  • JavaScript fundamentals: closures, this, promises, array methods, destructuring 
  • JSX, components, props and state 
  • useState, useEffect and keys 
  • Two or three small coding exercises you can finish without help 

Experienced developers 

  • State management and API integration, including loading and error states 
  • Routing, forms and authentication flows 
  • Performance profiling, testing and debugging stories from real projects 
  • React 19 basics: Actions, use, Server Components at concept level 

Senior engineers 

  • Application architecture, security and scalability trade-offs 
  • Performance profiling with real metrics 
  • System design for frontend: caching, rendering strategy, error handling 
  • Mentoring, code review and technical decision-making examples 
Week Focus Practice
Week 1 JavaScript and React fundamentals Sections 1 and 2, plus coding challenges 1, 2 and 10
Week 2 Hooks and data fetching Section 3 and 4, plus challenges 4, 6 and 13
Week 3 Rendering, performance and React 19 Sections 5, 9 and 10, plus challenges 7, 8 and 15
Week 4 Scenarios, architecture and mock rounds Sections 6 and 8, and a timed mock interview out loud

 

Conclusion

Strong React interview questions are never really about memorised definitions. Freshers win by explaining fundamentals clearly. Experienced developers win by showing how they build, debug and optimise real features. Senior engineers win by making sound architectural decisions and explaining the trade-offs. In all three cases, understanding modern React, including what is stable, what needs a framework and what is opt-in, beats reciting answers. 

Practise by coding, then explain your reasoning out loud. That habit is what turns a good answer into a convincing one. 

If you are on the other side of the table, the same standards apply when you build a team. You can hire React.js developers with a clear evaluation approach, read how to hire ReactJS developers in India for cost and skills context, or compare the best websites to hire React developers. 

Building a product with React? 

HireDeveloper.dev (Talent Wing of Rightbyte Technologies Pvt Ltd) supports businesses with experienced React.js developers, dedicated frontend developers and remote React development teams, along with React and Node.js development and IT staff augmentation. Hire dedicated React.js developers and tell us what you are building.