Wenhao HeBlog

Key Concepts in System Design

4 min readWenhao He

Understanding core system design concepts is crucial for building scalable, performant, and reliable software systems. This post summarizes foundational ideas like client-server architecture, scaling strategies, databases, and caching patterns to help solidify your knowledge for interviews or real-world engineering work.

Key Concepts in System Design

  1. Client-Server Architecture: The client (e.g., browser or mobile app) sends a request to the server, which processes it and sends back a response
  2. Domain Name System (DNS): Translates human-readable domain names into IP addresses to locate and connect to servers
  3. Proxy & Reverse Proxy:
    • Proxy: Acts as a middleman between client and server to mask the client’s IP and protect identity
    • Reverse Proxy: Intercepts client requests and forwards them to backend servers based on predefined rules
  4. Latency: Delay between request and response. High latency makes applications feel slow and unresponsive
  5. API (REST): Interfaces used to perform CRUD operations over HTTP:
    • GET – Retrieve data
    • POST – Create data
    • PUT – Update data
    • DELETE – Remove data
  6. SQL vs NoSQL
    • SQL: Structured, relational data with predefined schema. Ensures ACID properties and strong consistency
    • NoSQL: Flexible schema, high performance, high scalability — better suited for unstructured data
  7. Vertical Scaling: Quick fix for huge amount of request made when user base grows, add more resources (CPU, RAM, storage) to a single machine to handle more traffic
  8. Horizontal Scaling: Add more servers to handle increasing load and provide redundancy, when one server goes down, others can take over
  9. Load Balancer: Distributes incoming traffic across multiple servers. Algorithms include Round-Robin, Least Connections, and IP Hashing
  10. Indexing: Improves query performance on databases by creating data structures that allow faster retrieval, at the cost of extra write-time overhead
  11. Sharding (Horizontal Partitioning): Handle large data efficiently, instead of keeping everything in one place, split large database into smaller, manageable pieces by rows to improve performance and scalability
  12. Vertical Partitioning: Split a database by columns (e.g., user profile vs user activity) to improve query performance
  13. Caching: Used to optimize the performance of a system by storing frequently accessed data in memory instead of repeatedly fetching it from database
    • Cache-Aside Pattern: User request data, the application first checks the cache if in the cache, its returned instantly avoid database call; if not, retrieves from database & stores in the cache for future request, returns to the user
  14. CAP Theorem: In a distributed system, you can only guarantee two of the following:
    • Consistency: Every read receives the most recent write or an error
    • Availability: Every request receives a response (without guaranteeing it contains the most recent writes)
    • Partition Tolerance: System continues functioning despite network partition
  15. Blob Storage: Blobs are individual files (e.g., images, videos, documents), stores in logical container or buckets in the cloud, each file has URL make it easy to retrieve and serve over the web
    • Advantage: Scalability, pay as you go model, automatic replication, and easy access
  16. Content Delivery Network (CDN): Delivers static web content (HTML, JS, images, videos) from geographically closer servers for faster access
  17. Microservices: Break an application into small, independently deployable services, has own database and logic communicates with other microservices using APIs or messaging queues
  18. API Gateway: A centralized service, a simple entry point for all client requests, it simplifies API management and improves scalability and security
  19. Idempotency: Repeating a request (e.g., retrying a failed PUT) produces the same result as making it once — critical for reliability
  20. ACID: A set of properties that guarantee reliable database transactions
    • Atomicity: All operations in a transaction are completed; if one fails, the entire transaction is rolled back
    • Consistency: Ensures the database remains in a valid state before and after the transaction
    • Isolation: Transactions are executed independently without interference, even if run concurrently
    • Durability: Once a transaction is committed, it remains so — even in the event of a crash or power loss

I hope this gives you a solid overview of essential system design concepts — helpful for interviews, architecture reviews, and real-world engineering work.

#system design#concept