System Design Roadmap 2026: HLD + LLD From Scratch to Senior Engineer

If you can build a CRUD app but freeze when asked "how would you scale this to 10 million users?", this roadmap is for you. System design is the skill that separates a coder from an engineer, and it is the round that decides senior offers and salary bands in India. We will cover both HLD (architecture) and LLD (object design) in the order that actually builds intuition.

New to the HLD/LLD split? Read HLD vs LLD first, then come back. The full guided path lives in the System Design track.

You need working knowledge of one backend language and databases. If your Java is shaky, firm it up via the Java track, object-oriented thinking is the foundation of all LLD.

These concepts appear in *every* design discussion:

Client-server model, HTTP, REST, and what a request actually does

Latency vs throughput, and why they trade off

Vertical vs horizontal scaling

Load balancing (round-robin, least-connections, consistent hashing)

Caching: cache-aside, write-through, eviction, TTL

The CAP theorem, consistency vs availability under partition

Make each concept concrete by asking "what problem does this solve and what does it cost?"

SQL vs NoSQL, and when each wins

Indexing and how it changes query cost

Replication (leader-follower) for read scaling and failover

Sharding/partitioning and choosing a shard key

The N+1 query problem and how ORMs hide it

A tiny cache-aside pattern that shows up constantly:

public Product getProduct(String id) {
    Product cached = cache.get(id);
    if (cached != null) {
        return cached;                 // cache hit
    }
    Product fromDb = repository.findById(id);  // cache miss
    cache.put(id, fromDb, Duration.ofMinutes(10));
    return fromDb;
}

Synchronous vs asynchronous communication

Message queues (Kafka, RabbitMQ) for decoupling and buffering

Pub/Sub and event-driven architecture

Idempotency and exactly-once vs at-least-once delivery

Rate limiting (token bucket, leaky bucket)

This is also where microservices enter. Build the hands-on side with the Microservices course.

Circuit breakers, retries, and timeouts to stop cascading failures

Bulkheads to isolate failures

CDN and edge caching for global latency

Monitoring, logging, and distributed tracing

Designing for a 99.9% vs 99.99% availability target

Everything above is the HLD toolkit. Consolidate it in the HLD course.

Now zoom in. LLD is about writing extensible, clean object models.

SOLID principles, internalize each with an example

Design patterns: Strategy, Factory, Observer, Singleton, Decorator, Builder

UML class diagrams and relationships (association, composition, inheritance)

Turning requirements into classes without over-engineering

A Strategy-pattern skeleton, the most-used LLD pattern in interviews:

public interface PaymentStrategy {
    void pay(int amountPaise);
}
public class UpiPayment implements PaymentStrategy {
    public void pay(int amountPaise) { /* UPI flow */ }
}
public class CardPayment implements PaymentStrategy {
    public void pay(int amountPaise) { /* card flow */ }
}
public class Checkout {
    private PaymentStrategy strategy;
    public void setStrategy(PaymentStrategy s) { this.strategy = s; }
    public void checkout(int amountPaise) {
        strategy.pay(amountPaise);   // behavior swapped at runtime
    }
}

Go deeper with the LLD course.

Theory means nothing without reps. Work these, HLD first, then their LLD counterparts:

HLD problems

1URL shortener (hashing, cache, DB scale)

2News feed / timeline (fan-out, ranking)

3Chat system (WebSockets, message ordering)

4Rate limiter (distributed counters)

5Video streaming (CDN, chunking)

LLD problems

1Parking lot

2Elevator system

3BookMyShow seat booking

4Splitwise expense sharing

5In-memory key-value store

WeeksFocus

1-3Fundamentals: scaling, LB, caching, CAP 4-6Databases, sharding, replication 7-8Queues, async, rate limiting 9-10Reliability, CDN, monitoring 11-14LLD: SOLID, patterns, practice problems

System design is a conversation, not an essay. For every problem: (1) clarify requirements and scale, (2) sketch the HLD, (3) name the trade-offs, (4) drill into one component's LLD, (5) discuss bottlenecks and how they fail. Record yourself, or better, defend it against a mentor.

The fastest path is repeated mock interviews with feedback from engineers who have built these systems. Prakalpana runs live online and 1-on-1 system design training covering both HLD and LLD, with real mocks and reviews. WhatsApp or call +91 9945619267 to begin.