Two slots open this quarter Pune, India / 13:00 to 22:00 IST React and Node only Book a 30 minute call
reactdevstudio
Contact Book a call
Work Hire React developers Hire Node developers Node services Offshore development Blog About Contact
Book a 30 minute call
Home/Blog/React interview questions that actually work
react / testing 13 min read Updated September 2026

React interview questions that actually work

Four questions taken from real client code, twelve more sorted by level, what a good answer sounds like, and why the trivia questions everyone asks predict almost nothing.

Post author

Yogesh Jadhav

Founder, reactdevstudio · Pune

The standard React interview asks what the virtual DOM is, what a key does, and the difference between state and props. Every candidate who has read a blog post answers all three, which means the questions sort nobody. These four are harder to prepare for because they are drawn from code that actually shipped, and because the interesting part of each is a judgement rather than a fact.

React is common enough that the standard questions are everywhere. In the Stack Overflow Developer Survey 2025, 44.7% of all respondents said they had done extensive work with React over the past year, and so had 46.9% of professional developers. Every one of those people has seen the virtual DOM question. Most have a rehearsed answer.

The short version

Ask about code that exists, not concepts. Concepts are memorised; judgement is not.

The best signal in any answer is a stated assumption, not a correct conclusion.

Let candidates use documentation and an assistant. You are hiring for the job, and the job has both.

Score how they handle not knowing. It predicts more than anything they do know.

Trivia questions have a false-negative problem: good engineers fail them and it tells you nothing.

Why the usual questions fail

Trivia questions have two failure modes and both are expensive. They produce false positives, because the answers are memorable and widely published, so a weak candidate who prepared looks strong. And they produce false negatives, because a strong engineer who has not thought about reconciliation internals in three years fumbles a definition while being entirely capable of the work.

The deeper problem is that they test recall of how React works, when the job is judgement about what to do with a codebase. Those correlate far less than interviewers assume. The most productive React engineers we have worked with would give mediocre answers to a virtual DOM question and excellent answers to all four below.

There is also evidence that the format itself distorts the result. A randomised trial presented at ESEC/FSE 2020, Does Stress Impact Technical Interview Performance?, put 48 computer science students through the same problem either at a whiteboard in front of an interviewer or alone in a private room. Performance was reduced by more than half simply by being watched. A live whiteboard session partly measures how someone copes with an audience, which is rarely the job.

"A question that every prepared candidate answers correctly is not an interview question. It is a formality with a scoring column attached."

These four sit inside a longer process, described stage by stage in how to hire React developers.

The four questions

Each is presented as a short extract of real code, and the candidate is asked to fix it and explain. What follows is what each one is actually testing.

The four, as sent

01 This component re-renders on every keystroke and drops frames. Find why, fix it, and say what you would measure to prove the fix worked.
02 This hook fetches on mount and leaks when the component unmounts mid-request. Describe every way it fails in production, then fix it.
03 These two components need the same server state. Show how you would share it, and what you would do differently at ten components.
04 This form has validation in four places. Restructure it, and tell us what you deliberately did not change and why.

What each one is really testing

One Whether they measure before optimising. The trap is that the obvious fix, memoising everything, makes it slower and they should say so.
Two Whether they think about time. Races, unmounts, slow networks, the second request arriving before the first. Most candidates fix only the warning.
Three Whether they can see past the immediate ask to the shape at scale, without building it now.
Four Scope discipline. The strong answer changes less than the weak one and can defend every omission.

If you are assessing an engineer proposed by a vendor rather than a direct hire, ask to run your own format; when teams hire remote React developers from us, we expect exactly that. The company behind the engineer needs judging too, and what to check before hiring a React development agency goes through it.

What good and bad sound like

The gap between these is not knowledge. In most cases both candidates know the same APIs, and what differs is whether they reason about the situation or pattern-match to a remembered fix.

QuestionStrongWeak

Re-renders

Profiles first, finds the object recreated inline, fixes that, notes that memo here would cost more than it saves.

Wraps everything in memo and useCallback and declares it faster.

The leaking hook

Lists unmount, race between responses, error path, double-invoke in strict mode. Uses an abort signal.

Adds an isMounted flag and stops, treating the console warning as the bug.

Shared state

