Methods, status codes, headers, and cookies, plus how TLS secures the round trip between client and server.

How a request travels from browser to server through DNS, load balancers, and reverse proxies, and where your code sits in that flow.

How browsers parse and render pages, and the basics of where and how web apps are hosted and served.

Structure content with meaningful elements so pages stay accessible, searchable, and easy to style.

The box model, selectors, and modern layout with Flexbox and Grid to arrange interfaces predictably.

Media queries, fluid units, and a mobile-first approach so one layout adapts across screen sizes.

Variables, functions, closures, the event loop, promises, and async/await that power both client and server code.

Select and update elements, handle events, and use fetch so you understand what frameworks abstract away.

Static types, interfaces, and generics that catch bugs early and make code shared across the stack self-documenting.

Commits, branches, merges, and pull requests so every change is reviewable, reversible, and collaborative.

Install and pin dependencies with npm or pnpm, and understand what a bundler like Vite does under the hood.

Build UIs from composable components with props and JSX, the foundation most full-stack stacks share.

Manage local state and side effects with useState, useEffect, and custom hooks for reusable logic.

Controlled inputs, client-side validation, and clear error states so users can submit data confidently.

Load, cache, and revalidate remote data with a tool like TanStack Query instead of hand-rolling every fetch.

The Context API and lightweight stores like Zustand for state that many components need to share.

File-based routing, server and client components, and data loading in a framework built for full-stack apps.

Server-side rendering, static generation, and streaming, and when each keeps pages fast and fresh.

Run backend logic close to your components with server actions and route handlers instead of a separate service.

Handle requests with Node.js and Express: routing, middleware, and request parsing for a working API.

Organize larger services with NestJS modules, dependency injection, and a clear, testable architecture.

Drive settings through environment variables and keep development, staging, and production cleanly separated.

SELECT, JOIN, and aggregation to read and shape data, using PostgreSQL as a capable, open-source default.

Model entities and relationships, normalize sensibly, and add indexes so common queries stay fast.

Group related writes so concurrent operations stay correct under load instead of leaving half-finished data.

Document stores like MongoDB and key-value stores like Redis, and when their flexibility or speed earns a place.

Map rows to typed objects with Prisma or Drizzle, while knowing when raw SQL is simply clearer.

Version schema changes in code so every environment applies the same ordered, reversible steps.

Model resources, map CRUD to HTTP methods, return the right status codes, and paginate large collections.

Let clients request exactly the fields they need with a typed schema, and understand the N+1 problem it introduces.

Call your own and third-party APIs cleanly, handling loading, errors, and retries on the client.

Cookie-based sessions versus stateless JWTs, and the tradeoffs each makes for scale and revocation.

Delegate identity to providers and understand the authorization code flow behind sign-in with Google or GitHub.

Hash credentials with bcrypt or argon2, and model permissions with roles so authorization scales past one admin flag.

Test business logic and UI components in isolation with Vitest and Testing Library for fast feedback.

Exercise API routes against a real database to catch the wiring bugs unit tests never see.

Drive the whole app in a browser with Playwright to verify critical user flows from click to database.

Feature branches, code review, and a workflow like trunk-based or GitHub Flow that keeps a team unblocked.

Automate build, test, and deploy with GitHub Actions so every merge reaches production the same repeatable way.

Write Dockerfiles and build small images so your frontend and backend run identically across environments.

Spin up your app, database, and cache together with Compose so a new machine is one command from running.

Ship a Next.js app to a platform like Vercel, with previews, environment variables, and custom domains.

Run APIs on a container host or serverless platform and connect a managed database with pooled connections.

Use cache-control headers and a CDN to serve static and cacheable responses close to your users.

Emit machine-parseable logs with correlation IDs so one request can be traced from frontend to database.

Capture and group client and server exceptions with a tool like Sentry so real user errors surface fast.

Track latency, error rate, and uptime so you learn about problems before your users report them.

Injection, broken access control, and the other common web vulnerabilities you must design against.

Validate and sanitize every input at the boundary to block injection, XSS, and malformed data.

Keep keys out of source control, rotate them, and enforce HTTPS everywhere data is in transit.