What high level design encompasses in HLD - System Design Exercise

Design: High Level Design Overview

In scope: system components, interactions, data flow, technology choices. Out of scope: detailed code, database schema, deployment specifics.

Functional Requirements

FR1: Define the main components of a system

FR2: Show how components interact

FR3: Outline data flow between components

FR4: Identify key technologies and protocols

FR5: Provide a clear, simple architecture diagram

Non-Functional Requirements

NFR1: Design must be understandable by non-technical stakeholders

NFR2: Focus on system structure, not detailed implementation

NFR3: Must support scalability and maintainability

NFR4: Avoid low-level code or database schema details

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

❓ Question 5

Key Components

User Interface (UI)

API Gateway or Load Balancer

Application Servers or Services

Databases or Data Stores

Cache systems

External services or third-party APIs

Design Patterns

Client-Server pattern

Layered architecture

Microservices vs Monolithic

Event-driven communication

Caching strategies

Reference Architecture

  +-------------+       +----------------+       +-------------+
  |   Clients   | <---> | API Gateway /   | <---> | Application |
  | (Web/Mobile)|       | Load Balancer  |       | Servers     |
  +-------------+       +----------------+       +-------------+
                                   |                      |
                                   v                      v
                            +-------------+        +-------------+
                            |   Cache     |        |  Database   |
                            +-------------+        +-------------+
                                   |
                                   v
                          +------------------+
                          | External Services |
                          +------------------+

Components

Clients

Web browsers, Mobile apps

Users interact with the system through these interfaces

API Gateway / Load Balancer

Nginx, AWS ALB

Distributes requests and routes them to appropriate services

Application Servers

Node.js, Java Spring Boot, Python Flask

Process business logic and handle user requests

Cache

Redis, Memcached

Store frequently accessed data to reduce latency

Database

PostgreSQL, MongoDB

Persist system data reliably

External Services

Third-party APIs

Provide additional features or data not managed internally

Request Flow

1. Client sends request to API Gateway

2. API Gateway routes request to appropriate Application Server

3. Application Server checks Cache for data

4. If data not in Cache, Application Server queries Database

5. Application Server processes data and sends response back through API Gateway

6. API Gateway returns response to Client

7. Application Server may call External Services as needed

Scaling Discussion

Bottlenecks

API Gateway can become a single point of failure

Application Servers may be overwhelmed with requests

Database can become a bottleneck under heavy read/write load

Cache size limits may reduce hit rate

External Services latency can slow down responses

Solutions

Use multiple API Gateway instances with health checks and failover

Scale Application Servers horizontally with auto-scaling

Use database replication and sharding to distribute load

Increase cache size and implement cache eviction policies

Implement asynchronous calls or circuit breakers for External Services

Interview Tips

Time: Spend 10 minutes understanding requirements and clarifying scope, 20 minutes drawing and explaining the architecture, 10 minutes discussing scaling and trade-offs, 5 minutes for questions.

Explain main components clearly and their roles

Describe how data flows through the system

Highlight technology choices and why they fit

Discuss how the design supports scalability and reliability

Mention trade-offs and possible improvements