Nest

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. 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. 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.
    Filter flashcards to Mid and the DI & Modules, Request Lifecycle, Config, and Testing categories. Work study topics 05–13 and 20–25.
  3. 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 and fix event-loop blocking, N+1 queries, and memory leaks.
    • ✓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.
    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.
  4. 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.
    • ✓Design multi-tenancy and prevent cross-tenant leakage.
    • ✓Stand up CI/CD, observability, and SLOs across services.

    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. 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.