Full Stack Developer

URL to response: DNS, TCP/TLS, request/response anatomy, status codes and cookies - the vocabulary of every debugging session.

Semantic structure, Flexbox and Grid - every full-stack feature still ends at a screen someone has to use.

Branches, PRs and review flow - the collaboration substrate for literally everything that follows.

Closures, prototypes, this and the event loop - the depth that separates users of frameworks from engineers.

Promises, async/await, error propagation and parallelism with Promise.all - backend code is async code.

Interfaces, unions, generics and strict mode - shared types between client and server are full-stack's superpower.

Composition, controlled forms and lifting state - thinking in React rather than fighting it.

Multi-page apps with React Router or Next.js: params, nested layouts, redirects and protected routes.

fetch/React Query patterns: caching, loading and error states, optimistic updates and auth headers.

Client-side validation that mirrors server rules - one schema, two enforcement points.

Event loop, modules and npm - why Node handles thousands of concurrent connections on one thread, and when it can't.

Routing, middleware chains, request validation and centralised error handling as one coherent pipeline.

Resources, verbs, status codes, pagination and versioning - APIs another developer can guess correctly.

Password hashing with bcrypt, sessions vs JWTs, refresh flows and protecting routes - without inventing your own crypto.

Multipart handling, object storage and queues at concept level - the features that separate CRUD demos from products.

Tables, keys, normalisation and joins with Postgres - relational literacy is a career-long asset.

Why one query is instant and another isn't: indexes, EXPLAIN and the N+1 problem.

Documents, embedding vs referencing and aggregation pipelines - and honest criteria for choosing documents over tables.

Prisma/Mongoose for productivity, migrations for schema history, and the escape hatch to raw queries.

Cache-aside for hot reads, TTLs and invalidation - the first tool you reach for when the DB gets hot.

Injection, XSS, CSRF, broken auth and misconfiguration - recognising the classic holes before attackers do.

Same-origin policy, CORS configuration and security headers - the browser-side contract of your API.

Unit tests for logic, integration tests for APIs (supertest), one E2E happy path - confidence to refactor.

Secrets, env vars and the twelve-factor mindset that keeps dev, staging and production sane.

Frontend to a CDN, API to a host (Render/Fly/Railway/VPS), managed Postgres, custom domain and HTTPS.

Dockerfiles and Compose - the same app everywhere, and the lingua franca of modern deployment.

GitHub Actions running tests on every PR and deploying on merge - shipping as a routine, not an event.

Structured logs, health checks and reading a stack trace under pressure - the on-call survival kit.

Explaining your own app's architecture: request flow, data model, caching and how you'd scale it 10×.

Arrays, hashmaps, strings and two-pointer problems - the screening bar most product companies still use.

Take the OneRoadmap Full Stack certification so the resume line is verifiable, not just claimable.