Asks what the data is first. Server cache and client state are different problems with different tools.

Reaches for global state immediately, at two components.

The form

Consolidates validation in one place, leaves the submit handler alone, says why.

Rewrites the component, introduces a form library, changes the API shape.

The second row is the one that separates most reliably. Nearly every candidate fixes the warning. A much smaller number ask what happens when the user navigates away and back before the first request resolves, which is the bug that actually reaches production.

The third question is really about cost: the difference between a considered answer and a reflexive one shows up later as rework, which is the largest hidden line in what React development costs.

Running the interview well

Give the code in advance

Twenty minutes to read before the call. You are testing reasoning, not reading speed under observation.

Allow every tool

Documentation, search, an assistant. Ask them to say where they used one. The job has all of them.

Stay quiet

The first ten minutes are the signal. An interviewer who hints is assessing themselves.

Where our interests differ from yours

We publish these, so any candidate we send you could have read them. That weakens them for us and is the price of showing our working. If you use them, change the codebase they sit on and add one question from your own history. The local one will always outperform ours.

One more rule worth adopting: ask every candidate the same questions in the same order, and write the score before discussing it with anyone else. Interview panels converge on the first opinion voiced, and the cost is that you end up with one person's judgement wearing the whole panel's confidence.

It is also one of the better supported findings in hiring research. Schmidt and Hunter reviewed 85 years of selection studies in Psychological Bulletin in 1998 and put the average validity of structured interviews at .51, against .38 for unstructured ones. Same questions, same order and a score written down before the debrief are most of what "structured" means in practice.

Framework preference is not a signal in an interview, but it is a real decision for a project, and React or Next.js weighs it separately.

Twelve more React interview questions, by level

The four above are the core. People looking for React developer interview questions usually want a longer list, and a longer list is useful as long as each question is asked about code rather than in the abstract. These are the ones we reach for when a candidate finishes early or when the role needs a specific skill checked. Pick two or three for the level you are hiring. Never all twelve.

LevelQuestionA good answer covers

Junior

This list flickers and loses input focus when an item is added. What is wrong with the keys?

Index keys, why React reuses the wrong element, and what a stable key would be for this data.

Junior

This effect runs twice in development. Is that a bug?

Strict mode remounting on purpose, what it is catching, and why the effect needs a cleanup rather than a flag.

Junior

Where should the value of this search box live, and who needs to know about it?

Local state first, lifting it only when a sibling needs it, and why a URL parameter is sometimes the right home.

Junior

This button submits the form twice on a slow connection. Fix it.

Disabling while pending, and why the server should still reject a duplicate.

Mid

This page fetches the same user record in five components. What would you change?

A cache for server state, request deduplication, and not reaching for global client state to solve it.

Mid

The bundle for this route is 900KB. Where would you look first?

Reading the build output, route level splitting, heavy dependencies, and checking what actually ships.

Mid

Write a test for this component that will still pass after a refactor.

Testing behaviour through what the user sees, not internal state or implementation details.

Mid

This modal is unusable with a keyboard. What is missing?

Focus moving in and back out, Escape to close, and a label a screen reader can announce.

Senior

Half this app should render on the server. Which half, and why?

Pages that need to be indexed or fast on first load, against screens behind a login that do not.

Senior

Two teams keep breaking each other’s screens. How would you structure the codebase?

Ownership boundaries, a shared component contract, and what not to share.

Senior

The API returns shapes the UI does not want. Do you fix it in the client or the server?

Who owns the contract, the cost of a translation layer, and shared TypeScript types across the boundary.

Senior

We are moving off class components. What order would you migrate in?

Leaving stable code alone, migrating where work is already happening, and how to prove nothing regressed.

The senior rows lean away from React itself and towards the edges where React meets a server, a second team or an old codebase. That is deliberate. It is where senior engineers spend their week. The server rendering question overlaps with React or Next.js and with our guide to React SEO, and the API contract question is the boundary described in React vs Node.js. A candidate who answers those two well is often the person you want owning both sides of it.

What to weight, and what to ignore

Weight: stated assumptions

"I assumed the API cannot be changed. If it can, I would do this instead." The most predictive sentence available.

Weight: measuring

Any mention of a profiler, a metric or a test to confirm the fix. Rare, and strongly associated with people who ship well.

