<< back to Guides
🏗️ System Design: Creating a High-Level Design (HLD)
High-Level Design (HLD) provides a bird’s-eye view of the architecture. It focuses on the overall structure, key components, communication, and data flow — without diving into implementation details.
🎯 Purpose of HLD
- Aligns business needs with technical implementation
- Enables discussions between engineering, product, and stakeholders
- Serves as a blueprint for Low-Level Design (LLD)
- Helps evaluate trade-offs, scalability, and cost
🧩 Key Elements of a High-Level Design
1. System Context Diagram
Describes how the system fits into the external world.
- Who are the users?
- What external systems does it integrate with?
- What protocols (HTTP, WebSocket, gRPC, etc.)?
2. Component Breakdown
Break the system into major modules or services.
- API Gateway
- Authentication Service
- User Service
- Notification Service
- Database Layer
3. Communication Patterns
How components talk to each other.
- Synchronous (REST, gRPC)
- Asynchronous (Kafka, RabbitMQ, SQS)
4. Data Flow & Storage
Define what data is stored and how it flows between components.
- DBs: PostgreSQL, MongoDB, Redis
- Caches: Redis/Memcached
- File Storage: S3, Blob Storage
5. Availability & Scalability Plans
Show how the system will scale and handle failures.
- Load Balancers (HAProxy, ALB)
- Auto-scaling groups
- Database replication
- Failover mechanisms
6. Technology Stack
Summarize key technologies.
- Frontend: React
- Backend: Node.js, Spring Boot
- DB: PostgreSQL
- Queue: Kafka
- CI/CD: GitHub Actions
7. Key Non-Functional Requirements
- Latency requirements (e.g., < 200ms for key APIs)
- Throughput (e.g., 1,000 RPS peak)
- Uptime SLAs (e.g., 99.9%)
- Security (e.g., JWT, OAuth, mTLS)
📐 Sample HLD Process (Step-by-step)
1. Understand requirements (functional + non-functional)
2. Identify main actors and use cases
3. Draft system context diagram
4. Define main components/services
5. Design interactions and APIs between components
6. Choose tech stack based on trade-offs
7. Plan for scaling, failure, and observability
8. Review with stakeholders (team, architects)
📝 Example: Social Media Feed System
- API Gateway
- Handles client traffic, forwards to backend
- Feed Service
- Aggregates posts from followed users
- Post Service
- Creates, updates, stores posts
- User Service
- Manages profiles, followers
- Redis Cache
- Stores recent posts for quick access
- PostgreSQL
- Stores posts and user metadata
- Kafka
- Event-driven updates between services
📊 Diagram Examples (Not rendered here)
- System Context Diagram
- Component Diagram
- Sequence Diagrams (optional)
- Deployment View (how components are deployed)
✅ Tips for a Good HLD
- Avoid implementation details (leave those for LLD)
- Communicate ideas visually and simply
- Make it reviewable by non-engineers
- Highlight trade-offs made (e.g., consistency vs availability)
- Keep it versioned and up to date