DEVPREP CODEX · #15

Object Design · LLD Interview Questions

150 curated questions graded from Foundations (Easy) to Practical Patterns (Medium) and Internals & Architecture (Hard).

TOTAL QUESTIONS

150

THEORY QUESTIONS

150

IMPLEMENTATION FOLIOS

FREE QUESTIONS

5 / Level

Easy Level·50 Questions Total

Foundations & Core Concepts

Open Full Easy List

Q1What is Low-Level Design (LLD) and how does it fit into the software development life cycle?

LLD (Object-Oriented Design): The process of translating business requirements and high-level architecture (HLD) into a detailed, executable blueprint containing classes, interfaces, relationships, and design patterns.
SDLC Fit: It bridges the gap between High-Level Design (HLD) (services, databases, system architecture) and actual coding/implementation.

Q2What is the main objective of LLD?

Objectives:
- Guarantee maintainability, readability, and testability of the code.
- Implement structural SOLID principles and standard design patterns.
- Establish clear boundaries, class interfaces, and modular lifecycles.
- Reduce the risk of bugs by defining rigorous interaction protocols (UML) before writing code.

Q3What are the primary inputs and outputs of the LLD phase?

Inputs: HLD documentation, System Use Cases, Functional Requirements, Database Schemas, API contracts.
Outputs: Class diagrams, Sequence diagrams, State-machine diagrams, detailed interface specifications, and database schema mappings (ERD).

Q4What is Object-Oriented Analysis and Design (OOAD)?

Analysis (OOA): Identifying the core business domain entities, their attributes, and operations from the requirements (e.g., identifying "User", "Order", "Cart" in e-commerce).
Design (OOD): Structuring these entities into concrete software components (classes, interfaces), assigning behaviors, and arranging their interactions.

Q5Explain the Single Responsibility Principle (SRP) with an LLD example.

SRP: A class should have exactly one reason to change.
LLD Example: Instead of an Invoice class that handles both calculations and PDF generation, split it into two:
- Invoice: Manages invoice data and mathematical calculations.
- InvoicePDFGenerator: Exclusively handles formatting and rendering of the PDF file.

45 More Easy Questions Locked

Unlock the complete Object Design · LLD Easy question bank

Get instant access to all 50 questions, in-depth model answers, code sandboxes, and all 27+ technologies for a single one-time payment.

Unlock All — One-time payment · Lifetime access

Medium Level·50 Questions Total

Mechanisms & Practical Patterns

Open Full Medium List

Q1What is the difference between class cohesion and method cohesion in system design?

Class Cohesion: The degree to which the fields and methods of a single class belong together logically. High class cohesion means all members are focused on a single responsibility.
Method Cohesion: The level of focus of a single method. High method cohesion means the method performs exactly one distinct operation (does not mix formatting, validation, and calculations).

Q2What is the difference between syntactic coupling and semantic coupling?

Syntactic Coupling: The caller depends on the names, signatures, and types of the called class (easily checked by compiler).
Semantic Coupling: The caller depends on the internal behavior, state transitions, or execution order of the called class (harder to detect, causes fragile execution bugs when implementation changes).

Q3What are the key indicators (code smells) that signal a need for LLD refactoring?

Indicators:
- Divergent Change: A single class must be modified in different ways to support unrelated new requirements.
- Shotgun Surgery: A single change requires making tiny edits across dozens of different classes.
- Feature Envy: A method inside Class A constantly reads/writes variables of Class B instead of its own.

Q4What is the "Feature Envy" code smell, and how do you resolve it?

Feature Envy: A class method is more interested in the data of another class than its own class's data.
Resolution: Apply the Move Method refactoring technique. Relocate the envious method into the class whose data it is accessing, or pass the necessary data as parameters to keep logic localized.

Q5What is the "Long Method" code smell, and what LLD techniques reduce it?

Long Method: A method that contains too many lines of code, making it hard to read, maintain, and unit test.
LLD Techniques:
- Extract Method: Split logical sections of the method into smaller, descriptive helper functions.
- Replace Temp with Query: Replace temporary local variables with direct query methods to simplify the signature.

45 More Medium Questions Locked

Unlock the complete Object Design · LLD Medium question bank

Get instant access to all 50 questions, in-depth model answers, code sandboxes, and all 27+ technologies for a single one-time payment.

Unlock All — One-time payment · Lifetime access

Hard Level·50 Questions Total

Internals & System Architecture

Open Full Hard List

Q1How do you design an API Rate Limiter at the class level? Compare Token Bucket and Leaky Bucket models.

Token Bucket: Stores tokens up to a maximum capacity. Tokens are added at a constant rate. Each request consumes a token. Allows bursts of traffic.
- Class Layout: RateLimiter class holds lastRefillTimestamp, allowedTokens, refillRate, and a lock.
Leaky Bucket: Requests enter a queue (bucket) and leak out at a constant processing rate. Smoothes out traffic bursts.
- Class Layout: LeakyLimiter wraps a thread-safe blocking queue of size capacity with a background thread consuming requests at interval leakRate.

Q2How do you design a lock-free thread-safe concurrent queue?

Concept: Bypasses heavy OS-level mutex synchronization using Compare-And-Swap (CAS) CPU primitives.
Implementation: Employs the Michael-Scott Queue algorithm. Uses atomic references (AtomicReference in Java) for the head and tail nodes. Pushing and popping elements runs inside a CAS loop, continuously retrying until successful.

Q3Design a thread-safe, high-performance in-memory cache with an LRU eviction policy.

Data Structures:
- HashMap: Provides $O(1)$ lookup speed to locate cache keys.
- Doubly Linked List: Tracks usage order in $O(1)$ time. Whenever a key is read/updated, its node is moved to the head. The tail represents the least recently used node.
Synchronization: Uses a ReentrantReadWriteLock to permit concurrent readers while serializing write evictions.

Q4Design a custom Connection Pool supporting acquisition timeout configurations.

Key Fields: blockingQueue representing available connections, activeConnectionsCount, maxPoolSize, and lock.
Acquisition Flow: A thread requests a connection using poll(timeout, TimeUnit). If the queue is empty and activeConnectionsCount < maxPoolSize, the pool instantiates a new connection dynamically. Otherwise, the thread blocks up to the designated timeout.

Q5Explain the structural design of a Multi-Level Cache (L1/L2) system.

L1 (In-Memory): Fast, small memory size (local heap).
L2 (Distributed): Slower, larger memory size (Redis/Memcached).
Coherence Policies:
- Write-Through: Updates both L1 and L2 immediately.
- Write-Back: Updates L1 immediately and queues asynchronous updates to L2.
- Eviction: Evicting from L1 does not affect L2. Evicting from L2 triggers invalidation signals to all local L1 caches.