Full Stack Developer

Structure a document with the right elements — semantics are what make a page accessible and indexable, not decoration.

The cascade, specificity and the box model. Every confusing layout bug later traces back to one of these three.

Flexbox for one dimension, grid for two. Learn both properly and you stop fighting CSS.

Design mobile-first and let the layout grow. Most of your traffic is on a phone.

Branching, merging and reading history. Every job assumes this from day one.

Types, scope, closures and the array methods you will use hourly. React is this language, not an escape from it.

Select, change and listen without a library, so you know what a framework is doing for you.

Promises, async/await and the event loop — the model behind every network call you will ever write.

Call an HTTP API, handle the failure cases, and read the status code it sent back.

ES modules, npm and a bundler. Enough to understand your project rather than copy its config.

Types, interfaces and generics. Almost every job posting now assumes it, and it pays for itself on the first refactor.

Components, props and hooks. Build several small things before reaching for any library on top.

Local state first, then context, and a store only when you can name the problem it solves.

Multiple pages, loading and error states, and caching that does not go stale.

The messiest part of most real applications, and where usability is won or lost.

A utility framework or a component library, chosen once and applied consistently.

Next.js or similar: routing, server rendering and the build pipeline handled for you.

A server, routes and middleware. The JavaScript you already know, running somewhere else.

Methods, status codes and headers. Most API design arguments are really arguments about HTTP.

Resources, verbs, versioning and pagination — decisions that are expensive to change later.

Sessions versus tokens, password storage, and the difference between who you are and what you may do.

Never trust a client. Validate at the boundary and return errors a caller can act on.

XSS, CSRF, injection and CORS — the four that will actually be attempted against you.

Select, join, group and aggregate. This is a permanent skill that outlives every framework.

Model the domain before writing a query. Bad schemas are the hardest thing on this list to undo.

Inner, outer and self joins, and why the wrong one silently loses rows.

Why a query got slow and what an index actually costs on write.

Prisma or similar for productivity — but know the SQL it emits, because that is what runs.

Documents, caches and queues. Know the trade-off rather than the slogan.

Unit tests for logic, integration tests for the seams. Enough to refactor without fear.

Package the app with its dependencies so it runs the same everywhere.

Tests on every push and deploys that are boring. Automate before the manual steps calcify.

A real host, a real domain, HTTPS. A project nobody can visit is not finished.

Image handling, bundle size and caching. Slow pages lose users and rankings alike.

Data structures for the coding screen, plus being able to explain your own projects in depth.