Requests, responses, methods, status codes, and how TLS protects them in transit.

How human-readable names become IP addresses your browser can actually reach.

The pipeline from HTML parsing to the DOM, CSSOM, render tree, layout, and paint.

Where your code lives and how content delivery networks make it fast for users worldwide.

Doctype, head, body, meta tags, character encoding, and the viewport meta for mobile.

header, nav, main, article, section, aside, footer, and figure communicate meaning, not just style.

All the input types, labels, fieldsets, and built-in validation that the platform gives you for free.

img alt text, picture and srcset for responsive images, video and audio elements, and inline SVG.

Type, class, id, attribute, and pseudo selectors plus the specificity rules that decide who wins.

Content, padding, border, margin, and the difference between content-box and border-box sizing.

Hex, rgb, hsl, oklch, rem/em/px/percentages, and CSS variables for theming.

How the cascade resolves conflicts and which properties are inherited from parent to child.

One-dimensional layout: alignment, distribution, wrapping, and order.

Two-dimensional layout: grid templates, areas, auto-fit and auto-fill, and where it beats flex.

Adapt layouts to screen size, orientation, color scheme (dark mode), and reduced motion preferences.

Design and code for small screens first, then progressively enhance for larger viewports.

Style components based on their container size rather than the viewport.

var, let, const, primitive vs reference types, block vs function scope, and hoisting.

Function declarations vs arrow functions, the this keyword, and how closures capture variables.

Common methods (map, filter, reduce, find), spread/rest, and immutable update patterns.

if/else, switch, for/for-of/for-in, while, and when each loop is the right tool.

Destructuring, template literals, default parameters, optional chaining, nullish coalescing, and ES modules.

querySelector, createElement, appendChild, classList, and modifying attributes safely.

addEventListener, bubbling vs capturing, and delegating to a common ancestor for dynamic elements.

Make HTTP requests with fetch, handle responses, errors, and AbortController for cancellation.

Write asynchronous code that reads top-to-bottom instead of nested .then chains.

When to use each, their size limits, expiry behavior, and security implications.

init, clone, status, add, commit, push, pull, and reading the log.

Create branches, switch between them, merge changes, and resolve simple conflicts.

Fork, pull requests, code review, issues, and protected branches in a team setting.

When to rewrite history with rebase, when to preserve it with merge, and what never to rebase.

Installing dependencies, semver ranges, scripts, devDependencies vs dependencies, and lockfiles.

Faster alternatives to npm with disk-efficient stores and workspaces for monorepos.

The default modern dev server and bundler: instant HMR, native ESM in dev, Rollup for production.

What webpack, Rollup, esbuild, and Turbopack actually do and why bundling exists.

ESLint catches bugs, Prettier kills bikeshedding. Run both in pre-commit hooks and CI.

Functional components, JSX syntax, and how it compiles to plain JavaScript.

Pass data down with props, compose small components into bigger ones, and avoid deep prop drilling.

Manage local state with useState; subscribe to external systems and run side effects with useEffect.

Render based on state, map over arrays with stable keys, and avoid common rendering bugs.

Know enough about each to pick the right one for a project or a job market.

Start with useState in the component that owns the data; lift state up only when siblings need it.

Pass values to deeply nested components without prop drilling, plus the re-render trade-offs.

When the Context API stops scaling, reach for a small store. Know one well.

Server state belongs in a data-fetching library; URL state belongs in the URL; not everything is global.

Map URLs to components with React Router, TanStack Router, or your framework router; handle nested routes.

Read, parse, and design against REST endpoints; understand status codes, methods, and pagination.

Query exactly what you need from a single endpoint; learn enough to read schemas and write basic queries.

TanStack Query and SWR handle caching, deduping, retries, and revalidation so you stop reinventing them.

Know the difference between data the server already has and ephemeral UI state. They want different tools.

Plain CSS works fine for small apps; CSS Modules add automatic class scoping with zero runtime.

A utility-first framework that ships small bundles and keeps styles co-located with markup.

Styled Components, Emotion, and the runtime trade-offs. Increasingly being replaced by Tailwind or vanilla CSS.

Use CSS variables for colors, spacing, and typography so themes and dark mode are one switch away.

Primitives, arrays, objects, interfaces vs types, unions, and literal types.

Function components, props interfaces, children, event handlers, and refs typed correctly.

Partial, Pick, Omit, Record, ReturnType, and writing your own generic helpers.

Turn on strict, noUncheckedIndexedAccess, and exactOptionalPropertyTypes early to avoid pain later.

Test pure functions, hooks, and small modules in isolation. Fast and run in milliseconds.

Render components and assert on what the user sees, not on implementation details.

Drive a real browser through real flows: sign in, add to cart, checkout. Slowest but highest signal.

Tools like Chromatic and Percy catch unintended UI changes by diffing screenshots.

Largest Contentful Paint (load), Interaction to Next Paint (responsiveness), Cumulative Layout Shift (stability).

Ship less JavaScript up front with dynamic import, React.lazy, and route-based splitting.

Modern formats (AVIF, WebP), responsive srcset, width and height to prevent CLS, lazy loading.

Cache-Control headers, immutable assets, and how newer HTTP versions reduce round trips.

Measure with Lighthouse in DevTools and the web-vitals library; track real-user metrics in production.

The right element for the right job removes most accessibility bugs before you write any ARIA.

Every interaction must work without a mouse. Manage focus deliberately on route changes and in modals.

The first rule of ARIA is do not use ARIA when a native element will do the job.

Hit WCAG AA contrast ratios, label every input, and pair errors with the field they describe.

Try VoiceOver on macOS or NVDA on Windows. Five minutes a feature catches issues automated tools miss.

A small JSON file that lets users install your site to the home screen with an icon and start URL.

A scriptable network proxy that runs even when the page is closed; powers offline support and push.

Re-engage users with the Push API and a service worker that handles notification events.

Google's library that wraps service worker caching strategies into a few lines of config.

Vercel, Netlify, Cloudflare Pages, and GitHub Pages host SPA and SSG sites with a single git push.

Run lint, tests, and a production build on every PR; fail fast before code reaches main.

A unique URL for every PR so reviewers click around the change in a real environment before merge.

Keep API keys out of the bundle and out of git history; use platform-managed secrets per environment.

Sentry, Datadog, or Better Stack catch production errors and real-user performance issues.