System Design
Think beyond components.
Design entire systems.
Learn how to design software systems that meet real-world requirements. Understand architecture, APIs, databases, caching, distributed systems, scalability, reliability, and the trade-offs behind important design decisions.
Your learning path
Learn system design step by step.
Build your understanding from architectural fundamentals to distributed systems and complete system design problems.
System Design Fundamentals
Understand functional and non-functional requirements, architectural boundaries, and the trade-offs that shape a system’s design.
Learn the HLD approachArchitectural Components
Explore clients, application servers, APIs, load balancers, gateways, and the responsibilities of each component.
Explore HLD topicsDatabases and Data Modeling
Learn to reason about relational and NoSQL databases, data access patterns, indexing, replication, and partitioning.
Explore related topicsCaching and Content Delivery
Understand cache placement, eviction strategies, cache invalidation, CDNs, and the trade-offs between freshness and performance.
Explore HLD topicsDistributed Systems
Explore replication, partitioning, consistency, asynchronous communication, queues, failure handling, and coordination.
Explore HLD topicsSystem Design Problems
Apply your knowledge to realistic design exercises. Evaluate bottlenecks, compare alternatives, and justify your architectural decisions.
Practice design problemsWhat you need to understand
The foundations of good architecture.
System design is about meeting requirements while balancing performance, reliability, complexity, consistency, and cost.
Requirements and Constraints
Define what the system must do and the quality attributes it must meet. Clarify traffic, latency, availability, consistency, security, and cost expectations.
APIs and Communication
Design clear interfaces between clients and services. Understand request-response APIs, communication protocols, timeouts, retries, and asynchronous interactions.
Storage and Data
Select storage technologies according to access patterns, data relationships, consistency requirements, and expected growth. Understand indexing, replication, and partitioning.
Scalability and Performance
Identify bottlenecks and evaluate horizontal scaling, load balancing, caching, asynchronous processing, and capacity requirements.
Reliability and Resilience
Plan for failures using appropriate timeouts, retries, redundancy, recovery mechanisms, graceful degradation, and observability.
Trade-offs and Consistency
Evaluate competing goals instead of assuming one design is best for every situation. Consider consistency, availability, latency, complexity, and operational cost.
Explore system design concepts
Understand the design decisions.
Select a concept to understand the problem it addresses and the questions to consider when using it.
Design for changing demand.
Scalability describes a system’s ability to handle growth in workload. Horizontal scaling adds instances; vertical scaling increases the resources of an existing instance.
Start by locating the bottleneck. More application servers won’t solve a database bottleneck unless the database access pattern or capacity problem is addressed too.
Choose storage around access patterns.
Relational and NoSQL databases offer different data models and operational trade-offs. The appropriate choice depends on relationships, query patterns, consistency needs, transactions, and scale.
Consider indexes, replication, partitioning, and how data is read and written before choosing a technology.
Reduce repeated work intelligently.
Caching can reduce latency and the load on databases or downstream services by keeping frequently accessed data closer to the caller.
A cache also introduces decisions about expiration, invalidation, stale data, eviction, and what happens when the cache is unavailable.
Expect failures and design around them.
Services, networks, and storage systems can fail or respond slowly. Reliability depends on failure detection, recovery, redundancy, and sensible timeouts.
Retries should account for idempotency and retry limits. Circuit breakers, graceful degradation, and monitoring can help prevent failures from spreading.
Decouple work with asynchronous messaging.
Queues and event streams let producers and consumers communicate without requiring every operation to finish within the same request.
Plan for duplicate delivery, ordering requirements, consumer failures, backpressure, retries, and dead-letter handling. Delivery guarantees depend on the system design.
A practical workflow
From requirements to architecture.
Follow a structured approach to solve system design problems without jumping straight into technology choices.
Clarify requirements
Identify core use cases, constraints, scale expectations, and measurable quality attributes.
Estimate capacity
Estimate traffic, storage, bandwidth, and request patterns to identify important constraints.
Design the architecture
Define APIs, major services, data models, storage, and the interactions between components.
Evaluate and refine
Find bottlenecks and failure modes. Explain trade-offs and improve the design against the requirements.
Connect the concepts
From system architecture to code design.
System Design and Low-Level Design solve related but different problems. Strong engineers understand how high-level architecture connects to the internal design of individual components.
High-Level Design
Design the system.
Focus on major components, service boundaries, APIs, data storage, communication, scalability, reliability, and system-wide trade-offs.
Explore HLDLow-Level Design
Design the components.
Focus on classes, interfaces, object relationships, responsibilities, design patterns, and maintainable implementation details.
Explore LLDPut knowledge into practice
Learn by designing real systems.
Practice turning requirements into architecture. Explore design scenarios, identify bottlenecks, compare alternatives, and justify your decisions using the constraints of each problem.
Build your engineering skills
Think in systems.
Make better design decisions.
Start with the fundamentals, follow a structured design process, and learn to evaluate the trade-offs that shape scalable and reliable software.