Does Writing HLD and LLD Really Worth It?
Often I have seen developers stumbling upon a question about whether to put effort to write an HLD and LLD document. Is it really worth it? Do we need to write it because someone just told us to?
Many a time developers think that writing a document is a waste of time and that’s something not needed. Also, developers think they are getting paid for writing code and building systems, not for writing documents.
So in this document, we will be talking about whether writing an HLD document is really worth it.
Have you ever observed that in the real world, we mostly use blueprints for everything. Let’s take an example of constructing a house. Suppose you have a big size land where we can construct a house. But considering you need to move in fast and have fewer funds to build, you decide to build just the ground floor, you directly start building rooms and keep adding other areas like kitchen, dining, living room, etc. But without designing even a rough blueprint, think of the house that we would end up building. Now if in the end, you realize that the living room looks smaller and other rooms look bigger, then you will again have to do a lot of rework.
After you build the ground floor, you start to live there and after a few years, you realize that you need more space and want to build another story on top of it. After inspecting, you realize that you have never provisioned the first floor while building the ground floor, and hence you will have to demolish half of the existing house structure to build the next floor. Think of the disaster that just happened because of the lack of design. We have spent too much time on actual groundwork and construction and neglected spending time on designing and planning for future provisioning. Now that would cost a lot of rework and also would result in not a very secure, strong and good looking house.
The software systems are not much different than building a house or a building. So ideally it’s an investment and not a spend.
Now we have talked a lot about the importance of documentation but what they really are? Let’s see…
The system design documents use an iterative approach to determine the best solution ensuring functional and non-functional requirements are being incorporated. It tracks the necessary information required to effectively define the architecture and system design in order to give the development team guidance on the architecture of the system to be developed. While developing any application we should think about real-world scenarios, like how other applications work. Having these ideas would help us develop our application in a better way.
High-Level Design(HLD)
The HLD is an excellent communication and collaboration tool. Like many other tools and documents that can be used to improve the quality of your deliveries, the HLD plays a specific role in the designing phase of the project.
An HLD document is essentially a technical description of functional requirements which also covers a quick summary of how the system’s various subsystems and components interact. It basically gives a bird’s eye view of the whole system. It’s a blueprint that consolidates the application architecture, application flow, various systems involved, steps and modules, their objectives, variable components, and relationship among modules. It also includes some of the very important aspects of non-functional requirements like the number of concurrent requests expected, the number of overall users accessing the system, performance and latency consideration, and future growth.
HLD document includes an architectural plan and diagram, application modules, system flow, data flows, and flowcharts so that developers can understand how the system is expected to work. It describes the relationship between various components and functions of the system. It defines the actual logic for each and every module of the system to understand the flow of the entire system.
Low-Level Design(LLD)
LLD is like detailing HLD which refers to the component-level design process. It is based on HLD but digs deeper, going into the separate modules and features in order to document their specifications.
The high-level design helps with the what, and the low-level design is all about hows.
When we approach low-level design, the idea is to get into further detailing of the application. The low-level design document is often a heavy-duty, bulky document that contains the pseudocode for the developers. It gets into the details of how the components and classes work, the various properties of the classes, the definitions of the database, and the interfaces.
Often the developers rush through the low-level design phase to save time but they end up spending that time on reworking and resolving the errors due to the shallow design process.
The main objective of preparing low-level design is to mitigate any additional burden developers face during the development phase by clearly laying out details.
Writing technical documentation is an integral part of building software. Doing it right can make an enormous difference in the quality of your deliveries. Finding the right balance between quantity and productivity can take time but will be worth it.
Also, I have observed that when we write documents, we ponder and try to dig deeper to figure out all the connections and systems. We also connect all the dots together and design a system that covers the whole ground. This helps us to figure out all the unknown and figure out the design which helps in laying down the foundation work. It also helps in finding dependencies and resolving them upfront so that we can avoid rework.
Final Words
You can not become a successful software developer by just writing code. You need to get better at writing documents. Writing documents helps in formulating your thoughts and those docs help in speeding up your coding speed, execution speed and also help in delivering quality deliverables.
