Understand React well enough to explain it.

How React calculates changes and applies them to the host environment.

Initial renders, state updates, parent renders, context, and external stores.

How type, position, and identity influence reuse of component trees.

Stable identity, reordering, state preservation, and common key mistakes.

Why each render sees a fixed state value and event handlers capture it.

How tree position preserves state and how to reset it intentionally.

Queued updates, automatic batching, updater functions, and update order.

Grouping related values, avoiding contradictions, and normalizing state.

Calculate during rendering instead of synchronizing duplicate values.

Call-order identity, top-level calls, and why the rules exist.

Captured values, stale closures, event handlers, and safe updates.

Effects as a bridge to external systems rather than lifecycle callbacks.

Reactive dependencies, teardown, race conditions, and idempotence.

Persisting non-rendering values and interacting with DOM nodes.

Explicit transitions, complex state, actions, and reducer tradeoffs.

Extracting reusable behavior without hiding ownership or data flow.

Finding the closest common owner and preserving a single source of truth.

External control, local ownership, defaults, and reset behavior.

Children, slots, render APIs, and avoiding boolean-prop explosions.

Constraints, defaults, escape hatches, and semantic contracts.

Shared state, flexible markup, and accessible behavior primitives.

Provider boundaries, stable values, defaults, and dependency visibility.

Render failures, recovery boundaries, fallbacks, and their limitations.

Semantics, focus, keyboard behavior, announcements, and testing.

Render causes, profiling, state placement, and measurement discipline.

Object identity, dependency comparisons, props, and cascading work.

What each tool caches, when it helps, and when it adds noise.

Consumer fan-out, provider splitting, selectors, and stable values.

Route and component boundaries, Suspense fallbacks, and loading cost.

Windowing large collections while preserving usability and accessibility.

Profiler traces, render duration, commits, and validating improvements.

Urgent versus non-urgent work and keeping interactions responsive.

Rendering locations, navigation behavior, tradeoffs, and hybrid applications.

Attaching behavior to server HTML, mismatches, cost, and selective hydration.

Server and client boundaries, serialization, composition, and data access.

Coordinated fallbacks, progressive delivery, and boundary placement.

Ownership, waterfalls, caching, deduplication, and framework integration.

Pending state, rollback, reconciliation, and failure handling.

Form state, validation, submissions, progressive enhancement, and actions.

Local state, context, external stores, server state, and URL state.

Queries, interactions, outcomes, and avoiding implementation coupling.

Choosing the smallest test that provides meaningful confidence.

Waiting for outcomes, timers, requests, race conditions, and false confidence.

Development checks, repeated setup and cleanup, and purity expectations.

Stale responses, Effect cleanup, AbortController, and request ownership.

Explicit async states, resilient transitions, and accessible feedback.

Tracing renders, state changes, Effects, warnings, and minimal reproductions.

Observability, recovery, defensive boundaries, and graceful degradation.