Backend Engineer Learning Path
A structured 12-week journey through the Knowledge Vault for backend engineers. This path takes you from database fundamentals through API design, caching, message queues, Spring Boot, microservices, domain-driven design, background jobs, data pipelines, and production operations including debugging playbooks and production blueprints.
Who This Is For
- Software engineers transitioning into backend roles
- Junior backend engineers who want to level up to mid-level
- Full-stack engineers who want deeper backend expertise
- Anyone preparing for backend-focused interviews at top companies
Prerequisites
- Proficiency in at least one backend language (Java, Python, Node.js, Go)
- Basic SQL knowledge (SELECT, JOIN, WHERE, GROUP BY)
- Understanding of HTTP request/response cycle
- Familiarity with REST APIs
Total estimated time: ~55 hours across 12 weeks
Learning Progression
graph TD
S1["Week 1-2: Database Fundamentals"] --> S2["Week 2-3: Database Performance"]
S2 --> S3["Week 3-4: Caching Strategies"]
S3 --> S4["Week 4-5: Message Queues"]
S4 --> S5["Week 5-6: API Design"]
S5 --> S6["Week 6-7: Spring Boot"]
S6 --> S7["Week 7-8: Microservices"]
S7 --> S8["Week 8-9: DDD & CQRS"]
S8 --> S9["Week 9-10: Background Jobs"]
S9 --> S10["Week 10-11: Data Pipeline"]
S10 --> S11["Week 11: Debugging & Production"]
S11 --> S12["Week 12: Production Blueprints"]
style S1 fill:#e3f2fd
style S2 fill:#e3f2fd
style S3 fill:#e8f5e9
style S4 fill:#e8f5e9
style S5 fill:#fff3e0
style S6 fill:#fff3e0
style S7 fill:#f3e5f5
style S8 fill:#f3e5f5
style S9 fill:#fce4ec
style S10 fill:#fce4ec
style S11 fill:#fce4ec
style S12 fill:#fce4ec
Week 1-2: Database Fundamentals
Estimated reading time: 6 hours
You need to understand how databases work under the hood before you can design schemas, tune queries, or choose the right database for a workload.
- Required -- Database Selection Guide (20 min)
- Required -- Storage Engines (30 min)
- Required -- PostgreSQL Internals (35 min)
- Required -- Write-Ahead Logging (25 min)
- Required -- Indexing Deep Dive (30 min)
- Required -- Isolation Levels (25 min)
- Required -- MVCC (20 min)
- Required -- Replication (30 min)
- Optional -- MongoDB Internals (25 min)
- Optional -- Redis Internals (25 min)
- Optional -- Time-Series Databases (20 min)
- Optional -- Graph Databases (20 min)
- Optional -- NewSQL (15 min)
- Optional -- SQLite Internals (20 min)
Schema design practice:
- Required -- E-Commerce Schema Design (25 min)
- Required -- Chat Schema Design (25 min)
- Optional -- SaaS Schema Design (25 min)
- Optional -- Social Schema Design (25 min)
Checkpoint
After this section you should be able to explain: B-tree vs LSM-tree trade-offs, what WAL guarantees, how MVCC enables concurrent reads/writes, when to choose PostgreSQL vs MongoDB vs Redis, and design a normalized schema for a given domain.
Week 2-3: Database Performance
Estimated reading time: 4 hours
Now that you understand internals, learn how to make databases fast in production.
- Required -- Query Planning & Optimization (30 min)
- Required -- Connection Pooling (20 min)
- Required -- Sharding (30 min)
- Required -- Index Strategy (25 min)
- Required -- Query Optimization (25 min)
- Required -- N+1 Problem (20 min)
- Required -- PostgreSQL DBA (30 min)
- Optional -- Connection Pool Tuning (20 min)
- Optional -- VACUUM & ANALYZE (20 min)
- Optional -- Database Profiling (20 min)
- Reference -- SQL Cheat Sheet (10 min)
- Reference -- Advanced SQL Cheat Sheet (15 min)
Checkpoint
After this section you should be able to: read an EXPLAIN plan, set up read replicas, decide when sharding is appropriate, diagnose the N+1 query problem, and tune connection pools.
Week 3-4: Caching Strategies
Estimated reading time: 3.5 hours
Caching is the single biggest lever for backend performance. Learn the patterns, pitfalls, and production considerations.
- Required -- Caching Strategies Overview (25 min)
- Required -- Cache Invalidation (30 min)
- Required -- Redis Caching Patterns (30 min)
- Required -- Multi-Layer Caching (25 min)
- Required -- Application-Level Caching (25 min)
- Required -- Database-Level Caching (20 min)
- Optional -- Thundering Herd (20 min)
- Optional -- Cache Sizing Math (20 min)
- Optional -- Cache Warming (15 min)
- Optional -- CDN Deep Dive (25 min)
Checkpoint
After this section you should be able to: choose between cache-aside, write-through, and write-behind patterns; design a multi-layer caching strategy; and handle cache invalidation correctly.
Week 4-5: Message Queues & Async Processing
Estimated reading time: 4 hours
Asynchronous processing is essential for scalable backends. Understand the major queue systems and their trade-offs.
- Required -- Message Queues Overview (15 min)
- Required -- Queue Selection Guide (20 min)
- Required -- Kafka Internals (35 min)
- Required -- RabbitMQ Internals (30 min)
- Required -- Ordering Guarantees (20 min)
- Required -- Dead Letter Queues (20 min)
- Required -- Exactly-Once Semantics (25 min)
- Optional -- Backpressure Patterns (20 min)
- Optional -- Kafka Streams (20 min)
- Optional -- Kafka Connect (20 min)
- Optional -- Redis Streams (20 min)
- Optional -- SQS & SNS (20 min)
- Optional -- NATS (15 min)
Checkpoint
After this section you should be able to: choose between Kafka and RabbitMQ for a given use case, explain exactly-once delivery semantics, and design a DLQ strategy.
Week 5-6: API Design
Estimated reading time: 5 hours
Backend engineers live and breathe APIs. Understand the protocols, patterns, and production concerns across REST, GraphQL, gRPC, and event-driven APIs.
- Required -- API Design Overview (15 min)
- Required -- REST API Best Practices (25 min)
- Required -- API Versioning (20 min)
- Required -- Pagination Patterns (25 min)
- Required -- OpenAPI & Swagger (20 min)
- Required -- GraphQL Advanced (25 min)
- Required -- gRPC Deep Dive (25 min)
- Required -- Event-Driven APIs (25 min)
- Required -- Webhook Infrastructure (25 min)
- Optional -- API Gateway Patterns (20 min)
- Optional -- API Security Patterns (20 min)
- Optional -- tRPC (15 min)
Networking fundamentals:
- Required -- HTTP/2 & HTTP/3 (25 min)
- Required -- WebSockets (20 min)
- Required -- Service Discovery (20 min)
- Optional -- DNS Deep Dive (25 min)
- Optional -- TLS Handshake (20 min)
Checkpoint
After this section you should be able to: design RESTful APIs with proper versioning and pagination, choose between REST, GraphQL, gRPC, and WebSockets, build webhook infrastructure, and understand event-driven API patterns.
Week 6-7: Spring Boot
Estimated reading time: 8 hours
Spring Boot is the dominant backend framework in Java enterprise. This section covers the core concepts you need as a backend engineer.
Spring Boot Core
- Required -- Spring Boot Overview (15 min)
- Required -- Core Concepts (30 min)
- Required -- REST API (25 min)
- Required -- Exception Handling (20 min)
- Required -- Spring Data JPA (30 min)
- Required -- Hibernate Tuning (25 min)
- Required -- Database Migrations (20 min)
- Required -- Caching (20 min)
Spring Boot Security & APIs
- Required -- Security (25 min)
- Required -- JWT Auth (25 min)
- Required -- OpenAPI (20 min)
- Optional -- Security Advanced (25 min)
- Optional -- OAuth2 & OIDC (25 min)
- Optional -- Rate Limiting (20 min)
- Optional -- API Versioning (15 min)
Spring Boot Production
- Required -- Testing (25 min)
- Required -- Actuator (20 min)
- Required -- Logging (20 min)
- Required -- Best Practices (25 min)
- Optional -- Async (20 min)
- Optional -- AOP (20 min)
- Optional -- Docker (20 min)
- Optional -- Deployment (20 min)
- Reference -- Spring Boot Cheat Sheet (10 min)
Checkpoint
After this section you should be able to: build production-ready REST APIs with Spring Boot, implement JPA repositories with optimized Hibernate queries, secure endpoints with Spring Security and JWT, write integration tests with @SpringBootTest, and monitor with Actuator.
Week 7-8: Microservices & Architecture
Estimated reading time: 5 hours
Microservices architecture is the dominant pattern for large-scale backends. Learn when to use it, how to decompose, and how to avoid the pitfalls.
- Required -- Microservices Overview (15 min)
- Required -- Decomposition Strategies (25 min)
- Required -- Communication Patterns (30 min)
- Required -- Data Management (25 min)
- Required -- API Gateway Pattern (25 min)
- Required -- Anti-Patterns (20 min)
- Required -- Distributed Tracing (25 min)
- Optional -- Service Mesh (25 min)
- Optional -- Testing Strategies (25 min)
- Optional -- Migration from Monolith (25 min)
Spring Boot microservices:
- Optional -- Spring Boot Microservices Patterns (25 min)
- Optional -- Spring Cloud (25 min)
- Optional -- Spring Cloud Gateway (20 min)
- Optional -- Service Discovery (20 min)
- Optional -- Resilience (20 min)
Checkpoint
After this section you should be able to: decompose a monolith into services, choose synchronous vs asynchronous communication, design an API gateway, recognize common anti-patterns like distributed monoliths, and implement microservices with Spring Cloud.
Week 8-9: Domain-Driven Design & CQRS
Estimated reading time: 5 hours
DDD gives you the conceptual tools to design complex business domains cleanly. CQRS and event sourcing handle advanced read/write separation.
Domain-Driven Design
- Required -- DDD Overview (15 min)
- Required -- Strategic Design (30 min)
- Required -- Tactical Design (30 min)
- Required -- Domain Events (25 min)
- Required -- Anti-Corruption Layer (20 min)
- Optional -- Specification Pattern (20 min)
- Optional -- TypeScript Implementation (25 min)
CQRS & Event Sourcing
- Required -- CQRS & Event Sourcing Overview (15 min)
- Required -- CQRS Deep Dive (30 min)
- Required -- Event Sourcing Deep Dive (30 min)
- Required -- Aggregate Design (25 min)
- Required -- Projections (25 min)
- Optional -- Sagas & Process Managers (25 min)
- Optional -- Snapshots (20 min)
- Optional -- Event Upcasting (20 min)
Related Event-Driven Patterns
- Optional -- Event-Driven Overview (15 min)
- Optional -- Transactional Outbox (20 min)
- Optional -- Idempotent Consumers (20 min)
- Optional -- Eventual Consistency (20 min)
Checkpoint
After this section you should be able to: identify bounded contexts, design aggregates, implement CQRS with separate read/write models, build projections, and use domain events for decoupling.
Week 9-10: Background Jobs & Temporal
Estimated reading time: 4 hours
Long-running processes, scheduled tasks, and complex workflows require dedicated infrastructure beyond simple API request/response.
- Required -- Background Jobs Overview (15 min)
- Required -- Background Jobs Patterns (25 min)
- Required -- Background Jobs Comparison (20 min)
- Required -- Temporal (30 min)
- Required -- Job Queue Blueprint (15 min)
- Required -- Job Queue Architecture (25 min)
- Required -- Worker Patterns (20 min)
- Required -- Retry Strategies (20 min)
- Optional -- Priority Queues (20 min)
- Optional -- Job Queue Monitoring (20 min)
Spring Boot background processing:
- Optional -- Spring Batch (25 min)
- Optional -- Spring Batch Deep Dive (25 min)
- Optional -- Spring Integration (20 min)
- Optional -- Spring State Machine (20 min)
Checkpoint
After this section you should be able to: choose between Temporal, BullMQ, and Celery for a given workload, design retry strategies with exponential backoff and dead letter handling, build reliable background job systems, and implement batch processing with Spring Batch.
Week 10-11: Data Pipeline Fundamentals
Estimated reading time: 4 hours
Backend engineers increasingly own data pipelines. Understand the patterns for moving, transforming, and validating data at scale.
- Required -- Data Pipeline Overview (15 min)
- Required -- Pipeline Patterns (25 min)
- Required -- Data Contracts (25 min)
- Required -- Database Extraction (20 min)
- Required -- API Ingestion (20 min)
- Required -- Pipeline Monitoring (20 min)
- Optional -- Deduplication (20 min)
- Optional -- File Formats (20 min)
- Optional -- Great Expectations (20 min)
- Optional -- Pandera Validation (15 min)
Spring Boot data integration:
- Optional -- Spring Boot Kafka (25 min)
- Optional -- Spring Boot Event-Driven (20 min)
Checkpoint
After this section you should be able to: design data pipeline architectures, implement data contracts between services, extract data from databases and APIs, monitor pipeline health, and handle data deduplication.
Week 11: Debugging Playbooks & Production Operations
Estimated reading time: 4 hours
Your code is only as good as your ability to deploy it safely and debug it when things go wrong.
Debugging Playbooks
- Required -- Debugging Playbooks Overview (10 min)
- Required -- API Slow Response (25 min)
- Required -- Intermittent 502 (25 min)
- Required -- Database CPU (25 min)
- Required -- Memory Leak (25 min)
- Required -- High Error Rate (25 min)
- Optional -- Pods Restarting (20 min)
Deployment & Monitoring
- Required -- Deployment Strategies Overview (15 min)
- Required -- Blue-Green Deployments (20 min)
- Required -- Database Migrations (25 min)
- Required -- Monitoring Overview (15 min)
- Required -- Metrics Design (25 min)
- Required -- Structured Logging (20 min)
- Required -- Correlation IDs (15 min)
- Optional -- Canary Deployments (20 min)
- Optional -- Rollback Procedures (20 min)
- Optional -- Feature Flags for Deployment (20 min)
Checkpoint
After this section you should be able to: diagnose slow APIs, intermittent 502s, and memory leaks using structured playbooks, plan a zero-downtime deployment, set up application metrics with RED/USE methodology, and implement structured logging with correlation IDs.
Week 12: Production Blueprints & Capstone
Estimated reading time: 5 hours
Study complete production systems that integrate every concept from this path.
- Required -- Production Blueprints Overview (15 min)
- Required -- Auth Service Architecture (25 min)
- Required -- Auth Service Database Schema (20 min)
- Required -- Billing Engine Architecture (25 min)
- Required -- Billing Engine Idempotency (20 min)
- Required -- Notification Service Architecture (25 min)
- Required -- Rate Limiter Blueprint (15 min)
- Required -- Rate Limiter Algorithms (25 min)
- Optional -- Analytics Pipeline Architecture (25 min)
- Optional -- Realtime Pipeline Architecture (25 min)
- Optional -- Payment Engineering (25 min)
- Optional -- Chat Service Blueprint (25 min)
- Optional -- Search Service Blueprint (25 min)
What You Will Be Able to Do After This Path
- Design and optimize database schemas for complex domains
- Build production-ready REST, GraphQL, and gRPC APIs
- Implement caching strategies that reduce database load by 90%+
- Design asynchronous processing with message queues and background jobs
- Build Spring Boot microservices with proper security, testing, and observability
- Apply DDD and CQRS to model complex business domains
- Debug production incidents systematically using playbooks
- Design complete production systems (auth, billing, notifications, job queues)
Cross-References to Related Paths
- DevOps Engineer Path -- Deep dive into Docker, Kubernetes, Terraform, and infrastructure
- System Design Interview Path -- Apply your knowledge to interview-style problems
- Security Engineer Path -- Harden your backends against attacks
- Spring Boot Engineer Path -- Comprehensive 12-week Spring Boot deep dive
- Data Engineer Path -- Build data pipelines and analytics systems
- Platform Engineer Path -- Build the infrastructure platform
Total Progress
This path contains approximately 100 pages. At a pace of 5 pages per day, you can complete it in about 3 weeks of focused study. The Spring Boot section alone contains 20+ pages. Adjust based on your experience level and available time.