Junior → Architect → Beyond
Backend Engineer Roadmap
A level-graded path through everything in this guide. Each stage lists what you can already do and what to learn next — and every flashcard is tagged with its level so you can drill exactly where you are.
- 1
Junior
Build & ship endpoints with guidance.
You build endpoints and ship features with guidance. The goal is fluency in the fundamentals — modules, controllers, providers, DTOs, and basic data access — so you can deliver a working CRUD module end to end.
You can already
- ✓Scaffold a module with the CLI and wire a controller + service.
- ✓Define routes and read params/query/body with DTOs.
- ✓Inject a service via the constructor and understand it's a singleton.
- ✓Validate input with class-validator + a global ValidationPipe.
- ✓Read and write data through a repository (TypeORM/Prisma/Mongoose).
Level up by
- →Dependency injection in depth: tokens, custom providers, exports/imports.
- →The request lifecycle — guards, interceptors, pipes, filters and their order.
- →The Node event loop and async/await pitfalls.
- →Write your first unit + e2e tests with @nestjs/testing and supertest.
Drill the flashcards filtered to Junior, plus the Core and Data & ORM categories. Read study topics 01–04, 08, and 14. - 2
Mid
Own modules end-to-end: data, validation, tests.
You own modules end to end — data, validation, tests — with little hand-holding. The goal is depth across the everyday NestJS toolkit and the start of performance awareness.
You can already
- ✓Use the full request pipeline: guards, interceptors, pipes, exception filters.
- ✓Model config with @nestjs/config and validate env at boot.
- ✓Run transactions and avoid the synchronize-in-prod trap.
- ✓Write unit tests with overridden providers and e2e tests with supertest.
- ✓Reason about the event loop and avoid blocking it.
Level up by
- →Injection scopes and the cost of REQUEST scope; dynamic modules (forRoot/forFeature).
- →Authentication (JWT/Passport), RBAC, and rate limiting.
- →Caching, queues (BullMQ), scheduling, and events — and their multi-replica gotchas.
- →Streams & backpressure; worker_threads vs cluster.
- 3
Senior
DI depth, the request lifecycle, performance & security.
You bring DI depth, performance, and security maturity, and you raise the team around you. The goal is to be the person who profiles instead of guessing and reasons about the system, not just the syntax.
You can already
- ✓Explain DI scopes, dynamic modules, and the request lifecycle cold.
- ✓Design auth (JWT + refresh, RBAC/ABAC) and harden the API.
- ✓Profile with clinic.js/flame graphs/APM and reason in p95/p99 — fix event-loop blocking, N+1 queries, and memory leaks with evidence, not guesswork.
- ✓Isolate faults with circuit breakers, bulkheads, and timeouts (not bare try/catch) so one slow dependency can't drag the whole process down.
- ✓Frame decisions as trade-offs: name the option you rejected and why, then tie the choice to a measurable outcome — mid says what they did, you say why and what it moved.
- ✓Make caching/rate-limiting/queues correct across replicas with Redis.
- ✓Own observability: structured logs, traces, health checks, graceful shutdown.
Level up by
- →System design at scale: layering/hexagonal, CQRS, resilience patterns.
- →Microservices: transports, message vs event, sagas + outbox.
- →GraphQL at scale (DataLoader, federation) and real-time (WebSockets + Redis).
- →Deployment: multi-stage Docker, CI/CD, SLOs.
- →The senior meta-skill — communicating trade-offs live: "Option A optimizes X at the cost of Y; given Z I'd choose…, and revisit at [threshold]," always anchored to p95/p99, error rate, or cost per request.
Filter flashcards to Senior and the Node.js Core, Performance, Security, Auth, and Deploy & Ops categories. Read study topics 26–34 and the full Architecture guide. Then rehearse the why: for each fix, practice saying the framework, the alternative you rejected, and the p95/p99 or error-rate number it moved — that framing is what reads as senior, not the fix itself. - 4
Architect
System design, microservices, platform decisions.
You design backend systems end to end and make platform decisions that move a whole team. The goal is decision-making before code — for the worst query, the worst network, and the worst traffic spike.
You can already
- ✓Design a service end to end and justify the architecture, data, and consistency strategy.
- ✓Choose modular monolith vs microservices and draw clean boundaries.
- ✓Apply sagas, the outbox, idempotency, and resilience patterns (circuit breakers, bulkheads, timeouts) for fault isolation.
- ✓Design multi-tenancy and prevent cross-tenant leakage.
- ✓Stand up CI/CD, observability, and SLOs across services.
- ✓Walk a system you built end to end — decisions, alternatives rejected, failure modes, and the measured result — and drive a 45-minute design that proactively raises idempotency, backpressure, and delivery semantics.
Level up by
- →Org-level platform strategy: shared libraries, conventions, golden paths.
- →Cost/perf budgets at scale and evaluating emerging tech.
Filter flashcards to Architect and the Architecture and Microservices categories. Work the Architecture guide + Deep dives, the system-design prompts, and study topics 28, 36. - 5
Beyond
Frontier: event-driven at scale, edge & serverless Nest.
The frontier — where you push what a Node/NestJS backend can do. The goal is to bring genuinely new capability and pioneer patterns the rest of the team will adopt.
You can already
- ✓Run NestJS in serverless/edge with cached bootstrap and connection pooling.
- ✓Build event-sourced and CQRS systems where they genuinely fit.
- ✓Stream LLM/AI responses (SSE/WebSocket) with backpressure and cancellation.
- ✓Use AsyncLocalStorage for context with singleton-scope performance.
Level up by
- →Adopt NestJS 12 (ESM, Standard Schema/Zod, Vitest) and contribute patterns back to the team.
Filter flashcards to Beyond, and read study topics 29, 30. Try the event-driven and idempotency design prompts.