karanpratapsingh/system-design

Features

• Distributed Systems Architecture - Covers the fundamental principles, patterns, and trade-offs required to design scalable distributed systems.
• Architectural Design Curricula - Provides a comprehensive educational curriculum covering fundamental principles, patterns, and trade-offs for designing scalable and reliable distributed systems.
• Distributed Systems Curricula - Enterprise Service Bus (ESB) infrastructure is complex and can be challenging to integrate and expensive to maintain. It's difficult to troubleshoot them when problems occur in production environments, they're not easy t
• System Architecture Curricula - Provides a comprehensive educational framework for understanding distributed system design, architectural patterns, and infrastructure trade-offs.
• API Design Strategies - Now that we know how these API designing techniques work, let's compare them based on the following parameters: - Will it cause tight coupling? - How chatty (distinct API calls to get needed information) are the APIs?
• Architectural Patterns - In the Backend For Frontend (BFF) pattern, we create separate backend services to be consumed by specific frontend applications or interfaces. This pattern is useful when we want to avoid customizing a single backend for
• Microservices - A microservices architecture consists of a collection of small, autonomous services where each service is self-contained and should implement a single business capability within a bounded context. A bounded context is a
• Microservices Architectures - Applications are structured as a collection of small autonomous services that implement specific business capabilities within bounded contexts.
• Microservices Design Patterns - Explains how to decompose monolithic applications and manage microservice communication and consistency.
• Scalability Patterns - Modern high-traffic websites must serve hundreds of thousands, if not millions, of concurrent requests from users or clients. To cost-effectively scale to meet these high volumes, modern computing best practice generally
• System Design Curricula - Offers a structured educational curriculum focused on the architectural principles and trade-offs required for building scalable distributed systems.
• Distributed Architecture Handbooks - Serves as a comprehensive technical reference for core infrastructure and distributed system design.
• Data Consistency Models - The CQRS pattern is often used along with the Event Sourcing pattern. CQRS-based systems use separate read and write data models, each tailored to relevant tasks and often located in physically separate stores. When used
• Distributed System Paradigms - Systems communicate through asynchronous events to decouple services and improve scalability across distributed environments.
• Distributed Systems Theory - Explains core distributed systems trade-offs like the CAP theorem.
• Event-Driven Architectures - Event sourcing is seemingly constantly being confused with Event-driven Architecture (EDA). Event-driven architecture is about using events to communicate between service boundaries. Generally, leveraging a message broke
• Resilience Patterns - Describes the circuit breaker pattern for preventing cascading failures in distributed systems.
• Scalable Infrastructure Planning - Provides guidance on planning core infrastructure components like load balancing and database sharding.
• API Design Guides - A REST API (also known as RESTful API) is an application programming interface that conforms to the constraints of REST architectural style and allows for interaction with RESTful web services. REST stands for Representa
• Architectural Case Studies - Provides practical examples and real-world scenarios for applying caching, load balancing, and other distributed system patterns.
• Architectural Trade-off Analyses - Provides structured evaluations of the costs, limitations, and trade-offs associated with implementing complex distributed system components.
• Database Transaction Principles - The term ACID stands for Atomicity, Consistency, Isolation, and Durability. ACID properties are used for maintaining data integrity during transaction processing. In order to maintain consistency before and after a trans
• Engineering Reference Libraries - Provides a comprehensive technical handbook covering fundamental software engineering concepts and infrastructure design patterns.
• Load Balancing Curricula - This is the core functionality provided by a load balancer and has several common variations: - Host-based: Distributes requests based on the requested hostname. - Path-based: Using the entire URL to distribute r
• System Reliability Guides - Provides a structured explanation of availability metrics and the mathematical foundations of system uptime.
• Database Sharding Principles - But why do we need sharding? Here are some advantages: - Availability: Provides logical independence to the partitioned database, ensuring the high availability of our application. Here individual partitions can be m
• Distributed Caching Patterns - A distributed cache is a system that pools together the random-access memory (RAM) of multiple networked computers into a single in-memory data store used as a data cache to provide fast access to data. While most caches
• Distributed Consistency Models - Explains the PACELC theorem as an extension of CAP for distributed consistency.
• Distributed System Challenges - The most obvious challenge clustering presents is the increased complexity of installation and maintenance. An operating system, the application, and its dependencies must each be installed and updated on every node. Thi
• Distributed Transaction Patterns - Details the saga pattern for maintaining data consistency across distributed service operations.
• Load Balancing Patterns - Wait, isn't reverse proxy similar to a load balancer? Well, no as a load balancer is useful when we have multiple servers. Often, load balancers route traffic to a set of servers serving the same function, while reverse
• Modular Monoliths - A Modular Monolith is an approach where we build and deploy a single application (that's the Monolith part), but we build it in a way that breaks up the code into independent modules for each of the features needed in
• Monolithic Architectures - A monolith is a self-contained and independent application. It is built as a single unit and is responsible for not just a particular task, but can perform every step needed to satisfy a business need. ### Advantages Fol
• Service Discovery Patterns - Dynamic network locations of service instances are managed in a central database to facilitate communication in containerized environments.
• Service Meshes - Explains the architectural role of service meshes in managing complex service-to-service communication and traffic routing within distributed environments.
• System Architectures - Let's look at some examples of N-Tier architecture: ### 3-Tier architecture 3-Tier is widely used and consists of the following different layers: - Presentation layer: Handles user interactions with the application.
• System Reliability Principles - If queues start to grow significantly, the queue size can become larger than memory, resulting in cache misses, disk reads, and even slower performance. Backpressure can help by limiting the queue size, thereby maintaini
• System Architecture - Practical guide for learning system design at scale.
• System Design And Architecture - Curated collection of system design patterns and architectural concepts.
• Data Partitioning - Details the architectural pattern of horizontal partitioning to scale database performance.
• Data Partitioning Strategies - Explains techniques for splitting databases across machines to improve performance.
• Data Replication Strategies - Covers replication factors and node synchronization for high availability.
• Database Scaling Strategies - Large datasets are split horizontally across multiple physical machines to improve performance and manageability of high-traffic systems.
• Service Discovery - Details service discovery patterns for managing dynamic service locations.
• System Design Interview Preparation - Offers structured technical concepts and strategies for navigating complex system design discussions.
• API Design Patterns - Provides guidance on selecting communication protocols and integration patterns for backend services.
• Architectural Anti-patterns - Distributed Monolith is a system that resembles the microservices architecture but is tightly coupled within itself like a monolithic application. Adopting microservices architecture comes with a lot of advantages. But w
• Architectural Decision Guides - So, you might be wondering, monoliths seem like a bad idea to begin with, why would anyone use that? Well, it depends. While each approach has its own advantages and disadvantages, it is advised to start with a monolith
• Fault Tolerance Strategies - As you must've already guessed, the load balancer itself can be a single point of failure. To overcome this, a second or N number of load balancers can be used in a cluster mode. And, if there's a failure detection and
• High Availability Patterns - Load balancing shares some common traits with clustering, but they are different processes. Clustering provides redundancy and boosts capacity and availability. Servers in a cluster are aware of each other and work toget
• Load Balancing Architectures - Here are some commonly desired features of load balancers: - Autoscaling: Starting up and shutting down resources in response to demand conditions. - Sticky sessions: The ability to assign the same user or device
• Messaging Architectures - Message brokers can support two or more messaging patterns, including message queues and pub/sub, while event streaming platforms only offer pub/sub-style distribution patterns. Designed for use with high volumes of mess
• Messaging Patterns - Message brokers offer two basic message distribution patterns or messaging styles: - Point-to-Point messaging: This is the distribution pattern utilized in message queues with a one-to-one relationship between the me
• Reliability Engineering Concepts - If a system is reliable, it is available. However, if it is available, it is not necessarily reliable. In other words, high reliability contributes to high availability, but it is possible to achieve high availability ev
• Reliability Engineering Principles - An SLA, or Service Level Agreement, is an agreement made between a company and its users of a given service. The SLA defines the different promises that the company makes to users regarding specific metrics, such as serv
• Architectural Models - The OSI Model is a logical and conceptual model that defines network communication used by systems open to interconnection and communication with other systems. The Open System Interconnection (OSI Model) also defines a
• Disaster Recovery Strategies - Outlines various architectural strategies for disaster recovery and business continuity.
• API Gateways - The granularity of APIs provided by microservices is often different than what a client needs. Microservices typically provide fine-grained APIs, which means that clients need to interact with multiple services. Hence, a
• Availability Modeling - If a service consists of multiple components prone to failure, the service's overall availability depends on whether the components are in sequence or in parallel. ### Sequence Overall availability decreases when two com
• Commit Protocols - Explains the three-phase commit protocol as a solution to distributed blocking issues.
• Consistent Hashing - Describes how consistent hashing manages node distribution in distributed systems.
• Shared Caching Topologies - As the name suggests, we will have a single shared cache that all the application nodes will use. When the requested data is not found in the global cache, it's the responsibility of the cache to find out the missing pie
• Traffic Management - Explains rate-limiting algorithms like leaky bucket for managing system traffic.
• Multi-Master Replication - Details the operational benefits and coordination of master-master replication.
• Partitioning Algorithms - Details strategies like hash-based partitioning for distributing data.
• Primary-Replica Replication - Explains the flow of data from primary nodes to read-only replicas.
• Replication Strategies - Explains the performance and consistency trade-offs inherent in different data replication models.
• Transaction Management - Defines the fundamental unit of work required for reliable database state changes.
• API Fundamentals - Before we even get into API technologies, let's first understand what is an API. API stands for Application Programming Interface. It is a set of definitions and protocols for building and integrating application softwar
• Authorization Standards - OAuth 2.0 OAuth 2.0, which stands for Open Authorization, is a standard designed to provide consented access to resources on behalf of the user, without ever sharing the user's credentials. OAuth 2.0 is an authorizati
• Caching Concepts - Cache hit A cache hit describes the situation where content is successfully served from the cache. The tags are searched in the memory rapidly, and when the data is found and read, it's considered a cache hit. Cold
• Caching Strategies - Explains the fundamental principles and hierarchical levels of caching as part of a broader distributed systems curriculum.
• Content Delivery Network Guides - In a CDN, the origin server contains the original versions of the content while the edge servers are numerous and distributed across various locations around the world. To minimize the distance between the visitors and t
• Disaster Recovery Principles - Highlights the importance of disaster recovery for minimizing downtime and ensuring business continuity.
• Message Queueing Patterns - Messages are stored in the queue until they are processed and deleted. Each message is processed only once by a single consumer. Here's how it works: - A producer publishes a job to the queue, then notifies the user of t
• Network Protocol Tutorials - Transmission Control Protocol (TCP) is connection-oriented, meaning once a connection has been established, data can be transmitted in both directions. TCP has built-in systems to check for errors and to guarantee data w
• Networking Fundamentals - An IP address is a unique address that identifies a device on the internet or a local network. IP stands for "Internet Protocol", which is the set of rules governing the format of data sent via the internet or local ne
• Rate Limiting Guides - Explains the architectural complexities and strategies for implementing rate limiting across distributed nodes.
• Reliability Engineering Principles - Explains the importance of reliability frameworks for building user trust.
• Service Discovery Principles - Explains why service discovery is essential for dynamic microservice environments.
• Service Level Indicators - Explains the role of service level indicators in measuring system performance and reliability.
• Service Level Objectives - Describes the process of defining service level objectives to meet reliability promises.
• Architectural Comparisons - You might have seen Service-oriented architecture (SOA) mentioned around the internet, sometimes even interchangeably with microservices, but they are different from each other and the main distinction between the two
• Cache Eviction Strategies - Following are some of the most common cache eviction policies: - First In First Out (FIFO): The cache evicts the first block accessed first without any regard to how often or how many times it was accessed before. -
• Communication Protocols - gRPC is a modern open-source high-performance Remote Procedure Call (RPC) framework that can run in any environment. It can efficiently connect services in and across data centers with pluggable support for load balancin
• Distributed System Concepts - An event is a data point that represents state changes in a system. It doesn't specify what should happen and how the change should modify the system, it only notifies the system of a particular state change. When a user
• Routing Algorithms - Provides detailed explanations of load balancing and request distribution strategies used in distributed system design.

Star history