React interview guide

React interview preparation for senior frontend engineers

Senior React interviews test whether you understand rendering and state well enough to build reliable products—not whether you can recite every hook. Prepare to diagnose behaviour, place state deliberately, design clear boundaries and justify performance work with evidence.

Start Free Assessment

20 questions • Free to start • No credit card

What interviewers assess

What strong answers demonstrate

  • →Explain what causes rendering and how identity affects reconciliation and memoisation.
  • →Place local, shared, server and URL state according to ownership and lifetime.
  • →Use effects for external synchronisation rather than ordinary data derivation.
  • →Design accessible, testable components and measure performance before optimising.
Core preparation

Topics to understand and explain

Rendering and reconciliation

Know why a component renders, how React compares trees and why stable keys preserve the right state. Separate render work from browser painting and avoid describing every render as a DOM update.

  • ✓Render triggers
  • ✓Element identity and keys
  • ✓State preservation and reset
  • ✓Pure rendering

State ownership and data flow

Keep state near the components that own it and lift it only when coordination requires it. Treat remote data, form state, URL state and application state as different problems.

  • ✓Single source of truth
  • ✓Derived versus stored state
  • ✓Context boundaries
  • ✓Server-state caching

Effects and external systems

Effects are for synchronising with systems outside React, such as subscriptions or browser APIs. Explain cleanup, dependency correctness and race prevention without suppressing warnings by default.

  • ✓When an effect is unnecessary
  • ✓Cleanup and subscriptions
  • ✓Stale closures
  • ✓Network cancellation

Performance with evidence

Use the profiler and user measurements to locate expensive work. Memoisation has a maintenance cost, so apply it where stable inputs and avoided work produce a meaningful benefit.

  • ✓Profiler-led diagnosis
  • ✓Memoisation trade-offs
  • ✓List virtualisation
  • ✓Code splitting and streaming

Component and application architecture

Prefer explicit contracts, composition and accessible primitives. For larger systems, explain feature boundaries, data access, error handling, testing and how teams can evolve the code safely.

  • ✓Composition over excessive configuration
  • ✓Accessible interaction patterns
  • ✓Error and loading boundaries
  • ✓Testing behaviour over implementation
Practice prompts

Questions worth rehearsing

Practise explaining the decision, its trade-offs and how you would verify the result—not a memorised definition.

01

Why does using an array index as a key sometimes show the wrong row state?

A strong approach: Explain that keys identify items across renders; insertions or reordering can make state follow a position instead of the intended item.

02

A component fetches data in an effect and shows stale results. What would you change?

A strong approach: Identify the request race, cancel or identify stale work, and consider a server-state library for caching and lifecycle handling.

03

When should state move into context?

A strong approach: Use shared ownership and update frequency, not convenience alone; compare context with composition, colocated state and dedicated stores.

04

A large list feels slow while typing. How would you diagnose it?

A strong approach: Profile interaction, identify expensive renders or computation, then consider state isolation, deferred work, memoisation or virtualisation.

Preparation plan

A practical way to prepare

  1. STEP 1

    Master render reasoning

    Practise tracing props, state, keys and effects through small changes. Say exactly what re-renders and what state is preserved.

  2. STEP 2

    Refactor common mistakes

    Remove unnecessary effects, duplicated derived state, unstable list keys and broad context updates from sample components.

  3. STEP 3

    Design feature boundaries

    Sketch a search, checkout or dashboard feature with routes, data ownership, loading, errors, accessibility and tests.

  4. STEP 4

    Use the profiler

    Measure one slow interaction and explain the evidence, proposed change and verification method.

Common mistakes

What weakens an otherwise good answer

Treating every value as state

Derived values should usually be calculated during rendering instead of synchronised through another effect.

Using memoisation everywhere

Memoisation adds complexity and only helps when it avoids meaningful repeated work with stable inputs.

Ignoring effect cleanup

Subscriptions, timers and requests need explicit lifetime handling to prevent stale work and leaks.

Discussing React without users

Connect architecture and performance choices to accessibility, feedback, resilience and observable experience.

Measure your readiness

Turn preparation into a clear improvement plan

Choose React in InterviewGround to check your understanding across rendering, state, effects, performance and application design. Choice questions are scored immediately, while written answers receive concise technical feedback and a senior-level model answer.

Your report highlights readiness, demonstrated seniority for that assessment, strongest and weakest topics, and recommended resources. It is a practice signal—not a hiring decision or a permanent label.

Start Free Assessment
Continue preparing

Related interview guides

Back to InterviewGround