Backend Engineering
Master backend development from HTTP fundamentals to production-ready systems. 20 phases covering APIs, databases, security, caching, and scalability.
Your Progress
Complete all 20 phases to master this track
Backend engineering roadmap — 20 phases from HTTP fundamentals through APIs, databases, security, caching, and scalable microservices.
Phase 1: Backend Fundamentals
Understand what backend development is, how servers work, and the core concepts behind every backend application.
What Is Backend Development
Understand the role of backend in software applications.
Frontend vs Backend
Compare frontend and backend responsibilities and technologies.
Client-Server Architecture
Learn how clients and servers communicate over networks.
Request-Response Model
Understand the fundamental communication pattern of the web.
Stateless vs Stateful Applications
Learn the difference between stateless and stateful designs and their scaling implications.
Backend Application Lifecycle
Understand how backend applications start, handle requests, and shut down.
Application Server
Learn what application servers do and how they differ from web servers.
Web Server
Understand how web servers handle incoming HTTP requests.
Reverse Proxy
Learn how reverse proxies protect and distribute backend traffic.
Load Balancer
Understand how load balancers distribute traffic across multiple servers.
Ports
Learn how network ports work and how backend services bind to them.
Processes
Understand operating system processes and how backend applications run as processes.
Threads
Learn about threads, thread models, and how they relate to backend request handling.
Concurrency
Understand concurrent request handling and its impact on backend design.
Backend Scalability Basics
Learn the fundamentals of scaling backend applications vertically and horizontally.
Phase 2: HTTP and Web Fundamentals
Master HTTP protocol fundamentals - the backbone of all backend web communication.
HTTP
Understand the Hypertext Transfer Protocol that powers the web.
HTTPS
Learn how TLS/SSL secures HTTP communication.
HTTP Request
Understand the structure and components of an HTTP request.
HTTP Response
Learn how servers construct and send HTTP responses.
HTTP Methods
Master GET, POST, PUT, PATCH, DELETE and their semantics.
GET
Deep dive into the GET method for reading resources.
POST
Deep dive into the POST method for creating resources.
PUT
Deep dive into the PUT method for replacing resources.
PATCH
Deep dive into the PATCH method for partial updates.
DELETE
Deep dive into the DELETE method for removing resources.
HTTP Status Codes
Master all HTTP status code categories and when to use each.
Request Headers
Learn essential HTTP request headers and their purposes.
Response Headers
Understand response headers for caching, security, and content negotiation.
Cookies
Learn how cookies work for state management in web applications.
Sessions
Understand server-side sessions and how they maintain user state.
Content Types
Learn about MIME types and Content-Type headers.
JSON
Master JSON as the standard data format for API communication.
Form Data
Understand form-encoded data and multipart uploads.
CORS
Learn Cross-Origin Resource Sharing and why it exists.
Preflight Requests
Understand OPTIONS requests and CORS preflight mechanism.
HTTP Keep-Alive
Learn how persistent connections improve HTTP performance.
HTTP/1.1
Understand HTTP/1.1 features, pipelining, and limitations.
HTTP/2
Learn HTTP/2 multiplexing, header compression, and server push.
HTTP/3 Basics
Understand HTTP/3 and QUIC protocol fundamentals.
Phase 3: REST API Development
Master RESTful API design principles, patterns, and best practices for building clean backend APIs.
What Is an API
Understand what APIs are and why they matter in backend development.
REST
Learn the Representational State Transfer architectural style.
REST Principles
Master the six REST constraints.
Resource Design
Learn how to model your domain as RESTful resources.
RESTful URLs
Design clean, consistent, and intuitive API URLs.
HTTP Methods in REST
Map HTTP methods to CRUD operations in REST APIs.
Status Codes in REST
Choose the right HTTP status codes for REST API responses.
Request Validation
Validate incoming API requests to ensure data integrity.
Response Design
Design consistent and useful API response structures.
Pagination
Implement offset, cursor, and keyset pagination for list endpoints.
Filtering
Design query parameter filtering for REST APIs.
Sorting
Implement sorting parameters in REST API endpoints.
Searching
Design search endpoints with query parameters and full-text search.
API Versioning
Version your APIs using URL path, headers, or query parameters.
Idempotency
Understand why idempotency matters and how to implement it.
Error Handling
Design consistent error responses with error codes and messages.
API Documentation
Document your APIs effectively for other developers.
OpenAPI / Swagger
Use OpenAPI specification to define and document REST APIs.
REST API Best Practices
Compile all REST best practices into a checklist.
Phase 4: Java Backend Development
Learn how Java is used to build backend applications with layered architecture and clean code patterns.
Java Backend Architecture
Understand how Java backend applications are structured.
Layered Architecture
Learn the controller-service-repository layered pattern.
Controller
Understand the controller layer that handles HTTP requests.
Service
Learn the service layer that contains business logic.
Repository
Understand the repository layer that handles database access.
Entity
Learn how domain entities map to database tables.
DTO
Understand Data Transfer Objects and why they separate API contracts from domain models.
Mapper
Learn to map between entities and DTOs cleanly.
Dependency Injection
Master DI for creating loosely coupled, testable backend code.
Inversion of Control
Understand the IoC principle behind dependency injection frameworks.
Configuration Management
Manage backend configuration for different environments.
Environment Variables
Use environment variables for secrets and environment-specific config.
Logging
Implement proper logging in backend applications.
Exception Handling
Handle exceptions gracefully in backend code.
Global Exception Handling
Create centralized exception handlers for consistent error responses.
Validation
Validate request data using annotations and custom validators.
API Response Models
Design standard API response wrapper classes.
Backend Project Structure
Organize Java backend projects for maintainability.
Phase 5: Spring Boot Fundamentals
Master Spring Boot - the industry-standard framework for building Java backend applications.
What Is Spring
Understand the Spring ecosystem and its core principles.
What Is Spring Boot
Learn why Spring Boot exists and how it simplifies Spring development.
Spring Boot Project Structure
Understand the standard Spring Boot project layout.
Spring Boot Application
Create and run your first Spring Boot application.
Dependency Injection in Spring
Understand how Spring manages dependencies through its IoC container.
Beans
Learn what Spring beans are and how they are managed.
Component Scanning
Understand how Spring discovers and registers components.
@Component
Use @Component to mark classes for Spring management.
@Service
Use @Service to annotate service layer classes.
@Repository
Use @Repository to annotate data access classes.
@Controller
Use @Controller for traditional MVC controllers.
@RestController
Use @RestController for building REST APIs.
@Autowired
Understand field, setter, and constructor injection with @Autowired.
Constructor Injection
Learn why constructor injection is the recommended DI approach.
Configuration
Configure Spring Boot applications using Java config and properties.
application.properties
Configure Spring Boot using application.properties files.
application.yml
Use YAML format for Spring Boot configuration.
Profiles
Use Spring Profiles for environment-specific configuration.
REST Controllers in Spring
Build complete REST endpoints with Spring MVC.
Request Parameters
Extract query parameters, path variables, and request bodies.
Path Variables
Use @PathVariable to extract values from URL paths.
Request Body
Use @RequestBody to deserialize JSON request bodies.
ResponseEntity
Control HTTP response status, headers, and body with ResponseEntity.
Validation in Spring
Validate request data using Bean Validation annotations.
Exception Handling in Spring
Handle exceptions using @ExceptionHandler.
Global Exception Handler
Create @ControllerAdvice for centralized exception handling.
Phase 6: Database Integration
Connect backend applications to databases using JDBC, JPA, and Hibernate for persistent data storage.
Backend + Database Architecture
Understand how backend applications interact with databases.
JDBC
Learn Java Database Connectivity for raw SQL execution.
Connection Pooling
Understand why connection pooling is essential and how it works.
ORM
Learn Object-Relational Mapping concepts and benefits.
JPA
Understand Java Persistence API as the standard for ORM in Java.
Hibernate
Master Hibernate as the most popular JPA implementation.
Entity Mapping
Map Java entities to database tables with annotations.
Primary Keys
Define and generate primary keys for JPA entities.
Relationships
Model one-to-one, one-to-many, and many-to-many relationships.
One-to-One
Implement one-to-one entity relationships.
One-to-Many
Implement one-to-many entity relationships.
Many-to-Many
Implement many-to-many entity relationships with join tables.
Lazy Loading
Understand lazy loading and its impact on database queries.
Eager Loading
Understand eager loading and when to use it.
Transactions
Learn database transactions and their ACID properties.
@Transactional
Use @Transactional for declarative transaction management in Spring.
N+1 Query Problem
Identify and solve the N+1 query problem in ORM.
Query Optimization
Optimize database queries for better backend performance.
Database Indexes
Understand indexes and their impact on query performance.
Pagination with JPA
Implement database-level pagination in Spring Data JPA.
Database Migrations
Manage database schema changes with version-controlled migrations.
Flyway / Liquibase Concepts
Learn migration tools for managing database schema evolution.
Phase 7: Authentication
Implement secure user authentication and authorization in backend applications.
Authentication vs Authorization
Understand the critical difference between who you are and what you can do.
Login Flow
Trace the complete user login flow from request to response.
Password Hashing
Hash passwords with bcrypt, scrypt, or Argon2 - never store plaintext.
Sessions for Authentication
Use server-side sessions to maintain authenticated state.
Cookies for Authentication
Use cookies to transmit session identifiers and tokens.
JWT
Understand JSON Web Tokens for stateless authentication.
Access Tokens
Design short-lived access tokens for API authentication.
Refresh Tokens
Use refresh tokens to obtain new access tokens without re-login.
Token Expiration
Manage token lifetimes and handle expired tokens gracefully.
Role-Based Access Control
Implement RBAC to control what authenticated users can access.
OAuth Basics
Understand OAuth as a delegation protocol for third-party access.
OAuth 2.0 Concepts
Master OAuth 2.0 flows: authorization code, client credentials, PKCE.
Authentication Architecture
Design secure authentication systems with proper separation of concerns.
Common Authentication Mistakes
Avoid the top authentication anti-patterns and vulnerabilities.
Phase 8: Backend Security
Protect backend applications from common vulnerabilities following OWASP guidelines.
OWASP Basics
Learn the OWASP Top 10 and why it matters for backend developers.
SQL Injection
Prevent SQL injection with parameterized queries and ORM.
XSS
Prevent Cross-Site Scripting through input sanitization and output encoding.
CSRF
Prevent Cross-Site Request Forgery with tokens and same-site cookies.
Authentication Attacks
Defend against brute force, credential stuffing, and session hijacking.
Authorization Bugs
Detect and prevent broken authorization vulnerabilities.
Broken Access Control
The most common vulnerability - understand and prevent it.
Password Security
Implement secure password policies, storage, and reset flows.
Secrets Management
Never hardcode secrets - use vaults, environment variables, and key rotation.
Secure Headers
Set Content-Security-Policy, X-Frame-Options, and other security headers.
HTTPS
Enforce HTTPS everywhere and understand TLS termination.
Input Validation
Validate and sanitize all user input to prevent injection attacks.
Rate Limiting
Protect APIs from abuse with rate limiting and throttling.
Security Logging
Log security-relevant events for monitoring and incident response.
Secure API Design
Design APIs with security as a first-class concern.
Phase 9: Caching
Implement caching strategies to dramatically improve backend performance and reduce database load.
Why Caching
Understand the performance benefits of caching in backend systems.
Cache-Aside
The most common caching pattern: application manages cache explicitly.
Read-Through
Cache automatically loads data on cache miss.
Write-Through
Write to cache and database simultaneously for consistency.
Write-Behind
Write to cache first, asynchronously flush to database.
Cache Invalidation
The hardest problem in computer science - when and how to invalidate cache.
TTL
Use Time-To-Live to automatically expire cached data.
Cache Eviction
Understand eviction policies when cache is full.
LRU
Implement Least Recently Used eviction for efficient cache management.
Redis
Master Redis as the most popular in-memory data store for caching.
Distributed Cache
Scale caching across multiple servers with distributed cache architectures.
Cache Stampede
Prevent thundering herd when many requests hit a cold cache.
Cache Consistency
Maintain consistency between cache and database.
When NOT to Cache
Recognize when caching adds complexity without benefit.
Phase 10: Asynchronous Processing
Process work asynchronously with message queues, event-driven architecture, and background workers.
Synchronous vs Asynchronous
Understand when to process requests synchronously and when to go async.
Background Jobs
Offload long-running work to background job processors.
Task Queues
Use task queues to decouple request handling from work processing.
Message Queues
Understand message queues as the backbone of asynchronous systems.
Producer
Learn how producers publish messages to queues.
Consumer
Learn how consumers receive and process messages from queues.
Queue
Understand queue data structures in messaging systems.
Kafka Basics
Master Apache Kafka for high-throughput event streaming.
RabbitMQ Concepts
Learn RabbitMQ for reliable message-based communication.
Consumer Groups
Scale message processing with consumer groups.
Message Ordering
Guarantee message ordering when it matters.
Retry
Implement retry logic with exponential backoff for failed operations.
Exponential Backoff
Implement exponential backoff to avoid overwhelming failing services.
Dead Letter Queue
Handle permanently failed messages with dead letter queues.
At-Least-Once Delivery
Understand delivery guarantees and at-least-once semantics.
Idempotent Consumers
Process duplicate messages safely with idempotent consumers.
Event-Driven Architecture
Design systems around events rather than direct service calls.
Phase 11: Concurrency
Master concurrent programming for building high-performance backend systems.
Concurrency
Understand concurrency vs parallelism and why backend systems need both.
Parallelism
Execute multiple computations simultaneously for faster processing.
Threads Deep Dive
Understand thread lifecycle, states, and JVM thread model.
Thread Pools
Manage thread creation and reuse with thread pool executors.
Race Conditions
Detect and prevent race conditions in concurrent code.
Critical Sections
Protect shared resources with critical sections.
Locks
Use explicit locks for fine-grained concurrency control.
Synchronization
Synchronize access to shared mutable state.
Deadlocks
Detect, prevent, and recover from deadlocks.
Starvation
Prevent thread starvation with fair scheduling.
Thread Safety
Write thread-safe code using immutability, synchronization, and atomics.
Concurrent Collections
Use ConcurrentHashMap, CopyOnWriteArrayList, and other concurrent collections.
Async Processing
Use CompletableFuture and async frameworks for non-blocking operations.
Common Concurrency Interview Questions
Master the most frequently asked concurrency questions.
Phase 12: Files and Storage
Handle file uploads, object storage, and streaming in backend applications.
File Upload Architecture
Design scalable file upload systems.
Multipart Upload
Handle multipart form data for file uploads.
Object Storage
Understand object storage vs block vs file storage.
Amazon S3 Concepts
Master S3 buckets, objects, and access patterns.
Presigned URLs
Generate temporary URLs for secure direct uploads and downloads.
File Metadata
Store and manage file metadata alongside file data.
Large File Uploads
Handle large file uploads with chunking and resumable uploads.
Streaming
Stream data instead of buffering entire files in memory.
Download Optimization
Optimize file downloads with range requests and compression.
CDN for Static Files
Serve static files through CDNs for global low-latency access.
Phase 13: Backend Performance
Identify and resolve backend performance bottlenecks for fast, responsive applications.
Latency
Measure and optimize response latency in backend systems.
Throughput
Maximize requests per second while maintaining correctness.
Response Time
Understand and optimize end-to-end response time.
Database Bottlenecks
Identify and resolve database performance issues.
N+1 Queries
Detect and fix N+1 query problems that kill performance.
Connection Pooling
Tune connection pools for optimal database performance.
Caching for Performance
Use caching to eliminate redundant database queries.
Pagination
Implement efficient pagination for large result sets.
Batch Processing
Process large datasets efficiently with batch operations.
Asynchronous Processing
Offload slow operations to improve request response time.
Compression
Use gzip or brotli to reduce response payload size.
CDN
Use Content Delivery Networks to reduce latency globally.
Load Balancing
Distribute load effectively across backend instances.
Profiling
Profile backend applications to find performance hotspots.
Performance Debugging
Systematic approach to diagnosing and fixing performance issues.
Phase 14: Observability
Make backend systems observable with logging, metrics, tracing, and alerting.
Logging
Implement structured, leveled logging for backend applications.
Log Levels
Use ERROR, WARN, INFO, DEBUG, and TRACE appropriately.
Structured Logging
Log in JSON format for machine-parseable, searchable logs.
Metrics
Collect and expose application metrics like request count, latency, and errors.
Monitoring
Set up dashboards and monitors for backend health.
Distributed Tracing
Trace requests across multiple services with trace IDs.
Health Checks
Implement health check endpoints for load balancers and orchestrators.
Readiness
Determine when a service is ready to accept traffic.
Liveness
Detect and restart unresponsive backend instances.
Error Tracking
Track and aggregate errors for visibility into failure patterns.
Alerting
Set up actionable alerts for backend anomalies.
Debugging Production Issues
Systematic approach to diagnosing issues in production systems.
Incident Investigation
Investigate production incidents with logs, metrics, and traces.
Phase 15: Testing
Write reliable backend code with unit, integration, and API testing strategies.
Unit Testing
Write fast, isolated tests for individual components.
Integration Testing
Test how components work together, including databases and APIs.
API Testing
Test REST API endpoints for correctness and edge cases.
Mocking
Replace external dependencies with mocks for isolated testing.
Test Doubles
Understand mocks, stubs, fakes, and spies.
Repository Testing
Test database access layers with embedded databases.
Service Testing
Test business logic in service layers with mocked dependencies.
Controller Testing
Test REST controllers with MockMvc or WebTestClient.
Database Testing
Test database operations with test containers and fixtures.
Test Containers Concepts
Use Docker containers for realistic integration testing.
Test Coverage
Measure and improve test coverage without chasing 100%.
Testing Failure Cases
Test error paths, exceptions, and edge cases.
Testing Authentication
Test authentication and authorization logic thoroughly.
Testing APIs End-to-End
Write comprehensive API tests that validate full request flows.
Phase 16: Background Jobs and Scheduling
Schedule and manage background jobs for recurring tasks and delayed processing.
Cron Jobs
Schedule tasks using cron expressions and crontab.
Scheduled Tasks
Use Spring @Scheduled for time-based task execution.
Retryable Jobs
Implement automatic retry logic for transient job failures.
Job Status
Track and expose the status of background jobs.
Job Idempotency
Ensure jobs can be safely retried without side effects.
Distributed Job Processing
Coordinate job execution across multiple server instances.
Failure Recovery
Recover from job failures and resume processing.
Duplicate Job Prevention
Prevent the same job from being executed multiple times.
Dead Letter Jobs
Handle jobs that repeatedly fail with dead letter queues.
Monitoring Background Jobs
Monitor job execution, failures, and queue depths.
Phase 17: API Design Interview
Learn to design APIs systematically during technical interviews.
Requirement Clarification
Clarify API requirements before designing endpoints.
Resource Identification
Identify the core resources and their relationships.
Endpoint Design
Design clean, RESTful endpoints for each resource.
HTTP Method Selection
Choose the right HTTP method for each operation.
Request / Response Design
Design request payloads and response structures.
Status Codes
Select appropriate status codes for all scenarios.
Validation
Define validation rules for all request fields.
Pagination
Design pagination for list endpoints.
Authentication & Authorization
Design auth mechanisms for API endpoints.
Idempotency
Ensure idempotent operations for safe retries.
Error Handling
Design consistent error response formats.
Versioning
Plan API versioning strategy from the start.
Rate Limiting
Design rate limiting to protect APIs.
Caching
Identify which endpoints benefit from caching.
Phase 18: Backend Project Architecture
Design complete backend architectures from request entry to database persistence.
Controller -> Service -> Repository -> Database
The standard layered backend architecture explained end-to-end.
Client -> Load Balancer -> Backend -> Cache -> Database
Production architecture with load balancing and caching.
Backend -> Message Queue -> Worker -> Database
Async architecture for background processing.
Why Every Component Exists
Explain the purpose of every component in a backend architecture.
Architecture Tradeoffs
Evaluate tradeoffs between complexity, performance, and maintainability.
Phase 19: Backend Case Studies
Apply backend engineering concepts through guided real-world case studies.
User Authentication Service
Design and build a complete authentication service.
URL Shortener Backend
Build a URL shortener with hashing, redirects, and analytics.
E-commerce Backend
Design product catalog, cart, and checkout for an e-commerce platform.
Order Management System
Build order processing with transactions and state machines.
Payment Processing Backend
Design secure payment processing with idempotency and retry.
Notification Service
Build a multi-channel notification service with async processing.
File Upload Service
Design scalable file uploads with presigned URLs and metadata.
Search Backend
Build a search API with filtering, sorting, and full-text search.
Product Catalog Backend
Design a product catalog with categories, variants, and pricing.
Shopping Cart Backend
Build a shopping cart with session management and persistence.
Food Delivery Backend
Design order tracking, restaurant management, and delivery routing.
Ride Booking Backend
Build ride matching, pricing, and real-time tracking.
Chat Backend
Design real-time messaging with WebSockets and message persistence.
Job Processing System
Build a distributed job processing system with scheduling.
Email Notification Service
Design email sending with templates, queuing, and delivery tracking.
Phase 20: Amazon Interview Preparation
Prepare for backend-focused questions in Amazon SDE-1 interviews.
Backend Interview Questions
Common backend questions asked in Amazon interviews.
Java Backend Questions
Java-specific backend questions for Amazon interviews.
Spring Boot Questions
Spring Boot framework questions commonly asked.
REST API Questions
REST API design and implementation questions.
Database Questions
Database design and optimization interview questions.
Authentication Questions
Authentication and security interview questions.
Caching Questions
Caching strategy and implementation questions.
Concurrency Questions
Threading, synchronization, and concurrency questions.
Security Questions
Backend security and vulnerability prevention questions.
Performance Questions
Performance optimization and scalability questions.
Debugging Questions
Debugging production issues and incident response questions.
Production Incident Questions
How to handle and discuss production incidents in interviews.
API Design Questions
API design questions from Amazon interviews.
Backend Architecture Questions
System architecture and design pattern questions.
System Design Follow-ups
Backend-focused follow-up questions in system design interviews.