Low Level System Design

Understand how to model real-world entities as classes, instantiate objects, and hide internal state behind well-defined interfaces.

Learn how subclassing and method overriding let you share behavior across types and write code that works against abstractions rather than concrete classes.

Understand contracts — when to use an interface to define capability versus an abstract class to share partial implementation.

Learn why favoring object composition over class inheritance leads to more flexible, testable designs.

You can model domains with classes, interfaces, and composition confidently.

Each class should have exactly one reason to change — learn to identify and separate concerns.

Design modules that are open for extension but closed for modification, using abstraction and polymorphism.

Subtypes must be substitutable for their base types without breaking correctness — learn to spot violations.

Prefer many small, focused interfaces over one large general-purpose interface to reduce coupling.

High-level modules should depend on abstractions, not concrete implementations — the foundation of dependency injection.

Complementary principles that guard against duplication, over-engineering, and premature generalization.

Limit an object's knowledge to its immediate collaborators to reduce coupling between distant parts of the system.

You can evaluate and refactor code against SOLID and related principles.

Delegate object creation to subclasses or factory objects so the client code stays decoupled from concrete types.

Ensure a class has only one instance with a global access point — and understand when this pattern is a code smell.

Construct complex objects step-by-step, separating construction logic from representation.

Create new objects by cloning existing ones, useful when construction is expensive or configuration-heavy.

Convert the interface of a class into one the client expects, enabling incompatible classes to work together.

Attach additional behavior to objects dynamically without modifying their class — a flexible alternative to subclassing.

Provide a simplified interface to a complex subsystem, reducing the learning curve and coupling for client code.

Compose objects into tree structures and treat individual objects and groups uniformly.

Define a family of interchangeable algorithms and let the client choose one at runtime without conditional logic.

Establish a one-to-many dependency so that when one object changes state, all dependents are notified automatically.

Let an object alter its behavior when its internal state changes, appearing to change its class.

Encapsulate a request as an object, enabling undo/redo, queuing, and logging of operations.

Pass a request along a chain of handlers, where each handler decides to process or forward it.

Provide a way to access elements of a collection sequentially without exposing its underlying representation.

You can recognize, apply, and combine the most important Gang of Four patterns.

Read and draw class diagrams to communicate designs visually — associations, aggregation, composition, and inheritance arrows.

Design clean method signatures, define clear contracts, and version your interfaces for backward compatibility.

Translate class models into relational schemas — normalization, foreign keys, indexes, and mapping inheritance to tables.

Use enums and type-safe constructs to eliminate magic strings and invalid states from your design.

Understand race conditions, mutexes, locks, and synchronized blocks to protect shared mutable state.

Coordinate work between threads using bounded buffers and blocking queues — a fundamental concurrency pattern.

Allow multiple readers or a single writer to access shared data efficiently using specialized locks and thread-safe data structures.

You can design thread-safe classes and reason about concurrent access patterns.

Model vehicles, spots, floors, and ticketing — a classic LLD exercise covering OOP, enums, and strategy selection.

Handle scheduling, state machines, and concurrent requests in a multi-elevator building.

Combine a hash map and doubly-linked list to build a constant-time eviction cache — tests data structure choice and API design.

Model game state, turns, validation, and win conditions — exercises the state and strategy patterns.

Handle users, groups, expense splitting strategies (equal, exact, percentage), and balance settlement.

Model books, members, borrowing rules, fines, and search — a comprehensive CRUD-plus-business-rules exercise.

You can decompose a problem into classes, apply appropriate patterns, handle concurrency, and produce a clean, extensible design.