React interview questions

Rendering, the central topic

• Why did this component re-render? State changed, props changed, parent re-rendered, or context value changed - and knowing you can confirm it with the profiler rather than guessing.
• Why does passing an inline arrow or object literal as a prop defeat memoisation? A new reference every render.
• What does `React.memo` do, and when is it useless? When the props are new references anyway.
• Keys in lists - what goes wrong with an array index as the key when items reorder or are removed.
• What is reconciliation doing at a high level?

Hooks

• The dependency array. What it compares (reference equality), what happens when you omit it, and what breaks when you lie about it.
• `useEffect` cleanup - when it runs, and the classic subscription or timer leak when you omit it.
• `useMemo` versus `useCallback` - and the honest point that both are optimisations with a cost, not defaults.
• `useState` versus `useReducer`, and the point at which related state should move to a reducer.
• `useRef` for mutable values that should not trigger a render.
• The rules of hooks, and the actual reason - hooks are matched by call order.

State and data

• When is context the wrong tool? When the value changes often - every consumer re-renders.
• How do you handle server state - loading, error, caching, refetching - and why that is a different problem from UI state.
• Controlled versus uncontrolled inputs, and when uncontrolled is genuinely better.
• How would you lift state up, and when does that become prop drilling worth solving differently?

If the role uses a framework

For a Next.js-style role, expect server components versus client components at a high level, where data fetching belongs, and what hydration is. You are not expected to have memorised the API surface - you are expected to know which code runs where. The live build round is covered in frontend interview questions.

How deep it goes by level

• Junior: the fundamentals above, explained clearly. Nobody expects production scars yet, and honesty about what you have not done reads better than bluffing.
• Mid-level: the same ground, plus a component you are proud of. Expect follow-ups asking why you made a particular choice rather than whether you know the syntax.
• Senior: a performance problem you measured and fixed, and how you structure a growing codebase. At this level the language questions get shorter and the judgement questions get longer.

Whatever the level, the reliable way to prepare is to say your answers out loud rather than reading them. Most of what candidates lose in a React interview is lost in the gap between knowing something and explaining it under observation - the method is in how to use AI for interview prep.

Where CoPilot Interview fits

Disclosure: we build an interview assistant, so treat this as a disclosed pitch. CoPilot Interview is a native Windows and macOS app that puts suggested answers on your own screen in about two seconds, across coding, system design and behavioral rounds, with a permanent free tier that needs no credit card.

Frequently asked questions

What are the most common React interview questions?

Why a component re-rendered and how to confirm it, what the `useEffect` dependency array compares, `useMemo` versus `useCallback`, why index keys break reordering lists, and when context is the wrong tool for state.

Why does my React component re-render too often?

Usually because a parent re-rendered, or because a prop is a new reference each render - an inline arrow function or object literal defeats `React.memo`. The strong interview answer names the Profiler as the way to confirm which it is rather than guessing.

When should you not use context in React?

When the value changes frequently, because every consumer re-renders when the context value changes. Context suits relatively static values such as theme, locale or the current user rather than fast-changing state.

Do React interviews still ask about lifecycle methods?

Rarely, unless the codebase is older and class-based. Modern loops focus on hooks, the dependency array and rendering behaviour, which is where the practical bugs actually come from.