What is High Level Design? – Learn System Design
Last Updated :
19 Dec, 2024
In Developing scalable applications, proper planning, and organization play a significant role. High-level design plays an important role in this process by serving as the blueprint of the system’s architecture. It provides a comprehensive view of how components interact and function together which will further help for detailed implementation.
Understanding high-level design is very crucial for developers, architects, and project managers because it allows them to make sure that all stakeholders are aligned with the project objectives. High-level design is also known as macro-level design.
What is High-Level Design
What is High-Level Design?
High-Level Design is a initial step in development of applications where overall structure of a system is planned. High-Level design focuses mainly on how different components of the system work together without getting to know about internal coding and implementation. This helps everyone involving in the project to understand the goals and ensures good communication during development.
Components of High-Level Design
Components of High-Level Design
Understanding the components of high-level design is very important for creating effective systems that meets user needs and technical requirements. Below are the main components of high-level design:
- System Architecture: System architecture is an overview of the entire system which represents the structure and the relationships between various components. It helps to visually represent how different parts interact and function.
- Modules and Components: High-Level design breaks down the systems into modules or components each with specific roles and responsibilities, and has a distinct function that contributes to entire system helping in developing an efficient system.
- Data Flow Diagrams (DFDs): Data Flow Diagrams demonstrates the data movement within the system. They help to understand how information is processed and handled.
- Interface Design: This component focuses on how different modules communicate with one another. It details the application programming interfaces (APIs) and user interfaces necessary for seamless interaction between components.
- Technology Stack: The technology stack are various technologies and tools that will be used in the development of the system. This includes programming languages, frameworks, databases.
- Deployment Architecture: It includes how the system will be hosted and accessed. It includes server configurations, cloud infrastructure, and network considerations.
What is High-Level Design Document?
HLD document consists of data flows, flowcharts, and data structures to help developers in understanding and implement how the current system is being designed intentionally to function. This document is responsible for explaining the connections between system components and operations which depict the logic. The architecture design needed (for the system’s functionality and flow) for each and every module of the system as per the functional requirements.
Purpose and Characteristics of High-Level Design
The purpose of this High-Level Design (HLD) is to add the necessary detailed description to represent a suitable model. This is designed to help with operational requirements and will help to understand how the modules interact. Basically, HLD is a technical representation of functional requirements and the flow of information across components. Characteristics of High-Level Design include:
- A diagram representing each design aspect is included in the HLD (which is based on business requirements and anticipated results).
- Description of hardware, software interfaces, and also user interfaces.
- The workflow of the user’s typical process is detailed, along with performance specifications.
How HLD is different from LLD
High Level Design or HLD is a general system design where we do tradeoffs between different frameworks, components, and different databases and we choose the best considering what the business needs and how the system should work, both in terms of functional and non functional aspects.
Whereas LLD(Low Level Design), translates the HLD into smaller and more specific details, It includes class diagrams, methods, data structures, and algorithms, focusing on how each part will be implemented.
Further Read: Differences between High Level Design(HLD) and Low Level Design(LLD)
After having an adequate understanding of HLD and how it is different from LLD. Let us now discuss the HLD roadmap, which is shown below as an infographic:
How To Design Scalable High-level Design (HLD) Systems
Now in order to design any high-level system, certain terms are listed in a sequential manner so as to connect the dots in order to understand, Roadmap is very important for working professionals because these help us to get a complete binding understanding of how services in real-time are getting scaled at a high level.
How To Design Scalable High-level Design (HLD) Systems
Capacity estimation in system design involves predicting the resources (such as processing power, memory, and bandwidth) required to meet the expected workload. It ensures that a system can handle current and future demands efficiently, helping in the proper allocation of resources and preventing performance bottlenecks.
For example:
Twitter which is recently in newsfeeds these days, here at high-level designing we need to make sure tweets of popular influencers are reaching out to millions of people so how we need to scale our system so service should not be hampered.
We have also shown below the characteristics behavior of a server which is measured across throughput and latency within the system.
Comparison of Throughput and Latency with Concurrency : Behavior Of A Server
2. HTTP and HTTPS and their methods
HTTP(HyperText Transfer Protocol), is used to transfer the data over the web, which enables the communication between clients and server, that helps user to requests resources like HTML pages, messages, videos or images while HTTPS(HyperText Transfer Protocol Secure) is an extension of HTTP which adds a extra layer of security through SSL/TLS encryption. Methods of HTTP include GET, PUT and POST.
Tip: These are also important as per interview perceptive as constraint bounds in interviews in API over when to use what is very important.
Tip: There are 2 ways to send data from server to client:
- Using Websockets
- Using Polling
There are two way to send data from server to clients which are websockets and polling. In a client-server architecture, we are sending a request to server and server sends it back and so in this way communication takes place. But in designing the system biggest problem we face is whether we can implement the client-server model because we can not wait until the server responds.
- Here Web Sockets play a crucial role that solving problems and enabling us to have real-time communication.
- WebSocket is a full-duplex protocol as it allows the application to send and receive data at the same time.
- They are more or less used in every system to be designed because we can not let our system wait for a response.
- They are very useful in Real-time web applications, gaming applications, chat applications.
WebSocket Connection
Another way of sending and receiving data from a server just likely as we do we doing above in the case of web sockets Polling. There are mainly 2 types of polling:
- In short polling, we sent the request. In short polling, the client sends a request to the server and the server immediately sends data at fixed intervals whether the data is updated or not.
- In long polling, the server waits for the client’s request to respond and responds only and only if some new data is available or if some data is being updated.
Short polling vs long polling
Tip: Long polling is preferred over short polling because lesser number of requests are sent in a system.
5. Server-Sent Events(SSE)
It is purposely built as one-way communication from servers to clients in specific design systems. SSE is a technology that helps to push real-time updates from the server to the clients over HTTP connection. SSE enables server to send data automatically as it becomes available. Example of SSE include real-time streaming.
.png)
Server-Sent Events(SSE)
A rate limiter restricts the number of events that can be done in a timeframe by restricting the number of requests a sender can send in a given period of time. Here once the threshold limit is reached now further it blocks the incoming requests as can be seen below media as follows:
Rate limiting
No matter how great a system we design there is always a chance of faults and failure which could be because of hardware issues or software issues(such as running low on memory) or there can be some human error. In such cases we need to provide resiliency through replication, redundancy and availability.
Note: System design interviews starts with open ended designing a specific system which later is bounded with constraints at multiple levels. In order to clear dealing with these bounds in layman language is known as resiliency via implementing common tradeoff in the system. Hence providing resiliency is very crucial in designing complex system designs and also in clearing interviews.
8. Paging
Paging in High-Level Design (HLD) refers to the method of dividing large datasets or content into smaller, manageable pages. This approach improves user experience by allowing users to load data incrementally, reducing initial load times and enhancing performance.
Paging
9. Logging
A log file records details of events occurring in a software application. The details may consist of microservices, transactions, service actions, or anything helpful to debug the flow of an event in the system. Logging is crucial to monitor the application’s flow. This can also be useful for tracking the health and performance of a distributed system, as well as for debugging issues that may arise. There are several approaches to implementing distributed logging, including:
Roadmap to learn HLD
1. Basics of HLD
2. Core Components of HLD
3. Design Principles for HLD
4. Types of HLD Diagrams
5. Architectures and Patterns
6. Interview Preparation for HLD
Similar Reads
What is High Level Design? – Learn System Design
In Developing scalable applications, proper planning, and organization play a significant role. High-level design plays an important role in this process by serving as the blueprint of the system's architecture. It provides a comprehensive view of how components interact and function together which
9 min read
Difference between High Level Design(HLD) and Low Level Design(LLD)
System design involves creating both a High-Level Design (HLD), which is like a roadmap showing the overall plan, and a Low-Level Design (LLD), which is a detailed guide for programmers on how to build each part. It ensures a well-organized and smoothly functioning project. High-Level Design and Low
4 min read
What is Load Balancer & How Load Balancing works?
A load balancer is a crucial component in system design that distributes incoming network traffic across multiple servers. Its main purpose is to ensure that no single server is overburdened with too many requests, which helps improve the performance, reliability, and availability of applications. T
9 min read
What is Content Delivery Network(CDN) in System Design
These days, user experience and website speed are crucial. Content Delivery Networks (CDNs) are useful in this situation. It promotes the faster distribution of web content to users worldwide. In this article, you will understand the concept of CDNs in system design, exploring their importance, func
8 min read
Caching - System Design Concept
Caching is a system design concept that involves storing frequently accessed data in a location that is easily and quickly accessible. The purpose of caching is to improve the performance and efficiency of a system by reducing the amount of time it takes to access frequently accessed data. Table of
10 min read
What is API Gateway | System Design?
An API Gateway is a key component in system design, particularly in microservices architectures and modern web applications. It serves as a centralized entry point for managing and routing requests from clients to the appropriate microservices or backend services within a system. Table of Content Wh
9 min read
Message Queues - System Design
Message queues enable communication between various system components, which makes them crucial to system architecture. Because they serve as buffers, messages can be sent and received asynchronously, enabling systems to function normally even if certain components are temporarily or slowly unavaila
9 min read
Consistent Hashing - System Design
Consistent hashing is a distributed hashing technique used in computer science and distributed systems to achieve load balancing and minimize the need for rehashing when the number of nodes in a system changes. It is particularly useful in distributed hash tables (DHTs), distributed caching systems,
10 min read
Communication Protocols in System Design
Modern distributed systems rely heavily on communication protocols for both design and operation. They facilitate smooth coordination and communication by defining the norms and guidelines for message exchange between various components. Building scalable, dependable, and effective systems requires
6 min read
Network Protocols and Proxies in System Design
In the system design, the effective functioning of networks is essential for seamless communication and data transfer. Network protocols and proxies play important roles in shaping the structure of the system, ensuring efficient data transmission, and improving security. This article explores the si
13 min read
What is Scalability and How to achieve it?
The ability of a system to accommodate a growing load or demand without compromising performance is referred to as scalability. Scalability guarantees that systems can adjust without difficulty, whether a website's user base is growing or a corporation is extending its operations. Using distributed
11 min read
Availability in System Design
In system design, availability refers to the proportion of time that a system or service is operational and accessible for use. It is a critical aspect of designing reliable and resilient systems, especially in the context of online services, websites, cloud-based applications, and other mission-cri
6 min read
Consistency in System Design
Consistency in system design refers to the property of ensuring that all nodes in a distributed system have the same view of the data at any given point in time, despite possible concurrent operations and network delays. In simpler terms, it means that when multiple clients access or modify the same
9 min read
CAP Theorem in System Design
The CAP Theorem explains the trade-offs in distributed systems. It states that a system can only guarantee two of three properties: Consistency, Availability, and Partition Tolerance. This means no system can do it all, so designers must make smart choices based on their needs. This article explores
8 min read
Component Based Diagram - Unified Modeling Language (UML)
Component-based diagrams are essential tools in software engineering, providing a visual representation of a system's structure by showcasing its various components and their interactions. These diagrams simplify complex systems, making it easier for developers to design, understand, and communicate
9 min read
Sequence Diagrams - Unified Modeling Language (UML)
A Sequence Diagram is a key component of Unified Modeling Language (UML) used to visualize the interaction between objects in a sequential order. It focuses on how objects communicate with each other over time, making it an essential tool for modeling dynamic behavior in a system. Sequence diagrams
11 min read
Monolithic Architecture - System Design
Monolithic architecture, a traditional approach in system design, which contains all application components into a single codebase. This unified structure simplifies development and deployment processes, offering ease of management and tight integration. However, because of its rigidity, it is diffi
8 min read
What are Microservices?
Microservices are an architectural approach to developing software applications as a collection of small, independent services that communicate with each other over a network. Instead of building a monolithic application where all the functionality is tightly integrated into a single codebase, micro
12 min read
Event-Driven Architecture - System Design
With event-driven architecture (EDA), various system components communicate with one another by generating, identifying, and reacting to events. These events can be important happenings, like user actions or changes in the system's state. In EDA, components are independent, meaning they can function
11 min read
Serverless Architecture
By providing a new method where server management is no longer an issue, serverless architecture is completely changing how companies develop and implement apps. Because cloud providers handle the underlying infrastructure—including scaling, maintenance, and provisioning—developers may concentrate e
8 min read