How to Answer an LLD Problem

Succeeding in a 45-60 minute Low-Level Design (LLD) or Object-Oriented Design (OOD) interview is not just about writing code. Interviewers want to evaluate your system design thinking, how you decompose complex requirements, your application of SOLID principles, and your ability to write clean, modular, and extensible code.

1. Learning Objectives

• Master the structured 5-Step LLD Interview Framework.
• Deconstruct vague problem statements into functional and non-functional requirements.
• Identify core domain entities (classes) and behaviors (methods) systematically.
• Determine relationships (composition vs. inheritance) and draw accurate UML diagrams.
• Select and integrate appropriate GoF design patterns to make code extensible.
• Write clean, runnable, and testable code within the interview time limits.

2. Problem & Naive Solution

Imagine you are in an interview and the interviewer asks: "Design a Vending Machine."

The Naive Solution (Jumping Straight to Code)

A common mistake candidates make is immediately opening their IDE or writing code on the whiteboard without clarifying requirements or designing the class structure:

3. Issues with the Naive Approach

• Tightly Coupled State Transitions: If you need to add a new state (e.g., OutOfOrder or Dispensing), you must rewrite the conditional logic across all methods. This violates the Open/Closed Principle, making the code fragile and error-prone.
• Unclear Scope: The developer did not clarify what coins are accepted, how inventory is managed, or what happens when a product is out of stock. This leads to missing requirements and wasted development time.
• Poor Modularity: A single class manages states, balances, and product dispensing, violating the Single Responsibility Principle.

4. Real-world Analogy

5. Theory: The 5-Step LLD Interview Framework

To succeed in LLD interviews, follow this structured 5-step framework:

Step 1: Clarify Requirements & Scope (5-10 mins)

LLD questions are intentionally open-ended. Your first task is to gather functional requirements, list system constraints, and establish non-functional guidelines:

• Functional Requirements: What *must* the system do? (e.g., "The vending machine must accept coins and bills, allow product selection, dispense products, and return change.")
• Constraints: What is out of scope? (e.g., "We will assume card payments and inventory restocking notifications are out of scope for the initial version.")
• Non-functional Guidelines: What are the design priorities? (e.g., "The system must be extensible to support new states and payment methods, and must be thread-safe.")

Step 2: Define Core Entities (10 mins)

Identify key classes (nouns) and behaviors (verbs) systematically from the requirements:

• Nouns (Classes): VendingMachine, State, Product, Inventory, Coin.
• Verbs (Methods): insertCoin(), selectProduct(), dispense(), cancelTransaction().

Step 3: Design Relationships & UML (10-15 mins)

Map class relationships: inheritance, composition, association. Add multiplicities (e.g., VendingMachine contains 1 Inventory; Inventory contains many Products).

Step 4: Select Design Patterns (5 mins)

Integrate design patterns to make code extensible. For example:

• State Pattern: Ideal for vending machines, parking gates, or order workflows where behavior changes based on state.
• Strategy Pattern: Useful for routing payment fees or discount strategies dynamically.
• Factory Method: Perfect for instantiating products or vehicles.

Step 5: Write Clean Code (20 mins)

Translate your UML design into clean, runnable code. Implement robust error handling (avoid returning nulls) and create a main demo runner to demonstrate your classes.

6. UML Class Diagram: Vending Machine State Pattern

Below is the UML class diagram for the vending machine design. The VendingMachine class delegates operations to the polymorphic State interface, decoupling states from one another.

7. Complete Code (Vending Machine Case Study)

This is a complete, clean, and runnable implementation of the Vending Machine design using the State Pattern.

8. Code Walkthrough

Let's review the key elements of the Vending Machine case study:

• Polymorphic Delegation: The VendingMachine context delegator calls currentState.insertCoin(this, amount). It has no knowledge of what concrete state class is active. This decouples transition logic from the main class, satisfying the Open/Closed Principle.
• No Conditional Chains: We have completely eliminated the nested if-else blocks present in the naive solution. Adding a new state is as simple as implementing the State interface and updating transitions.

9. Best Practices

• State Your Assumptions Proactively: At the start of the interview, state your assumptions clearly (e.g. "Assuming one vehicle type per parking spot"). Write them down on the board to avoid misalignment.
• Prioritize Modularity Over Performance: In LLD interviews, clean interfaces, loose coupling, and SOLID compliance are significantly more important than minor micro-optimizations.

10. Common Mistakes

• Jumping Into Coding Immediately: Coding without clarifying the scope. This often leads to over-engineering or building the wrong solution.
• Force-Fitting Design Patterns: Applying complex patterns (e.g., using a Visitor pattern where a simple strategy would suffice), adding unnecessary complexity.

11. Interview Discussion

12. Practice Exercises

• Easy: Apply the 5-step framework to design a simple Stack Overflow system (Users, Questions, Answers).
• Medium: Design a thread-safe Parking Lot system supporting multiple vehicle types and parking spot size allocations.
• Hard: Design an Online Movie Ticket Booking System (like BookMyShow). Handle concurrent seat selection and booking transactions.

13. Challenge Problem

Apply the 5-step framework to design an Enterprise Ride-Sharing Dispatcher (like Uber). The dispatcher matches riders with nearby drivers based on distance and rating metrics. It must handle concurrent ride requests and driver status updates. Draw the UML class diagram and implement a thread-safe simulation in Java, Python, or C++.

14. Summary & Cheat Sheet

15. Quiz

16. Next Lesson Preview

In the next lesson, we will cover Clean Code & Refactoring. We will explore code smells, learn refactoring techniques like Extract Method, and study how to write readable, self-documenting code!