System Design Academy · Java / Spring

System design,
from first principles to production.

From “what is a server?” to consensus and storage engines: 19 phases, 221 topics, 18 LLD problems and 39 HLD systems, each labelled Beginner, Intermediate, or Advanced. Every topic starts with a real-life analogy and ends the same way: explain it without notes, implement it, break it, and state the trade-off.

New here? Start from zero The full roadmap First 10 sessions Interview templates

Phases: 19
Topics: 221
LLD problems: 18
HLD systems: 39

The method

The Learning Loop

Apply it on every topic →

01
Learn
Study the concept with the tutorial open.
02
Close the tutorial
Put the notes away.
03
Explain without notes
Teach it out loud — this is the pass/fail gate.
04
Implement
Write the code from the design, not from memory of the sample.
05
Break it
Change a requirement and watch which seams exist.
06
Fix it
Every break reveals a missing abstraction or test.
07
Explain trade-offs
State the cost of your choices out loud.

Curriculum

The roadmap, in six parts

Full roadmap with progress →

Start Here

How software systems work, the vocabulary, and the mindset. No experience needed.

PHASE Start · 5 topicsBeginner

Start Here: How Software Systems Work

Zero assumptions. What a client, a server, an API, and a database actually are, where data lives, the vocabulary every design discussion uses, and how one app grows from 1 user to a million.

PHASE 0 · 6 topicsBeginner

System Design Mindset

Learn the loop. Never memorize an answer again.

Foundations · LLD

OOP, SOLID, design patterns and low-level designs with complete Java.

PHASE 1 · 5 topicsBeginner

OOP + SOLID + UML

The vocabulary every LLD answer is graded on.

PHASE 2 · 22 topicsBeginner

Design Patterns

The 22 GoF patterns that show up in LLD interviews — each tied to the problem it solves, with Java.

PHASE 3 · 7 topicsIntermediate

LLD Foundations

The repeatable method behind every LLD answer.

PHASE 4 · 18 topicsIntermediate

LLD Real Problems

18 problems, from Parking Lot to LRU Cache and Pub/Sub — with production-style Java.

Core Systems

Concurrency, networking, API design, and identity: the floor every answer stands on.

PHASE 5 · 11 topicsAdvanced

Concurrency for LLD

Threads, locks, pools and the four shared-state bugs every LLD hides.

PHASE 6 · 10 topicsBeginner

Networking Fundamentals

HTTP, HTTPS, TCP/UDP, WebSockets, REST, gRPC — the layer HLD answers sit on.

PHASE 6B · 7 topicsIntermediate

API Design & Identity

Designing APIs other teams love to use, and knowing who is calling them: resource design, pagination, versioning, idempotency and errors, REST vs GraphQL vs gRPC, authentication (sessions, JWT, OAuth 2.0, OIDC, SSO), and authorization (RBAC, ABAC, ReBAC).

Data at Scale

Databases, indexing, replication, sharding and the scalability arithmetic.

PHASE 7 · 7 topicsBeginner

Database Fundamentals

Tables, ACID, isolation levels, indexes, joins, normalization.

PHASE 8 · 10 topicsIntermediate

Database Scaling

Replication, partitioning, sharding, consistent hashing — from one box to many.

PHASE 9 · 9 topicsIntermediate

Scalability

Vertical, horizontal, stateless, load balancers, CDNs, and the numbers behind it all.

HLD · Distributed

Caching, Kafka, microservices, real HLD systems, consistency, and the building blocks behind them.

PHASE 10 · 16 topicsIntermediate

Caching + Messaging

Cache placement, cache invalidation, Redis, Kafka — where latency and decoupling actually live.

PHASE 11 · 15 topicsIntermediate

Microservices Architecture

Boundaries, discovery, resilience, sagas and the patterns that keep a fleet from eating itself.

PHASE 12 · 39 topicsAdvanced

HLD Real Systems

39 real systems across 6 levels, from URL shortener to a distributed message queue — every one answers the same 13-section template.

PHASE 13 · 13 topicsAdvanced

Advanced Distributed Systems

