Technical documentation creation is a critical step for a successful IT project, no matter whether it is big or small. When you have a team of people working on the same product, building it for someone else, communication is vital.
Technical documentation (TD) is one of the ways to bring everyone on the same page. It provides and explains the logical design of the upcoming (or existing) code and sets the expectations for features and modules the developer needs to create.
From a business standpoint, it is also an important step. Good technical documentation for a software project helps lower costs (especially sudden overhead), achieve high reliability, create a maintainable product, and streamline communication between the business and IT people (who often think differently).
There are several types of technical documentation, and in this article, we’ll look at such things as HLD, LLD, and DLD. You’re not sure what these mean and when to use which one? Read on.
What should you as a client know about LLD, HLD, and DD?
It’s important for you to understand the differences between high-level design (HLD), detailed design (DD), and low-level design (LLD) in order to be able to effectively communicate with the development team and make informed decisions about their software project.
Here are a few key things that you should know about each of these design stages:
- High-level design (HLD): HLD is the first step in the design process and provides a broad overview of the software architecture. It describes the main components of the system and their interactions, as well as the main algorithms and data structures that will be used. It’s important for a client to understand the HLD so they can ensure that the system’s functionality, performance, and scalability meet their requirements.
- Low-level design (LLD): LLD is the next step after HLD, and it provides a more detailed, technical representation of the system. It defines the specific data structures and algorithms that will be used, as well as the interfaces between the components of the system. It’s important for a client to understand the LLD so they can ensure that the proposed design is feasible and that the system will meet their requirements.
- Detailed Design (DD): DD is an extension of the LLD, and it provides a very detailed design of the software system. The DD includes specific, detailed descriptions of the data structures, algorithms, interfaces, and other elements of the system, as well as pseudocode or other representations of the code that will be written. It’s important for the client to understand DD so they can ensure that the design of the system meets their requirements and is implementable.
In general, you should be aware that these design stages are important in order to ensure that the software meets their requirements and is feasible to implement. It is also important for you to be aware that these design stages are iterative, and that your feedback should be incorporated into each of these stages.
Types of Design
High-Level Design (HLD)
High-Level Design (HLD) is a general system design. In software development, high-level design (HLD) is the process of creating an abstract representation of a software system before detailing the lower-level design. The high-level design provides a broad overview of the software architecture, including the overall structure and organization of the system, the main components and their interactions, and the main algorithms and data structures that will be used.
It includes the description of the following parts:
- System architecture
- Database design
- Brief mention of all the platforms, systems, services, and processes the product would depend on
- Brief description of relationships between the modules and system features
All the data flows, flowcharts, data structures, etc. are in these docs so that developers can understand how the system is expected to work with regard to the features and the database design.
The goal of HLD is to provide a clear and comprehensive understanding of the system’s functionality, performance, and scalability, as well as its key constraints and trade-offs. This information is used to guide the development of the system and to ensure that it meets the requirements and satisfies the constraints of the problem domain.
The HLD process typically involves a number of steps, including:
- Identifying the system’s requirements and constraints
- Identifying the key components and their interfaces
- Identifying the main algorithms and data structures
- Identifying the system’s overall structure and organization
- Identifying any external dependencies or interfaces
- Identifying any performance or scalability concerns
The output of the HLD process is typically a set of diagrams, such as block diagrams, entity-relationship diagrams, or class diagrams, that describe the system’s architecture at a high level. The HLD is usually reviewed by the stakeholders, including the customer, development team, and management, to ensure that it meets their expectations and that the proposed design is feasible and will meet the requirements.
It’s important to note that the High-Level Design is a non-technical representation of the system, it does not include low-level details like, for example, specific programming languages, libraries, or any other technical details, which will be explained in the Low-Level Design (LLD).
Low-Level Design (LLD)
Low-Level Design (LLD) is a component-level design process that follows a step-by-step refinement process. It provides the details and definitions for the actual logic for every system component. It is based on HLD but digs deeper, going into the separate modules and features for every program in order to document their specifications.
Are LLD and DLD the same or is there a difference?
In software development, low-level design (LLD) and detailed design (DD) refers to similar but slightly different stages in the design process.
LLD is the process of taking the high-level design (HLD) and creating a more detailed, technical representation of the system. The LLD defines the specific data structures and algorithms that will be used, as well as the interfaces between the components of the system. It also addresses issues such as error handling and recovery and defines any necessary data validation rules. The goal of LLD is to provide a clear, step-by-step plan for the implementation of the system, including detailed pseudocode or other representations of the algorithms and data structures that will be used.
Detailed Design (DD) is a phase in the software development process where the software design is transformed into a detailed design that can be used to guide the implementation of the system. DD is the next step after HLD and LLD, it could include all the elements of LLD, but with more depth and detail. It includes specific, detailed descriptions of the data structures, algorithms, interfaces, and other elements of the system, as well as pseudocode or other representations of the code that will be written. DD may also specify any specific design patterns that will be used in the implementation of the system.
In summary, Low-Level Design is the process of taking the high-level design and creating a more detailed, technical representation of the system. The Detailed Design is an extension of the Low-Level Design, which provides a very detailed design of the software system.
Detailed-Level Design (DD)
Detailed Level Design (DLD) is the most detailed technical document, which describes user stories, error processing algorithms, state transitions, logical sequences, and others. DLD describes the interaction of every low-level process with each other. As we noted above, DLD is the extension of the Low-Level Design (LLD.)
You might also be interested: What Code Repository to Choose for Your Project
HLD vs LLD
|High-Level Design||Low-Level Design|
|HLD is a macro-level design or system design. It allows seeing the “Big Picture.”||LLD is a micro-level design or detailed design. It allows seeing the minutiae.|
|The overall architecture of the application and the network design as well as relationships between various system modules and functions.||A detailed description of each and every module that is mentioned in the high-level design (HLD.)|
|Target audience: clients, designers, reviewers, management team members, and program and solution teams.||Target audience: designer teams, operation teams, and implementers.|
|Main idea: HLD is required to understand the flow across various system entities. For example, if you have several integrated solutions, HLD describes how everything works as a single organism.||Main idea: provides information for building the product, its configuration, and troubleshooting. For example, if you have several solutions, LLD describes each one in detail, like a single organ in a body.|
|Goal: converts business goals and requirements into a high-level solution.||Goal: converts a high-level solution into a detailed solution ready for building.|
|Chronologically, HLD is created before any other technical documentation.||Chronologically, LLD is created after the high-level design document.|
|HLD Creator: Solutions Architect.||LLD Creator: Designers & Developers with PM.|
|Input Data: software requirement specifications (SRS.)||Input Data: reviewed and authorized high-level design document (HLD.)|
|Results: database design, functional design, and review record.||Results: program specification and unit test plan.|
Here is a convenient infographic that shows the difference between HLD and LLD: