Understanding System Design Fundamentals

System design is one of the most important skills for a software engineer. Whether you're building a small API or a distributed system, these fundamentals apply.

The CAP Theorem

Every distributed system must choose between:

1. Consistency — every read returns the most recent write
2. Availability — every request receives a response
3. Partition tolerance — the system continues to operate despite network partitions

In practice, since network partitions are inevitable, you're really choosing between CP and AP systems.

Load Balancing Strategies

# Round-robin load balancer (simplified)
class LoadBalancer:
    def __init__(self, servers: list[str]):
        self.servers = servers
        self.current = 0

    def next_server(self) -> str:
        server = self.servers[self.current]
        self.current = (self.current + 1) % len(self.servers)
        return server

lb = LoadBalancer(["server-1", "server-2", "server-3"])
for _ in range(6):
    print(lb.next_server())

Caching Layers

A typical caching strategy involves multiple layers:

Layer	Technology	TTL	Use Case
Browser	HTTP Cache	Varies	Static assets
CDN	CloudFront/Cloudflare	1-24h	Global distribution
Application	Redis/Memcached	5-60min	Hot data
Database	Query cache	Session	Repeated queries

Database Scaling

Vertical Scaling

Simply add more resources (CPU, RAM) to your existing server. Simple but has limits.

Horizontal Scaling

Distribute data across multiple servers using sharding:

-- Shard by user_id modulo
-- Shard 0: user_id % 3 == 0
-- Shard 1: user_id % 3 == 1
-- Shard 2: user_id % 3 == 2

SELECT * FROM users WHERE user_id = 42;
-- Routes to shard: 42 % 3 = 0

Conclusion

System design is a broad topic, but understanding these fundamentals gives you a solid foundation. Start simple, measure everything, and scale when the data tells you to.