Low-Level Design

Database Indexing

An index is a data structure that speeds up data retrieval by allowing the database to find rows without scanning the entire table.

SQL vs NoSQL Databases

SQL databases offer structured data and strong consistency; NoSQL databases offer flexible schemas and horizontal scalability.

Database Replication

Keeping synchronized copies of data across multiple database servers for high availability and read scalability.

Database Normalization

Organizing database tables to reduce data redundancy and improve data integrity by following a set of normal forms.

Singleton Pattern

Ensures a class has only one instance throughout the entire application and provides a global point of access to it.

Factory Method Pattern

Defines an interface for creating objects but lets subclasses or implementations decide which class to instantiate.

Builder Pattern

Separates the construction of a complex object from its representation, letting you build objects step by step.

Abstract Factory Pattern

Provides an interface for creating families of related objects — like UI components for different operating systems — without specifying their concrete classes.

Prototype Pattern

Creates new objects by copying (cloning) an existing object, avoiding the overhead of creating from scratch.

Adapter Pattern

Converts the interface of one class into the interface another class expects, making incompatible interfaces work together.

Decorator Pattern

Wraps an object to add new behaviors dynamically at runtime without modifying the original class or creating a huge number of subclasses.

Facade Pattern

Provides a simplified interface to a complex subsystem, hiding all the internal complexity behind a single easy-to-use class.

Proxy Pattern

Provides a substitute or placeholder for another object to control access to it, add caching, or add logging without changing the real object.

Composite Pattern

Composes objects into tree structures and lets you treat individual objects and groups of objects uniformly through the same interface.

Strategy Pattern

Defines a family of interchangeable algorithms and lets you swap them at runtime without changing the code that uses them.

Observer Pattern

Defines a one-to-many dependency so when one object (subject) changes state, all its dependents (observers) are notified automatically.

Bridge Pattern

Decouples an abstraction from its implementation so that the two can vary independently — preventing a class explosion when you have multiple dimensions of variation.

Command Pattern

Encapsulates a request as an object, letting you parameterize operations, queue them, log them, or support undo/redo.

Chain of Responsibility

Passes a request along a chain of handlers; each handler either processes it or passes it to the next one in the chain.

State Pattern

Allows an object to change its behavior when its internal state changes — the object appears to change its class.

Template Method Pattern

Defines the skeleton of an algorithm in a base class but lets subclasses override specific steps without changing the overall structure.

Iterator Pattern

Provides a standard way to traverse elements of a collection without exposing its internal structure.

Flyweight Pattern

Shares common, immutable state across many fine-grained objects to dramatically reduce memory usage when dealing with huge numbers of similar objects.

Interpreter Pattern

Defines a grammar for a simple language and provides an interpreter to evaluate sentences in that language by representing each grammar rule as a class.

Mediator Pattern

Reduces chaotic dependencies between many objects by routing all communication through a central mediator object — objects talk to the mediator, not to each other.

Memento Pattern

Captures and externally stores an object's internal state so it can be restored later — enabling undo/redo without exposing private implementation details.

Visitor Pattern

Lets you add new operations to a class hierarchy without modifying any of the existing classes — by moving the operation logic into a separate "visitor" object.

How to Approach an LLD Interview

A structured 6-step framework for tackling any Low-Level Design problem in an interview confidently.

How to Approach a System Design (HLD) Interview

A 7-step framework for high-level system design interviews — from requirements to deep-dive on the most challenging components.

How to Identify the Right Design Pattern

A practical guide to recognizing which design pattern to apply in a given problem scenario.

Encapsulation

Bundling data and the methods that operate on it within one class, and hiding internal details from the outside world.

Inheritance

A mechanism where a child class acquires the properties and behaviors of a parent class, enabling code reuse and specialization.

Polymorphism

The ability for different classes to be treated as instances of the same parent class, each responding to the same method call in their own way.

Abstraction

Hiding complex implementation details and showing only the essential features of an object — focusing on WHAT it does, not HOW it does it.

Composition over Inheritance

Prefer building complex behavior by combining simpler objects (has-a) rather than by creating deep inheritance hierarchies (is-a).

Single Responsibility Principle (SRP)

A class should have only one reason to change — it should do one thing and do it well.

Open-Closed Principle (OCP)

Software entities should be open for extension but closed for modification — add new behavior without changing existing code.

Liskov Substitution Principle (LSP)

Objects of a subclass should be replaceable for objects of the parent class without breaking the application.

Interface Segregation Principle (ISP)

No class should be forced to implement methods it doesn't use — prefer many small, specific interfaces over one large general one.

Dependency Inversion Principle (DIP)

High-level modules should not depend on low-level modules — both should depend on abstractions (interfaces).

CAP Theorem

In a distributed system, you can only guarantee two out of three: Consistency, Availability, and Partition Tolerance.

Consistent Hashing

A technique for distributing data across servers so that adding or removing a server minimizes the number of keys that need to be remapped.

Caching Strategies

Techniques for storing frequently accessed data in fast storage to reduce latency and database load.

Load Balancing

Distributing incoming traffic across multiple servers to prevent any single server from being overwhelmed.

Database Sharding

Horizontally partitioning a database into smaller pieces (shards) each stored on a different server to handle large scale.

ACID vs BASE

ACID guarantees strong consistency for traditional databases; BASE allows relaxed consistency for highly available distributed systems.

Content Delivery Network (CDN)

A globally distributed network of servers that caches and delivers static content to users from the nearest geographic location.

Message Queues & Async Processing

Decouple producers and consumers using a queue so heavy tasks are processed asynchronously without blocking the user.