CAP, PACELC, consistency models, quorums, consensus, event sourcing, CQRS.

PHASE 13B · 8 topicsAdvanced

Data-Intensive Building Blocks

The internals senior engineers reach for: storage engines (B-tree vs LSM), unique ID generation, Bloom filters and sketches, geospatial indexes, clocks and ordering, gossip and Merkle trees, stream vs batch processing, and backpressure.

Production · Mastery

Reliability, DR, observability, security, cost, then the templates that close interviews.

PHASE 14 · 8 topicsAdvanced

Production Architecture

Reliability, disaster recovery, observability, security, multi-tenancy, cost — the engineer's layer.

PHASE 15 · 5 topicsIntermediate

Interview Mastery

The two templates that turn 50+ problems into one repeatable process.

Where should I start?

Pick a path for your goal

I'm new to this

Students and developers who haven't designed systems before.

Then continue in order from Phase 2.

Interview in 4–6 weeks

You know the basics and need to perform in LLD and HLD rounds.

Do the top 10 systems in Phase 12 and time yourself with the templates.

Go deep (senior → staff)

You design real systems and want the internals and the production reality.

Pair each topic with its 'Run it in production' links into the DevOps courses.

Design it here, run it there

From whiteboard to production

Every design idea in this course has a hands-on twin in the DevOps courses. Caching becomes Redis you tune and fail over, queues become Kafka you operate, load balancers become Nginx you configure, and reliability becomes SLOs and on-call. Look for the Run it in production section at the end of each topic.

Stateful Systems

PostgreSQL, Kafka, Redis, OpenSearch, and performance: operate what phases 7–10 design.

Networking

TCP, DNS, HTTP, TLS, and load balancers, hands-on behind phases 6 and 9.

Production architecture

HA, multi-region, and DR, the practical side of phase 14.

The DevOps path

The full order from Linux to platform engineering, with 12 projects.

Week one

Your first 10 study sessions

01System Design FundamentalsPhase 0 — the 8 questions, LLD vs HLD, NFRs, trade-offs.
02OOP relationshipsEncapsulation, composition, aggregation, association; composition over inheritance.
03SOLIDEach letter tied to the production problem it prevents.
04UML + object responsibilitiesClass relationships + who owns which behavior.
05Factory + BuilderCreational patterns with runnable Java.
06Strategy + ObserverThe two behavioral patterns that appear in every LLD.
07Adapter + DecoratorStructural patterns for integration and stacking.
08State + CommandVending machines and undo-aware systems.
09LLD: Parking LotYour first full problem with complete Java + concurrency.
10LLD: Vending MachineState pattern applied end to end.

Open the full plan →

The templates

One process, any interview

HLD — the 13-step answer

01Requirements — Functional + non-functional, written down. Ask the 8 questions from Phase 0.
02Scale estimation — QPS, peak, storage, bandwidth, memory — order-of-magnitude math.
03APIs — Verbs, paths, request/response shapes, status codes.
04Data model — Core tables + access patterns + consistency budget per path.
05High-level architecture — Clients, LB, services, data stores, queues, caches, CDN.

…and 8 more, with the LLD counterpart.

See both templates →

The ₹0 resource stack

→System Design Primer— LLD + HLD practice
→Code-N-Code Java Design Patterns— LLD – Java design patterns
→AlgoMaster — Awesome System Design Resources— HLD concepts
→Your own Java / Spring Boot projects— Java implementation
→Refactoring.Guru Design Patterns— Pattern reference

Open the resource stack →

Journal

Latest essays

All posts →

2026-09-206 min

The 8 Questions of System Design

Every system design interview is the same eight questions wearing different clothes. Learn them once and you can design anything.

2026-09-158 min

Kafka Without the Hype

Producer, topic, partition, broker, consumer group, offset. Six words. The whole mental model is built from them — here's how, with no marketing fog.

2026-09-106 min

SOLID Is About Production, Not Purity

Stop memorizing the letters. Each SOLID principle is the scar of a production incident. Learn the incidents.

Command Palette

System design,from first principles to production.