30 Must‑Know System Design Concepts to Build Scalable, Reliable Applications

1. Client‑Server Architecture

Every web application follows a client‑server model where the client (browser, mobile app, etc.) sends requests to a server that processes them and returns responses.

2. IP Addresses

Clients need an IP address to locate servers. The Internet uses IPv4/IPv6 addresses as the “phone numbers” of machines.

3. DNS

Domain Name System translates human‑readable domain names (e.g., algomaster.io) into IP addresses. When you type a URL, your browser queries a DNS server, receives the IP, and connects to the server.

4. Proxies and Reverse Proxies

Proxy: Acts as a middleman between a client and the Internet, hiding the client’s IP.

Reverse proxy: Sits in front of one or more backend servers, forwarding client requests, providing load balancing, security, and SSL termination.

5. Latency

Network latency is the total time for data to travel between client and server, heavily influenced by physical distance. Reducing latency often means deploying servers closer to users.

6. HTTP/HTTPS

Clients and servers communicate via HTTP. HTTPS adds TLS encryption to protect data in transit.

7. API (Application Programming Interface)

APIs abstract the underlying services, allowing clients to request data without handling low‑level details. Responses are typically JSON or XML.

8. REST API

Stateless, resource‑oriented.

Uses standard HTTP methods: GET, POST, PUT/PATCH, DELETE.

REST is simple and cacheable but can over‑fetch data.

9. GraphQL

GraphQL lets clients request exactly the fields they need, reducing over‑fetching. It requires more server‑side processing and is less cache‑friendly than REST.

10. Databases

Databases store persistent data. Choosing between SQL (strong consistency, ACID) and NoSQL (high scalability, flexible schema) depends on the workload.

11. SQL vs. NoSQL

SQL: Structured tables, strict schema, ACID guarantees—ideal for financial systems.

NoSQL: Key‑value, document, graph, or wide‑column stores—better for massive, rapidly changing data.

12. Vertical Scaling (Scaling Up)

Adding CPU, RAM, or storage to a single machine increases capacity but hits hardware limits, cost, and single‑point‑of‑failure risks.

13. Horizontal Scaling (Scaling Out)

Adding more servers distributes load, improves fault tolerance, and is cost‑effective. A load balancer decides which server handles each request.

14. Load Balancers

Round‑robin

Least connections

IP hash (session affinity)

They also detect unhealthy servers and reroute traffic.

15. Database Indexes

Indexes speed up read queries by maintaining a lookup structure for frequently queried columns (primary keys, foreign keys, WHERE clauses). Over‑indexing hurts write performance.

16. Caching

Cache stores frequently accessed data in memory (e.g., Redis, Memcached) to avoid repeated database reads. Cache‑aside pattern checks the cache first, falls back to the DB, then populates the cache.

17. Non‑Normalization (Denormalization)

Combining related data into a single table reduces JOINs and improves read speed at the cost of data redundancy and more complex writes.

18. CAP Theorem

In a distributed system you can only guarantee two of three properties: Consistency, Availability, Partition tolerance. Systems choose CP (e.g., traditional SQL) or AP (e.g., Cassandra, DynamoDB) based on requirements.

19. Blob Storage

Large binary objects (images, videos, PDFs) are stored in object storage services like Amazon S3, which provide virtually unlimited scalability, durability, and HTTP access via unique URLs.

20. CDN (Content Delivery Network)

CDNs cache static assets in edge locations worldwide, delivering them from the node closest to the user to reduce latency and bandwidth costs.

21. WebSockets

WebSockets provide a persistent, full‑duplex connection for real‑time communication, eliminating the need for frequent HTTP polling.

22. Webhooks

Webhooks let external services push events to your server via HTTP POST, enabling near‑real‑time reactions without polling.

23. Microservices

Instead of a monolithic codebase, break the application into independent services, each owning its data and exposing APIs. This improves scalability, fault isolation, and independent deployment.

24. Message Queues

Message queues (e.g., Kafka, RabbitMQ) decouple producers and consumers, enabling asynchronous processing, load smoothing, and resilience to spikes.

25. Rate Limiting

Rate limiting caps the number of requests a client can make in a time window (e.g., 100 requests per minute). Common algorithms: fixed window, sliding window, token bucket.

26. API Gateways

An API gateway is a single entry point that handles authentication, rate limiting, logging, and routes requests to the appropriate microservice.

27. Idempotency

Idempotent operations produce the same result no matter how many times they are repeated. Assign a unique request ID; if the server sees the ID again, it returns the original result instead of processing twice.

Illustrative Images