Who prepares HLD and LLD?

The preparation of High-Level Design (HLD) and Low-Level Design (LLD) typically involves different roles and collaboration among team members within a software development project. Here’s an overview of who is usually responsible for each and how they collaborate:

High-Level Design (HLD)

Who Prepares HLD:

• Architects: Solution architects or system architects are primarily responsible for creating the high-level design. They define the overall structure of the system, ensuring it meets the requirements and aligns with the organization’s technical strategy.
• Senior Engineers/Technical Leads: Senior software engineers or technical leads often collaborate with architects to provide input based on their practical experience and knowledge of the system's operational aspects.
• Project Managers/Product Managers: They may contribute by ensuring that the high-level design aligns with business requirements and project constraints.

Collaboration:

• Requirements Gathering: Architects and senior engineers work with stakeholders (product managers, business analysts, etc.) to gather and understand requirements.
• Review Meetings: Regular design review meetings are held to discuss the high-level design with various stakeholders, including developers, QA engineers, and operations teams, to ensure feasibility and address any concerns.
• Documentation: Architects create documentation, including architecture diagrams, data flow diagrams, and descriptions of major components and their interactions.

Low-Level Design (LLD)

Who Prepares LLD:

• Senior Software Engineers/Technical Leads: They are primarily responsible for creating the low-level design. They detail the implementation of components, classes, methods, and interactions.
• Software Developers: Depending on the project, regular software developers may also be involved in preparing parts of the low-level design, especially for the modules they are directly responsible for implementing.
• Design Review Committees: In some organizations, design review committees or peer review groups may contribute to and review the low-level design to ensure it adheres to best practices and design principles.

Collaboration:

• Detailed Requirements Analysis: Senior engineers and developers analyze detailed requirements to create specific design solutions.
• Design Discussions: Teams hold discussions and whiteboard sessions to brainstorm and refine low-level design choices.
• Documentation and Diagrams: Developers create class diagrams, sequence diagrams, and detailed pseudocode or actual code structures as part of the LLD.
• Code Reviews: Before implementation, the low-level design is often reviewed by peers or leads to ensure it aligns with the high-level design and follows coding standards and best practices.

Collaboration Between HLD and LLD

Integration:

• The HLD provides the blueprint for the overall system architecture, guiding the LLD.
• LLD dives into the specifics, detailing how each component defined in the HLD will be implemented.

Feedback Loop:

• During the LLD phase, developers and engineers may discover constraints or improvements that need to be communicated back to the architects. This can result in adjustments to the HLD.
• Continuous collaboration and iteration between HLD and LLD creators ensure that both designs remain aligned and feasible.

Review and Approval:

• Both HLD and LLD are reviewed in joint meetings involving architects, senior engineers, developers, and other stakeholders to ensure consistency, feasibility, and alignment with requirements.
• Sign-offs from both architects (for HLD) and senior engineers or leads (for LLD) are typically required before proceeding to implementation.

Example Scenario: Design of a Scalable E-commerce Platform

High-Level Design (HLD):

• Prepared by: Solution Architect with input from Senior Engineers and Product Managers.
• Content: Overall architecture diagram showing major components like the frontend, backend services, databases, cache, load balancers, and third-party integrations. Descriptions of data flow, scalability strategies, and high-level interactions between components.

Low-Level Design (LLD):

• Prepared by: Senior Software Engineers and Developers.
• Content: Detailed class diagrams for each service, sequence diagrams for key operations (like user authentication, order processing), API specifications, database schema design, and detailed pseudocode or method signatures.

Conclusion

The preparation of HLD and LLD involves collaboration among architects, senior engineers, technical leads, and developers. Architects typically lead the creation of the HLD, focusing on the overall system structure, while senior engineers and developers prepare the LLD, detailing the implementation of individual components. Effective communication and iterative reviews between these roles ensure that the system is well-designed, scalable, and maintainable.