React

Arrow functions, destructuring, spread/rest, template literals, modules (import/export), and promises — the JS features React code relies on daily.

How JSX translates to function calls, what the virtual DOM is, and how React's reconciliation decides what to re-render.

Setting up a React project with Vite or Create React App, understanding the dev server, hot module replacement, and project structure conventions.

You can create a new React project, understand JSX syntax, and are comfortable with the modern JS features React uses.

Functional components, passing data via props, prop types, default props, and the mental model of components as pure functions of their props.

Rendering content conditionally with ternaries and logical operators, rendering arrays with map(), and why keys matter for reconciliation.

Handling user interactions with event handlers, controlled vs uncontrolled form inputs, and form submission patterns.

Using the children prop, composing components together, and thinking in terms of component trees rather than inheritance.

You can build interactive UIs with multiple components, handle user input, and render dynamic content.

Declaring local state, understanding immutability requirements, batched updates, and functional updater patterns for state that depends on previous state.

Running side effects after render, the dependency array, cleanup functions, and common pitfalls like stale closures and infinite loops.

Persisting mutable values across renders without causing re-renders, accessing DOM nodes directly, and when refs are the right tool vs. state.

Extracting reusable stateful logic into custom hooks, naming conventions, and how custom hooks compose to build complex behaviors from simple pieces.

Managing complex state transitions with reducer functions, when useReducer is preferable to useState, and the dispatch pattern.

You can manage component state, handle side effects cleanly, and extract reusable logic into custom hooks.

Sharing state across the component tree without prop drilling, creating providers and consumers, and understanding when context is appropriate vs. overkill.

Two classic patterns for sharing behavior between components — how they work, when they're still useful, and how hooks have largely replaced them.

Building flexible component APIs where multiple components work together implicitly, like a Tabs component with Tab and TabPanel children.

Catching rendering errors gracefully so a broken component doesn't crash the entire app, and designing fallback UIs for error states.

You understand advanced component design patterns and can architect flexible, reusable component APIs.

Deciding where state should live in the component tree, lifting state up to shared ancestors, and recognizing when local state is sufficient vs. when you need something more.

Centralized state management with a single store, actions, reducers, and selectors — using Redux Toolkit to eliminate boilerplate and enforce best practices.

Simpler alternatives to Redux for state management — when a lightweight store is the right choice and how these libraries reduce ceremony.

Treating server data as a separate category of state, with caching, background refetching, optimistic updates, and automatic invalidation.

You can choose and implement the right state management approach for different scales of application complexity.

Declarative routing with React Router — defining routes, nested layouts, URL parameters, programmatic navigation, and route-based code splitting.

Loading data in components with useEffect, Suspense for data fetching, loading and error states, and avoiding race conditions in async operations.

Using Suspense boundaries to orchestrate loading states, useTransition for non-urgent updates, and how these primitives improve perceived performance.

You can build multi-page apps with clean data loading, graceful loading states, and smooth transitions.

Memoizing components and computed values to skip unnecessary re-renders — and more importantly, knowing when NOT to optimize prematurely.

Splitting your bundle with React.lazy and dynamic imports so users only download the code they need, reducing initial load time.

Using React DevTools to inspect the component tree, the Profiler to identify re-render bottlenecks, and Chrome DevTools for runtime performance analysis.

You can identify and fix performance bottlenecks, implement code splitting, and make informed memoization decisions.

Writing user-centric tests that query the DOM the way users interact with it — rendering components, simulating events, and asserting outcomes.

Testing complete user flows with tools like Playwright or Cypress, and strategies for deciding what to test at each level of the testing pyramid.

You can write meaningful tests for React components and user flows with confidence.

Server-side rendering, static generation, API routes, and file-based routing — understanding why frameworks like Next.js exist and what problems they solve.

The server/client component model, when to use each, how data flows between them, and how RSCs change the way you think about React architecture.

Typing props, state, hooks, events, and refs — leveraging TypeScript to catch bugs at compile time and improve the developer experience with autocompletion.

Building inclusive UIs with semantic HTML, ARIA attributes, keyboard navigation, focus management, and screen reader testing.

Production builds, environment variables, deployment to platforms like Vercel or Netlify, CI/CD pipelines, and monitoring in production.

You have a deep, practical understanding of React and its ecosystem — from fundamentals to production-grade applications.