Backend Architecture & System Design Fundamentals

Layered architecture, caching, scaling and the system design basics asked in entry-level interviews.

This section is being written. There are no lessons in it yet: below is the plan for what it will cover. It opens in the syllabus as soon as its first lessons are ready.

What you will be able to do

Explain how a request flows through a typical backend: load balancer, app servers, cache and database
Describe layered and modular monolith architecture and when each fits
Design APIs that stay correct and fast as traffic grows
Explain caching, indexing, replication and sharding in simple terms with trade-offs
Make rough capacity estimates and answer classic entry-level system design questions

What it will cover

21.1Thinking About Systems
What system design means and how interviewers judge a fresher's answer.
- Functional vs non-functional requirements
- Latency, throughput and availability
- Single server to many servers: how systems grow
- Trade-offs: there is no perfect design
- A step-by-step approach for design rounds
21.2Backend Architecture
Ways to structure a backend application and its code.
- Layered architecture revisited at system level
- Monolith and modular monolith
- Microservices: what they are and why not to start with them
- Stateless application servers
- Synchronous calls vs background jobs (the idea of queues)
21.3API Design at Scale
Keep APIs reliable when many clients call them at once.
- Idempotency keys for safe retries
- Pagination for very large lists
- Timeouts and retries with backoff
- Backward-compatible changes
- Handling slow work asynchronously
21.4Caching
Serve common data faster by keeping a copy closer to the user.
- Where caches live: browser, CDN, application, database
- Cache-aside, write-through and expiry
- Cache invalidation and stale data
- Eviction policies: LRU and TTL
- Spring's @Cacheable with an in-memory cache; Redis as the usual shared cache
21.5Databases at Scale
How databases cope when data and traffic grow.
- Indexes and query tuning as the first step
- Connection pools and their limits
- Replication and read replicas
- Sharding and partitioning (concept)
- SQL vs NoSQL: choosing for the right reasons
- CAP theorem in plain words
21.6Load Balancing & Scaling
Spread traffic across servers so the system keeps working when one fails.
- Vertical vs horizontal scaling
- Load balancer algorithms: round robin, least connections
- Health checks and failover
- Sticky sessions and why stateless is easier
- CDNs for static content
21.7Rate Limiting & Protection
Protect a service from overload and abuse.
- Why rate limit
- Fixed window, sliding window and token bucket
- Implementing a token bucket in Java
- Where to apply limits: per user, per IP, per API key
- Returning 429 and Retry-After
21.8Back-of-the-Envelope Estimation
Make quick, reasonable estimates of traffic and storage.
- Useful numbers: requests per second, bytes per record
- Estimating daily users to requests per second
- Estimating storage over years
- Using estimates to pick a design
21.9Classic Design Questions
Work through the system design questions most often asked of freshers.
- URL shortener
- Pastebin
- Rate limiter as a service
- Notification system
- News feed (basic version)
- Explaining the design of your own project
21.10System Design Practice & Review
Practise design rounds end to end and review common mistakes.
- Mock design round with a checklist
- Drawing clear architecture diagrams
- Common mistakes in fresher answers
- System design interview questions and short answers

Start with what’s live

These sections are ready to study now.

See the whole roadmap

What you will be able to do

Explain how a request flows through a typical backend: load balancer, app servers, cache and database

Describe layered and modular monolith architecture and when each fits

Design APIs that stay correct and fast as traffic grows

Explain caching, indexing, replication and sharding in simple terms with trade-offs

Make rough capacity estimates and answer classic entry-level system design questions

What it will cover

21.1Thinking About Systems

What system design means and how interviewers judge a fresher's answer.

Functional vs non-functional requirements
Latency, throughput and availability
Single server to many servers: how systems grow
Trade-offs: there is no perfect design
A step-by-step approach for design rounds

21.2Backend Architecture

Ways to structure a backend application and its code.

Layered architecture revisited at system level
Monolith and modular monolith
Microservices: what they are and why not to start with them
Stateless application servers
Synchronous calls vs background jobs (the idea of queues)

21.3API Design at Scale

Keep APIs reliable when many clients call them at once.

Idempotency keys for safe retries
Pagination for very large lists
Timeouts and retries with backoff
Backward-compatible changes
Handling slow work asynchronously

21.4Caching

Serve common data faster by keeping a copy closer to the user.

Where caches live: browser, CDN, application, database
Cache-aside, write-through and expiry
Cache invalidation and stale data
Eviction policies: LRU and TTL
Spring's @Cacheable with an in-memory cache; Redis as the usual shared cache

21.5Databases at Scale

How databases cope when data and traffic grow.

Indexes and query tuning as the first step
Connection pools and their limits
Replication and read replicas
Sharding and partitioning (concept)
SQL vs NoSQL: choosing for the right reasons
CAP theorem in plain words

21.6Load Balancing & Scaling

Spread traffic across servers so the system keeps working when one fails.

Vertical vs horizontal scaling
Load balancer algorithms: round robin, least connections
Health checks and failover
Sticky sessions and why stateless is easier
CDNs for static content

21.7Rate Limiting & Protection

Protect a service from overload and abuse.

Why rate limit
Fixed window, sliding window and token bucket
Implementing a token bucket in Java
Where to apply limits: per user, per IP, per API key
Returning 429 and Retry-After

21.8Back-of-the-Envelope Estimation

Make quick, reasonable estimates of traffic and storage.

Useful numbers: requests per second, bytes per record
Estimating daily users to requests per second
Estimating storage over years
Using estimates to pick a design

21.9Classic Design Questions

Work through the system design questions most often asked of freshers.

URL shortener
Pastebin
Rate limiter as a service
Notification system
News feed (basic version)
Explaining the design of your own project

21.10System Design Practice & Review

Practise design rounds end to end and review common mistakes.

Mock design round with a checklist
Drawing clear architecture diagrams
Common mistakes in fresher answers
System design interview questions and short answers