Topics in order:
- OOD
- UML and other diagrams
- Design patterns
- Problems
Design principles:
The focus of the LLD interview is on code organization: What are the right objects? How do they interact? What methods do they expose? Can the design be extended without rewriting everything?
Modern production systems favor composition over inheritance, simple state over deep hierarchies, and pragmatism over pattern worship.
LLD vs System Design
For low-level design - you are defining objects, modeling data, and shaping the interactions that make a single feature or service work. Instead of boxes and arrows, you work through classes, methods, relationships, and state transitions. In a low-level design interview, instead of drawing services, you write the code structure for a single part of the system, usually in pseudocode. The discussion is about methods, relationships, data models, and state transitions, not how to scale the fleet to millions of users.
System design is the map. Low level design is the blueprint for a building on the map.
Assessment
Interviewers want to see whether you can turn a small, well-scoped problem into a clean, maintainable code structure. They are testing your ability to decompose a system, express clear classes, and design code that a real team would want to work with.
Problem Analysis
Interviewers start by checking whether you understand what you are building. Strong candidates extract the key entities and responsibilities, ask a few clarifying questions to lock down scope, and frame the problem before touching code. What interviews don’t want to see is you jumping right into code without understanding the problem thoroughly first.
Class Design
Once the problem is scoped, interviewers look at how you design the main classes and how they interact. This includes choosing the right responsibilities, shaping method signatures, defining clear ownership, and keeping boundaries clean. Good class design makes the rest of the interview feel natural. Weak class design makes everything downstream harder.
Code Quality
This combines the fundamentals of good object-oriented design with the structure and hygiene of real code. Interviewers want to see encapsulation, well-managed state, sensible use of composition or inheritance, and clear separation of concerns. They also look at naming, consistency, and dependency direction. Even in pseudocode, the goal is code that reflects disciplined thinking rather than ad hoc decisions.
Extensibility and Maintainability
Most interviews include a small follow-up requirement. The goal is to see whether your design can absorb new functionality without being rewritten. Strong candidates build flexible structures with clean boundaries. The focus is on practicality. Interviewers reward designs that adapt easily, not designs that anticipate every possible future.
Communication
Interviewers want to see a clear narrative, thoughtful reasoning, and the ability to adjust when the interviewer probes. A structured explanation often signals confidence and maturity more than perfectly written code. This one should be easy, just talk out loud and walk them through your thought process as you go.
Delivery Framework
https://www.hellointerview.com/learn/low-level-design/in-a-hurry/delivery