What is High Level Design (HLD)?

High Level Design (HLD), also called system architecture design, focuses on the big-picture view of the system. It identifies the major components (services, databases, caching layers, message queues, load balancers), how they communicate with each other, and the data flow through the system. HLD is technology-agnostic at first and gradually incorporates technology decisions.

HLD artifacts include architecture diagrams (typically using boxes and arrows), component interaction diagrams, data flow diagrams, and deployment architecture. Stakeholders include architects, engineering managers, and senior developers who need to understand the system at a strategic level.

// HLD is about component-level design, not code.
// This diagram (conceptual) shows how components relate:
//
// [Client] --> [Load Balancer] --> [Web Server Cluster]
//                                         |
//                                    [Cache Layer]
//                                         |
//                              [Database Primary] <--> [Database Replica]
//
// In contrast, LLD would define the classes inside the Web Server.

What is Low Level Design (LLD)?

Low Level Design (LLD) takes the components identified in HLD and drills down into their internal structure. For each component, LLD defines the classes, interfaces, methods, data structures, algorithms, error handling strategies, and design patterns used. LLD is implementation-focused and language-specific — it can be directly translated into code.

LLD artifacts include class diagrams (UML), sequence diagrams for important interactions, state machine diagrams, detailed API specifications, data structure definitions, and algorithm pseudocode. Stakeholders are the developers who will implement the system and the code reviewers who will verify the implementation.

// LLD example: detailed class design for the Web Server component
public class RequestHandler {
    private final AuthenticationService authService;
    private final RateLimiter rateLimiter;
    private final CacheManager cache;
    private final DatabaseClient dbClient;

    public RequestHandler(AuthenticationService authService,
                          RateLimiter rateLimiter,
                          CacheManager cache,
                          DatabaseClient dbClient) {
        this.authService = authService;
        this.rateLimiter = rateLimiter;
        this.cache = cache;
        this.dbClient = dbClient;
    }

    public Response handleRequest(Request request) {
        if (!authService.authenticate(request)) {
            return Response.unauthorized();
        }
        if (!rateLimiter.allowRequest(request.getClientId())) {
            return Response.rateLimited();
        }
        // ... detailed request processing logic
        return Response.success(data);
    }
}

HLD vs LLD — Comparison Table

The table below summarizes the key differences between HLD and LLD across multiple dimensions. Use this as a quick reference when deciding how much detail is appropriate for your current design phase.

// Comparison Table (conceptual representation)
// +-------------------+--------------------------------+----------------------------------+
// | Dimension         | HLD (High Level Design)         | LLD (Low Level Design)           |
// +-------------------+--------------------------------+----------------------------------+
// | Scope             | Entire system architecture      | Individual component internals   |
// | Abstraction Level | High (components, services)    | Low (classes, methods, fields)   |
// | Audience          | Architects, managers, seniors  | Developers, code reviewers        |
// | Artifacts         | Architecture diagrams, DFD      | Class diagrams, sequence diagrams |
// | Technology        | Technology-agnostic first       | Language-specific (Java, C++)     |
// | Detail            | What and where                 | How exactly                      |
// | Change Frequency  | Low (weeks to months)          | High (daily during implementation)|
// | Example           | "Use Redis cache, MySQL DB"    | "CacheManager class with LRU eviction"|
// +-------------------+--------------------------------+----------------------------------+