Weight: saying "I do not know"

Followed by how they would find out. It is the behaviour you want on day one of a real codebase.

Ignore: framework fashion

Preferring a different state library is not a signal. Being unable to work in yours would be, and that is a different question.

Ignore: speed

Interview speed measures interview practice. Nobody ships at interview pace and you would not want them to.

Ignore: perfect syntax

Nobody writes without an editor. Judge the shape of the solution, not whether a bracket is missing.

Measuring rather than asserting is the same discipline a performance budget enforces at the project level.

Questions we stopped asking, and why

Each of these was in our set at some point. Each was removed after we noticed it was either failing people we later wished we had hired, or passing people we later replaced.

QuestionWhy it wentReplaced by

Explain the virtual DOM

Every prepared candidate answers it and several excellent engineers fumbled it. It sorted for recent reading, not skill.

The re-render question, which requires the same understanding applied to code.

Implement a debounce from scratch

A memory test with a known answer. Everyone who had seen it passed; everyone who had not was penalised for nothing.

Watching them use one correctly in the re-render question.

What is the difference between state and props?

Answerable from a tutorial read the night before. It carried no information at any seniority.

Nothing. The slot was better spent elsewhere.

Design a component library, whiteboard

Tested confidence and presentation. The strongest answers came from people who talked well, which is not the job.

The form restructuring question, done in code.

The pattern across all four: each rewarded preparation or performance rather than judgement. That is the test to apply to any question you are considering. Ask whether a mediocre engineer who spent an evening revising could answer it as well as a strong one who did not. If yes, it is not earning its place.

We also retired one habit rather than a question: asking follow-ups until the candidate failed. It feels like calibration and it is actually a guaranteed way to end every interview on a failure, which distorts both the candidate's performance and the interviewer's memory of it. Now we stop at the point where the answer is good enough for the work.

Interviews are a sample, not a proof. A two week paid pilot is the only part of the process that produces evidence rather than impressions.

Questions people ask

+Should we still ask about hooks rules or the dependency array?

Only as it arises inside a real problem. Asked directly it is trivia; observed while someone fixes the leaking hook it is genuinely informative, because you see whether they understand why the rule exists rather than that it does.

+How long should the technical interview be?

Ninety minutes, once, with the code sent in advance. Multi-round technical loops mostly measure who can afford the time, and by round three you are re-testing the same thing with more people watching.

+What if a candidate uses an AI assistant well?

That is a positive signal, not a negative one, provided they can defend the output. Ask them why the suggested approach is right, and what they would have done differently. Someone who cannot answer that has told you what you needed to know.

+Do these work for mid-level candidates?

Yes, with different expectations. A mid-level engineer should fix all four correctly. A senior one should also tell you which fix is not worth making, and why. The questions do not change; the bar for the fourth answer does.

+What are the most common React interview questions?

The virtual DOM, keys, state against props, the rules of hooks and the dependency array. They are common because they are easy to ask, and that is the trouble: they are just as easy to prepare for. Ask about the same ideas inside real code, as in the table of twelve above, and you learn far more from the same half hour.

+Should a React interview include Node.js questions?

Only if the role touches the server. For a frontend role, one question about the API contract is enough. If you are hiring one person to cover both, read React vs Node.js first, because the answer changes who you should be interviewing.

Where to go next

These four sit inside a larger process, described in how to hire React developers along with the vetting stages and the replacement terms behind them. Cost is a separate question: what React development costs has the drivers for a project and what it costs to hire a React developer the numbers per engineer, and teams who hire a React developer in India from us get the same process, in writing. Whatever set you use, change a question every few months, because published questions stop sorting anyone.

Sources

Post author

Yogesh Jadhav

Founder of reactdevstudio. Ten years as a working full stack developer, across SaaS products and client work.

Related, Group B only

Three more on engineering

Engineering posts only, scored within Group B, so a technical reader is never handed a procurement checklist.

react / hiring 14 min

How to hire React developers, the process written out

cost / hiring 12 min

How much it costs to hire a React developer

cost / react 11 min

What React development costs, and what moves the number

Two slots open this quarter.

Send the ticket you would hand over first. You get a written approach in two working days.

Book a 30 minute call

Interview whoever would write the code, in your own format.