Why semantic HTML matters for accessibility, SEO, and maintainability, and how the browser parses a document.

Building interfaces usable by everyone — a frequent senior-level interview differentiator.

The mental model of CSS: how the browser decides what applies and how elements take up space.

One-dimensional layout — the workhorse of component-level layouts.

Two-dimensional layout for page-level structure.

Designing for every screen size with fluid layouts and media/container queries.

Custom properties, nesting, layers, and animation — modern CSS without preprocessors.

var/let/const, primitives vs reference types, and how values are stored and compared.

Operator behavior, precedence, and short-circuit evaluation.

Object creation, property access, mutation, copying, and iteration.

The array method toolbox — map/filter/reduce and friends, used daily and asked in every interview.

Functions that remember their lexical environment — the single most asked JS interview concept.

Functions that take or return functions — the foundation of JS patterns.

What happens when a function runs: creation phase, execution phase, and the stack of contexts.

How the browser coordinates the call stack, task queues, and rendering — asked in nearly every JS interview.

JavaScript's actual inheritance model underneath classes.

Class syntax, fields, private members, and how it maps to prototypes.

Selecting, creating, and updating DOM nodes efficiently.

The event lifecycle from capture to bubble, and delegation as the scaling pattern.

How V8 allocates and reclaims memory, and how leaks happen in real apps.

Rate-limiting event handlers — implement both from scratch (classic coding round).

Designing for failure: custom errors, global handlers, and async error boundaries.

XSS, CSRF, and the browser security model every frontend interview probes.

Type annotations, inference, and the compile-time/runtime boundary.

Interfaces, type aliases, optional/readonly members, and function signatures.

What JSX compiles to and how to design component boundaries.

The data model of React: immutable props down, state owned locally.

State and synchronization with external systems — including what effects are NOT for.

Mutable values that don't re-render, and imperatively touching the DOM.

The render → reconcile → commit pipeline and what triggers re-renders.

The diffing algorithm, element identity, and why keys change everything.

Client vs server state, colocation, and deriving instead of duplicating.

Store-based state: selectors, immutability, and Redux Toolkit vs Zustand trade-offs.

Preventing wasted renders with memo/useMemo/useCallback and the React Compiler context.

React DevTools Profiler and finding the actual bottleneck.

Compound components, render props, HOCs — and when composition beats them all.

Containing failures gracefully and rendering outside the tree.

Project structure and the special files that define behavior per route segment.

Dynamic segments, catch-alls, parallel and intercepting routes.

Fetching in server components, request memoization, and avoiding waterfalls.

The caching layers (request memoization, data cache, full route cache, router cache) and how to reason about staleness — a top Next.js interview question.

Image/font optimization, bundle analysis, and Core Web Vitals in Next.js.

Vercel vs self-hosted: Docker, standalone output, CDN and cache headers.

From HTML bytes to pixels: parsing, render tree, layout, paint, composite — the critical rendering path.

Requests, caching, and cookies from the browser's point of view.

Pattern matching every engineer needs — and the traps that take down production.

The newest language features worth knowing in interviews and code review.

Intersection, Resize, and Mutation observers — the engine behind lazy loading and responsive components.

The proxy in the browser: caching strategies, offline UX, and background sync.

Form actions and the new hook family that reshaped data mutations.

Automatic memoization: what the compiler does, the Rules of React it depends on, and when manual memo still matters.

A disciplined fetch layer: error normalization, retries, and cancellation.

Queries, fragments, and normalized caches with Apollo/urql.

Reliable end-to-end tests: selectors, fixtures, and flake control in CI.

Screenshot diffing and automated a11y checks as regression gates.

Tab order, focus traps, and roving tabindex — where most apps fail audits.

The APG patterns for menus, dialogs, tabs, and comboboxes done right.

Dev-server model, production bundling, and the esbuild/SWC/Rolldown landscape.

pnpm workspaces, Turborepo pipelines, and versioning shared packages.

The classic warm-up: debounce, caching, race conditions, and accessibility.

Virtualization, pagination, and prefetching for endless content.

ICU messages, the Intl API, RTL layouts, and locale routing.

Using AI tools well: scaffolding, refactoring, tests, and review — without shipping slop.

Streaming text, tool progress, and error recovery — the patterns of AI product frontends.

Understand how React Native differs from web React, how the JS bridge/runtime model works at a high level, and how to organize a mobile app project. This sets the foundation for discussing rendering, native modules, and app lifecycle trade-offs in interviews.