Roadmap

Backend Engineer

FAANG-level backend engineering: APIs, databases, async systems, caching, microservices, distributed systems, and performance tuning. Build systems that handle millions of users.

3levels16skills~32hours

Curated from the best, MDN · Kubernetes · AWS · OWASP · Google SRE & more

Backend engineers are the highest-demand engineering role at every FAANG company. Mastery of APIs, databases, async systems, and distributed systems unlocks $180k–$350k+ compensation.

Start learning, it’s free Ready to build? See capstone projects

Foundations: APIs, Databases, Auth & Async

~12h

The four pillars every backend engineer must master: choosing the right API protocol, designing production-grade databases, securing systems with auth, and writing non-blocking async code.

Choose between REST, GraphQL, and gRPC based on use case tradeoffs Design SQL schemas for production: indexes, constraints, money as integers, UUIDs Implement JWT authentication with RS256 and RBAC authorization Write async/await patterns that exploit parallelism, not just sequential awaits

API Protocols: REST vs GraphQL vs gRPCChoose the right communication contract. REST for public APIs, GraphQL for flexible UIs, gRPC for internal services.

Database Fundamentals: SQL, Scaling & Data ModelingPostgreSQL, ACID guarantees, query-first schema design, and the scaling ladder.

Auth & Authorization: Securing Backend SystemsJWTs, OAuth 2.0 + PKCE, RBAC, ABAC, and why 401 ≠ 403.

Async Programming: Callbacks, Promises, Async/AwaitThe event loop, Promise.all vs sequential awaits, Worker Threads for CPU work.

Build Challenge: Production REST APIDay 1 at a fintech startup. Build /users and /transactions with JWT auth, Zod validation, SQL injection safety, and pass a 1,000 RPS load test. Your tech lead reviews Friday.

Intermediate: Caching, Queues, Optimization & Microservices

~12h

The systems that separate junior from senior engineers: caching strategies that eliminate 80% of DB load, message queues for decoupled async, database query optimization, microservices design, and API gateway patterns.

Implement cache-aside with TTL jitter, thundering herd prevention, and proper invalidation Design Kafka consumer groups and RabbitMQ work queues; implement the Outbox Pattern Diagnose slow queries with EXPLAIN ANALYZE and apply composite/partial indexes Design microservices with proper bounded contexts, not a distributed monolith

Caching Strategies: Redis, Memcached & Cache InvalidationCache-aside, write-through, TTL jitter, thundering herd, and Redis data structures.

Message Queues: Kafka, RabbitMQ & Async CommunicationConsumer groups, fan-out, idempotent consumers, DLQ, and the Outbox Pattern.

Database Optimization: Indexing, Query Performance & ShardingEXPLAIN ANALYZE, B-tree internals, composite indexes, partitioning vs sharding.

Microservices Architecture: Building Distributed SystemsBounded contexts, service boundaries, circuit breakers, Saga pattern.

API Gateway & Load Balancing: Traffic at ScaleLoad balancing algorithms, token bucket rate limiting, health checks, graceful shutdown.

Build Challenge: Diagnose and Fix a Slow APIYour senior hands you a PR. The endpoint works but p99 is 4s. EXPLAIN ANALYZE it, add a composite index, add Redis cache-aside, add token-bucket rate limiting. Code review tomorrow.

Advanced: Observability, Consensus, Performance & Scale

~8h

Staff-engineer-level mastery: distributed tracing that cuts MTTR from 45 minutes to 3 minutes, consensus algorithms that power etcd and CockroachDB, performance profiling that finds real bottlenecks (not guesses), and scaling architecture from 1k to 1B users.

Instrument services with OpenTelemetry; design SLOs with error budgets Explain Raft leader election and quorum; use fencing tokens for distributed locks Profile Node.js services with clinic.js flame graphs; apply Amdahl's Law Design stateless services for horizontal scaling; apply CQRS and idempotency keys

Distributed Tracing: Observability in a Microservices WorldOpenTelemetry auto-instrumentation, trace context propagation, SLOs and error budgets.

Consensus Algorithms: Building Reliable Distributed SystemsCAP theorem, Raft leader election, quorum, fencing tokens, consistency models.

Performance Tuning: Profiling, Bottlenecks & OptimizationFlame graphs, Amdahl's Law, CPU vs I/O vs event-loop bottlenecks, Worker Threads.

Scalable Backend: From Thousands to Billions of UsersStateless design, scaling ladder, idempotency keys, CQRS, multi-region architecture.

Build Challenge: Make It Observable and ResilientThe SRE team needs 4 things before your service ships: distributed traces, /health + /ready endpoints, graceful SIGTERM shutdown, and a circuit breaker on the DB call. Ship it.

Job-ready: Backend Engineer

Finish the path, earn the certificate, and walk into interviews prepared.