What is HLD/LLD? “Higher-level design” (basic design) / “Lower-level design” (detailed design)

What is HLD (High-Level Design)?

HLD (High-Level Design) is a process that refers to “high-level design” (basic design) in the development process of systems and software. It defines the overall system structure, its main components, the relationships between them, and the overall system architecture.

In English-speaking countries, “HLD (High-Level Design)” is a commonly used term, especially when referring to the initial phase of designing the structure and architecture of an entire system.

Purpose of HLD

• Create a design that provides an overview of the entire system and create a common understanding among the development team and stakeholders.
• It provides a foundation for actual implementation and progression to “low-level design” (LLD).
• Create materials to explain the overall picture of the system to clients and senior management.

HLD Contents

The main things we cover at HLD are:

1. System Architecture:
   • Diagram of the entire system (e.g., client, server, database relationships).
   • Data flow between modules.
2. Key Components and Their Roles:
   • Features and overview of each component or module.
   • Interfaces between components (such as APIs and communication protocols).
3. External Specifications:
   • How do you work with users and external systems?
   • Definition of external interfaces.
4. Non-functional requirements:
   • System performance, scalability, availability, security, etc.
5. Overview of the technology used:
   • Such as the frameworks, programming languages, and tools you use.

If you replace HLD with Japanese

HLD is expressed in Japan system development terminology as follows:

1. Basic Design:
   • The most common term in the IT industry in Japan.
   • It is the process of defining the structure and external specifications of the entire system, which corresponds to the content of the HLD.
   • Higher-level design:
     • It is an expression that is close to a literal translation and is used to explain the contents of HLD as it is.
     • In the IPA (Information Technology Promotion Agency) document, it is described as high-level design (HLD).
2. Outline design:
   • It is sometimes used to briefly describe HLD in practice.
3. Architectural Design:
   • It refers to the design phase with a focus on the technical side and covers part of the HLD.

HLD’s Concrete Positioning

HLD is implemented early in the “design phase” of the system development process. It plays a role in the following processes:

1. Requirements Definition:
   • Organize user needs and business requirements.
2. High-Level Design (HLD):
   • Define the overall system structure and key components.
3. Low-Level Design (LLD):
   • Detailed design of each module or function (classes, functions, data structures, etc.).
4. Implementation:
   • Real code development.

Summary: HLD (High-Level Design)

HLD (High-Level Design), widely recognized as “basic design” or “high-level design” in Japanese, refers to the process of defining the structure and key components of the entire system. This process provides a foundation for organizing the “big picture” of the system early in the development process and moving on to the next “detailed design”.

What is LLD (Low-Level Design)?

LLD (Low-Level Design) refers to the stage of defining “low-level design” (detailed design) in the design of software and systems. Based on the outline of the overall system structure and key components defined in the High-Level Design (HLD), we design specific implementation methods for each module or function.

Features of LLD

1. Detailed Modular Design:
   • Define the internal structure of each module.
   • Detailed description of class, function, data structure, and algorithm specifications.
2. Designing Implementation Perspectives:
   • Provides the level of detail you need to get started with real coding.
3. Emphasis on Technical Perspectives:
   • Designed to match the programming language and framework used.
4. Relationship with HLD:
   • While HLD presents the big picture, LLD is a design phase that delves into the “details of each part”.

Key Contents Included in LLD

The LLD provides a plan for specific implementation, including:

1. Class Design:
   • Attributes (properties), methods (functions), and access controls (e.g., public/private) of the class.
   • Class diagram and inheritance relationship diagram.
2. Data Structure:
   • The storage format of variables and data.
   • Arrays, lists, trees, database schemas, etc.
3. Algorithm Details:
   • Process flow and computational logic.
   • Written in flowcharts and pseudocode.
4. How to implement the interface:
   • Communication between modules and classes.
   • API and protocol design.
5. Error Handling:
   • What to do if an error occurs.
   • Logging, exception handling design.
6. Unit Test Plan:
   • Test case design on a module-by-module basis.
   • Make sure each feature is working correctly.

Difference Between HLD and LLD

Instructions for creating an LLD

1. Check the HLD:
   • Start working on the overall system picture defined in the HLD.
2. Module Disassembly:
   • Each module defined in HLD is broken down into more detailed parts.
3. Designing Classes and Functions:
   • Design classes and functions in detail, clarify roles and data flows.
4. Data Structure Selection:
   • Decide which data structure to use (e.g., lists, dictionaries, arrays, etc.).
5. Preparation of design documents:
   • For each module and function, class diagrams and flowcharts are included in the design document.

When expressing LLD in Japanese

The Japanese system development terms corresponding to LLD are as follows:

1. Detailed Design:
   • The most commonly used term in Japan’s development field.
   • The process of designing each module, class, and function.
2. Lower Level Design:
   • It is sometimes used as a literal translation of LLD, but in practice it is often recognized as “detailed design”.
   • In the IPA (Information Technology Promotion Agency) document, it is described as a low-level design (LLD).

Summary: LLD (Low-Level Design)

LLD (Low-Level Design) is a process that defines the details required to implement modules and functions based on an overview of the entire system defined in HLD. Specifically, we design classes, functions, algorithms, data structures, interface specifications, etc. In the Japan development process, it is generally recognized as “detailed design”.

Related Information Related to HLD/LLD

1. IPA (Information Technology Promotion Agency):
   • Explain the “basic design” equivalent to HLD.
   • IPA IT Skills Standards
     https://www.ipa.go.jp/jinzai/skill-standard/plus-it-ui/itss/download_v3_2011.html
2. IEEE Standard 1016:
   • Provides definition of HLD as a standard for software design.
   • IEEE official website
     https://standards.ieee.org/
3. PMI (Project Management Body of Knowledge Guide):
   • Define HLD in the project design process.
   • PMI Official Website
     https://www.pmi.org/