@BBKing2002: 系统设计面试资料总是又散又厚？这个开源项目把高频知识点压成了一张张架构图，复习效率会高很多。 system-design-101 由 ByteByteGo 团队制作，目前已有 84.1k Star，核心内容包括： 1. 用图示拆解缓存、消…
摘要
ByteByteGo团队制作的开源项目system-design-101，通过架构图简化系统设计面试知识点，已获84.1k星标，适合面试准备和团队培训。
系统设计面试资料总是又散又厚？这个开源项目把高频知识点压成了一张张架构图，复习效率会高很多。
system-design-101 由 ByteByteGo 团队制作，目前已有 84.1k Star，核心内容包括：
1. 用图示拆解缓存、消息队列、数据库分片等难点，降低阅读长文档的成本。
2. 覆盖限流、一致性哈希等系统设计面试常考主题，适合集中补齐知识盲区。
3. 完全免费开源，现成的架构图还能用于团队培训、技术分享和方案讲解。
部分内容对应真实的大型系统架构场景。准备面试、学习分布式系统，或需要制作技术培训材料，都可以直接从这里开始。
🔗 https://t.co/WRjvtKyMbY
查看缓存全文
缓存时间: 2026/09/20 05:15
系统设计面试资料总是又散又厚？这个开源项目把高频知识点压成了一张张架构图，复习效率会高很多。
system-design-101 由 ByteByteGo 团队制作，目前已有 84.1k Star，核心内容包括：
-
用图示拆解缓存、消息队列、数据库分片等难点，降低阅读长文档的成本。
-
覆盖限流、一致性哈希等系统设计面试常考主题，适合集中补齐知识盲区。
-
完全免费开源，现成的架构图还能用于团队培训、技术分享和方案讲解。
部分内容对应真实的大型系统架构场景。准备面试、学习分布式系统，或需要制作技术培训材料，都可以直接从这里开始。
🔗 https://t.co/WRjvtKyMbY
ByteByteGoHq/system-design-101
Source: https://github.com/ByteByteGoHq/system-design-101
【 👨🏻💻 YouTube | 📮 Newsletter 】
System Design 101
Explain complex systems using visuals and simple terms.
Whether you’re preparing for a System Design Interview or you simply want to understand how systems work beneath the surface, we hope this repository will help you achieve that.
Table of Contents
- API and Web Development
- Short/long polling, SSE, WebSocket
- Load Balancer Realistic Use Cases
- 5 HTTP Status Codes That Should Never Have Been Created
- How does gRPC work?
- How NAT Enabled the Internet
- Important Things About HTTP Headers
- Internet Traffic Routing Policies
- How Browsers Render Web Pages
- What makes HTTP2 faster than HTTP1?
- What is CSS (Cascading Style Sheets)?
- Key Use Cases for Load Balancers
- 18 Common Ports Worth Knowing
- What are the differences between WAN, LAN, PAN and MAN?
- How does Javascript Work?
- 8 Tips for Efficient API Design
- Reverse Proxy vs. API Gateway vs. Load Balancer
- How does REST API work?
- Load Balancer vs. API Gateway
- How GraphQL Works at LinkedIn
- GraphQL Adoption Patterns
- A cheat sheet for API designs
- API Gateway 101
- Top 3 API Gateway Use Cases
- What do version numbers mean?
- Do you know all the components of a URL?
- Unicast vs Broadcast vs Multicast vs Anycast
- 10 Essential Components of a Production Web Application
- URL, URI, URN - Differences Explained
- API vs SDK
- A Cheatsheet to Build Secure APIs
- HTTP Status Codes You Should Know
- SOAP vs REST vs GraphQL vs RPC
- A Cheatsheet on Comparing API Architectural Styles
- Top 9 HTTP Request Methods
- What is a Load Balancer?
- Proxy vs Reverse Proxy
- HTTP/1 -> HTTP/2 -> HTTP/3
- Polling vs Webhooks
- How do we Perform Pagination in API Design?
- How to Design Effective and Safe APIs
- How to Design Secure Web API Access
- What Does an API Gateway Do?
- What is gRPC?
- Top 12 Tips for API Security
- Explaining 9 Types of API Testing
- REST API vs. GraphQL
- What is GraphQL?
- REST API Cheatsheet
- The Ultimate API Learning Roadmap
- The Evolving Landscape of API Protocols in 2023
- Real World Case Studies
- 100X Postgres Scaling at Figma
- API of APIs - App Integrations
- The one-line change that reduced clone times by 99% at Pinterest
- Is Telegram Secure?
- Fixing Bugs Automatically at Meta Scale
- How Levelsfyi Scaled to Millions of Users with Google Sheets
- McDonald’s Event-Driven Architecture
- Uber Tech Stack - CI/CD
- How to Design Stack Overflow
- Twitter 1.0 Tech Stack
- How does Twitter recommend “For You” Timeline in 1.5 seconds?
- How YouTube Handles Massive Video Uploads
- How Does a Typical Push Notification System Work?
- 4 Ways Netflix Uses Caching
- Netflix Tech Stack - Databases
- 0 to 1.5 Billion Guests: Airbnb’s Architectural Evolution
- How Netflix Scales Push Messaging
- Netflix’s Overall Architecture
- Netflix Tech Stack - CI/CD Pipeline
- How TikTok Manages a 200K File Frontend MonoRepo
- How Netflix Really Uses Java
- Evolution of Airbnb’s Microservice Architecture
- Reddit’s Core Architecture
- 10 Principles for Building Resilient Payment Systems
- What is the Journey of a Slack Message?
- Top 9 Engineering Blogs
- Uber Tech Stack
- Evolution of the Netflix API Architecture
- How Discord Stores Trillions of Messages
- Twitter Architecture 2022 vs. 2012
- Evolution of Uber’s API Layer
- Netflix’s Tech Stack
- AI and Machine Learning
- Database and Storage
- Read Replica Pattern
- Pessimistic vs Optimistic Locking
- How to Upload a Large File to S3
- Types of Message Queues
- Smooth Data Migration with Avro
- The Ultimate Kafka 101 You Cannot Miss
- Database Isolation Levels
- Top 6 Data Management Patterns
- Why is Kafka Fast?
- Explaining the 4 Most Commonly Used Types of Queues
- Time Series DB (TSDB) in 20 Lines
- Differences in Event Sourcing System Design
- Erasure Coding
- Delivery Semantics
- Change Data Capture: Key to Leverage Real-time Data
- Can Kafka Lose Messages?
- Storage Systems Overview
- Explain the Top 6 Use Cases of Object Stores
- Top Eventual Consistency Patterns You Must Know
- B-Tree vs. LSM-Tree
- How to Decide Which Type of Database to Use
- Cloud Database Cheat Sheet
- Types of Memory
- Understanding Database Types
- Top 4 Data Sharding Algorithms Explained
- Top 6 Database Models
- SQL Statement Execution in Database
- What is Serverless DB?
- Why PostgreSQL is the Most Loved Database
- Top 10 Most Popular Open-Source Databases
- Is PostgreSQL Eating the Database World?
- How to Choose the Right Database
- iQIYI Database Selection Trees
- 8 Data Structures That Power Your Databases
- How to Implement Read Replica Pattern
- A Crash Course on Database Sharding
- IBM MQ -> RabbitMQ -> Kafka -> Pulsar: Message Queue Evolution
- CAP Theorem: One of the Most Misunderstood Terms
- Consistent Hashing Explained
- Types of Databases
- Key Concepts to Understand Database Sharding
- Database Locks Explained
- A Cheatsheet on Database Performance
- What does ACID mean?
- Top 5 Kafka Use Cases
- Types of Memory and Storage
- 7 Must-Know Strategies to Scale Your Database
- Technical Interviews
- Caching & Performance
- What is ELK Stack and Why is it Popular?
- Why are Content Delivery Networks (CDN) so Popular?
- How Big Keys Impact Redis Persistence
- A Beginner’s Guide to CDN
- The Ultimate Redis 101
- Cache Systems Every Developer Should Know
- Top 5 Strategies to Reduce Latency
- Top 5 Caching Strategies
- Things to Consider When Using Cache
- Cache Eviction Policies
- Memcached vs Redis
- Low Latency Stock Exchange
- Cache Miss Attack
- Top 8 Cache Eviction Strategies
- How Can Cache Systems Go Wrong?
- Top 6 Elasticsearch Use Cases
- How Does CDN Work?
- How Redis Architecture Evolved
- How Does Redis Persist Data?
- How can Redis be used?
- Why is Redis so Fast?
- How to Learn Elasticsearch
- What is CDN (Content Delivery Network)?
- Frontend Performance Optimization
- Which Latency Numbers Should You Know?
- Top Caching Strategies
- Top 9 Website Performance Metrics You Cannot Ignore
- Top 5 Common Ways to Improve API Performance
- Learn Cache
- Payment and Fintech
- E-commerce Workflow
- Digital Wallets: Banks vs. Blockchain
- What is a Stop-Loss Order and How Does it Work?
- What is Web 3.0? Why doesn’t it have ads?
- SWIFT Payment Messaging System
- 4 Ways of QR Code Payment
- Handling Hotspot Accounts
- Reconciliation in Payment
- Unified Payments Interface (UPI)
- How Scan to Pay Works
- Money Movement
- Payment System
- How to Learn Payments
- The Payments Ecosystem
- Foreign Exchange Payments
- How to Avoid Double Payment
- How do Apple Pay and Google Pay work?
- How VISA Works When Swiping a Credit Card
- How ACH Payment Works
- How does Visa make money?
- Software Architecture
- Inter-Process Communication on Linux
- Orchestration vs. Choreography in Microservices
- UML Class Diagrams Cheatsheet
- Amazon Prime Video Monitoring Service
- Is Microservice Architecture the Silver Bullet?
- Database Middleware
- 9 Best Practices for Developing Microservices
- Design Patterns Cheat Sheet
- Key Terms in Domain-Driven Design
- 8 Key OOP Concepts Every Developer Should Know
- 18 Key Design Patterns Every Developer Should Know
- 10 System Design Tradeoffs You Cannot Ignore
- 9 Essential Components of a Production Microservice Application
- 9 Best Practices for Building Microservices
- 8 Key Concepts in Domain-Driven Design
- 8 Common System Design Problems and Solutions
- 6 Software Architectural Patterns You Must Know
- How To Release A Mobile App
- How Do Computer Programs Run?
- Linux Boot Process Explained
- MVC, MVP, MVVM, VIPER Patterns
- The Ultimate Software Architect Knowledge Map
- Typical Microservice Architecture
- Top 5 Software Architectural Patterns
- DevTools & Productivity
- Git Commands Cheat Sheet
- How does Git Work?
- JSON Crack: Visualize JSON Files
- Git vs GitHub
- Git Merge vs. Git Rebase
- 30 Useful AI Apps That Can Help You in 2025
- Diagram as Code
- Top 9 Causes of 100% CPU Usage
- Top 6 Tools to Turn Code into Beautiful Diagrams
- Tools for Shipping Code to Production
- Making Sense of Search Engine Optimization
- Most Used Linux Commands Map
- Linux File Permissions Illustrated
- 5 Important Components of Linux
- 15 Open-Source Projects That Changed the World
- 20 Popular Open Source Projects Started by Big Companies
- Linux File System Explained
- Life is Short, Use Dev Tools
- How Git Works
- How do Companies Ship Code to Production?
- Software Development
- Top 6 Most Commonly Used Server Types
- How does Garbage Collection work?
- A Roadmap for Full-Stack Development
- What Are the Greenest Programming Languages?
- Java Collection Hierarchy
- Running C, C++, or Rust in a Web Browser
- Top 8 C++ Use Cases
- Top 6 Multithreading Design Patterns You Must Know
- Data Transmission Between Applications
- Blocking vs Non-Blocking Queue
- Big Endian vs Little Endian
- How to Avoid Crawling Duplicate URLs at Google Scale?
- 10 Books for Software Developers
- Top 8 Standards Every Developer Should Know
- How Do C++, Java, Python Work?
- 10 Key Data Structures We Use Every Day
- A Brief History of Programming Languages
- Top 6 Load Balancing Algorithms
- The Fundamental Pillars of Object-Oriented Programming
- Top 8 Programming Paradigms
- Algorithms for System Design Interviews
- Imperative vs Functional vs Object-oriented Programming
- Explaining 9 Types of API Testing
- The 9 Algorithms That Dominate Our World
- Concurrency vs Parallelism
- Linux Boot Process Explained
- 11 Steps to Go From Junior to Senior Developer
- 10 Good Coding Principles to Improve Code Quality
- Cloud & Distributed Systems
- How AWS Lambda Works Behind the Scenes
- 8 Must-Know Scalability Strategies
- System Design Cheat Sheet
- Cloud Disaster Recovery Strategies
- Vertical vs Horizontal Partitioning
- Top 9 Architectural Patterns for Data and Communication Flow
- Top 6 Cases to Apply Idempotency
- Top 5 Trade-offs in System Designs
- How to Detect Node Failures in Distributed Systems
- Why Meta, Google, and Amazon Stop Using Leap Seconds
- The Fantastic Four of System Design
- What makes AWS Lambda so fast?
- Scaling Websites for Millions of Users
- Resiliency Patterns
- 25 Papers That Completely Transformed the Computer World
- A Crash Course on Architectural Scalability
- Must Know System Design Building Blocks
- Monorepo vs. Microrepo: Which is Best?
- How to Handle Web Request Errors
- A Cheat Sheet for Designing Fault-Tolerant Systems
- Typical AWS Network Architecture
- Unique ID Generator
- Amazon’s Build System: Brazil
- Infrastructure as Code Landscape Cheatsheet
- How do we manage configurations in a system?
- How do we incorporate Event Sourcing into systems?
- The 12-Factor App
- Explaining 5 Unique ID Generators
- Retry Strategies for System Failures
- Cloud Monitoring Cheat Sheet
- Why Use a Distributed Lock?
- Top 6 Cloud Messaging Patterns
- Most Important AWS Services to Learn
- How to Transform a System to be Cloud Native
- Hidden Costs of the Cloud
- 2 Decades of Cloud Evolution
- Cloud Cost Reduction Techniques
- Top 7 Most-Used Distributed System Patterns
- Cloud Load Balancer Cheat Sheet
- AWS Services Evolution
- Azure Services Cheat Sheet
- A cheat sheet for system designs
- CAP, BASE, SOLID, KISS, What do these acronyms mean?
- System Design Blueprint: The Ultimate Guide
- How to Design for High Availability
- What is Cloud Native?
- Cloud Comparison Cheat Sheet
- Big Data Pipeline Cheatsheet for AWS, Azure, and Google Cloud
- AWS Services Cheat Sheet
- How it Works?
- How do AirTags work?
- How is Email Delivered?
- Design Gmail
- How Google/Apple Maps Blur License Plates and Faces
- Quadtree
- Build a Simple Chat Application with Redis
- Live Streaming Explained
- How to Design a System for Internationalization
- How to Design Google Docs
- Payment System
- Experiment Platform Architecture
- Design Google Maps
- Designing a Chat Application
- Design Stock Exchange
- How are Notifications Pushed to Our Phones or PCs?
- What Happens When You Upload a File to Amazon S3?
- Proximity Service
- How Do Search Engines Work?
- DevOps and CI/CD
- Top 10 Kubernetes Design Patterns
- Some DevOps Books I Find Enlightening
- Paradigm Shift: Developer to Tester Ratio
- Push vs Pull in Metrics Collection Systems
- Choose the Right Database for Metric Collection
- Top 4 Kubernetes Service Types
- Cloud Native Anti-Patterns
- Kubernetes Tools Stack Wheel
- Kubernetes Tools Ecosystem
- Kubernetes Periodic Table
- 9 Docker Best Practices You Must Know
- Netflix Tech Stack - CI/CD Pipeline
- Top 8 Must-Know Docker Concepts
- CI/CD Simplified Visual Guide
- Top 5 Most-Used Deployment Strategies
- Kubernetes Command Cheatsheet
- Kubernetes Deployment Strategies
- How does Terraform turn Code into Cloud?
- DevOps vs. SRE vs. Platform Engineering
- Deployment Strategies
- Logging, Tracing, and Metrics
- Log Parsing Cheat Sheet
- DevOps vs NoOps: What’s the Difference?
- Why is Nginx so Popular?
- What is Kubernetes (k8s)?
- How does Docker work?
- CI/CD Pipeline Explained in Simple Terms
- Security
- What is DevSecOps?
- Encoding vs Encryption vs Tokenization
- Storing Passwords Safely: A Comprehensive Guide
- Designing a Permission System
- How Password Managers Work
- Is PassKey Shaping a Passwordless Future?
- Firewall Explained to Kids and Adults
- Cookies vs Sessions
- HTTP Cookies Explained With a Simple Diagram
- Token, Cookie, Session
- Sessions, Tokens, JWT, SSO, and OAuth Explained
- How to Design a Secure System
- Top 6 Firewall Use Cases
- Top 4 Authentication Mechanisms
- How Digital Signatures Work
- How do we manage sensitive data in a system?
- HTTPS, SSL Handshake, and Data Encryption Explained
- Symmetric vs Asymmetric Encryption
- Session-based Authentication vs. JWT
- JWT 101: Key to Stateless Authentication
- Is HTTPS Safe?
- Cybersecurity 101
- Cookies vs Sessions vs JWT vs PASETO
- How does SSH work?
- How Does a VPN Work?
- How Google Authenticator Works
- Types of VPNs
- What is a Cookie?
- OAuth 2.0 Flows
- Top Network Security Cheatsheet
- What is SSO (Single Sign-On)?
- How does HTTPS work?
- Session, Cookie, JWT, Token, SSO, and OAuth 2.0 Explained
- Explaining JSON Web Token (JWT) to a 10 Year Old Kid
- OAuth 2.0 Explained With Simple Terms
- Computer Fundamentals
- Paging vs Segmentation
- IPv4 vs. IPv6: Differences
- Top 4 Most Popular Use Cases for UDP
- How Does the Domain Name System (DNS) Lookup Work?
- DNS Record Types You Should Know
- TCP vs UDP for Online Gaming
- What is a Deadlock?
- Process vs Thread: Key Differences
- OSI Model Explained
- Visualizing a SQL Query
- Explaining 8 Popular Network Protocols in 1 Diagram
- What is the Best Way to Learn SQL?
License
This work is licensed under CC BY-NC-ND 4.0
相似文章
@vintcessun: 一早翻到一个有意思的项目，改变了我对面试准备的认知。一直以为大厂面试刷题就够了，但本质上它考察的是完整的计算机科学知识体系。这个项目把离散的知识点串成了一个系统计划，从 Big-O、数据结构、算法到系统设计、面试技巧全覆盖，甚至包含如何写…
A popular GitHub project providing a comprehensive multi-month study plan for software engineering interviews, covering CS fundamentals, algorithms, system design, and resume tips.
@GitHub_Daily: 想要转型 AI 开发或者准备系统设计面试，网上找到的大部分资料都是理论或者知识点已过时。 偶然看到 AI System Design Guide 这份在持续更新的系统性 AI 学习指南。 整理了 110 道面试真题和答题框架，涵盖 RAG…
推荐一份持续更新的AI系统设计学习指南，涵盖110道面试真题和答题框架，包括RAG架构、Agent智能体等核心技术栈。
@QingQ77: 开源架构知识库，收录 25 个真实系统架构模板和一套系统化架构思维教程。 https://github.com/study8677/awesome-architecture… 这个仓库不讲代码，只讲架构。收录了 25 个热门系统的架构模板…
这是一个开源架构知识库，收录了 25 个真实系统架构模板和一套系统化架构思维教程，帮助开发者培养架构设计能力。
@bkdgiffug: 操作系统底层原理向来是计算机领域的硬骨头。几十万行内核源码摊在眼前，翻上几页便头晕目眩，既抓不住设计主线，更谈不上通篇精读。 egos-2000这个教学项目，只用2000行代码，就把操作系统的核心组件完整呈现了出来。 这套系统的三层架构尤…
egos-2000是一个教学操作系统项目，仅用2000行代码实现操作系统核心组件，三层架构清晰，支持RISC-V平台，配套教材提供9个课程项目，便于学习和实践。
donnemartin/system-design-primer
一个开源的入门指南，整理了系统设计概念，提供学习指南、Anki 闪卡和练习面试题，帮助工程师构建大规模系统并准备系统设计面试。