Horizontal vs Vertical Scaling
Scaling is at the heart of high-level design (HLD).
When traffic grows, you must decide: scale up (vertical scaling) or scale out (horizontal scaling).
1. Vertical Scaling (Scale Up)
What It Is
- Increase capacity of a single server.
- Add more CPU, RAM, storage, or faster hardware.
Advantages
- Simple to implement (no code changes).
- Works well for small-scale systems.
- Useful for short-term bottlenecks (e.g., DB out of memory).
Disadvantages
- Expensive at higher levels (diminishing returns).
- Hardware limits (there’s always a max size).
- Single point of failure (SPOF).
- No redundancy by default.
Examples
- Upgrading DB from 8GB RAM → 64GB RAM.
- Adding faster SSDs to improve IO performance.
2. Horizontal Scaling (Scale Out)
What It Is
- Add more servers (nodes) to handle traffic.
- Workload distributed via load balancing.
Advantages
- Virtually unlimited scaling (add more nodes).
- High availability (if one node fails, others still serve traffic).
- Commodity hardware (cheaper than giant servers).
- Foundation for microservices, cloud-native systems.
Disadvantages
- Requires distributed systems design (stateless apps, data sharding).
- Load balancing complexity.
- Harder debugging/monitoring.
- Consistency challenges.
Examples
- Web servers behind load balancer.
- Database read replicas.
- Sharding large datasets across nodes.
3. Vertical vs Horizontal — Comparison
| Feature | Vertical Scaling | Horizontal Scaling |
|---|---|---|
| How it works | Bigger machine (scale up) | More machines (scale out) |
| Complexity | Low | High (distributed systems needed) |
| Cost | Expensive at scale | Scales with commodity hardware |
| Fault tolerance | Single point of failure | High availability with redundancy |
| Limits | Hardware cap | Near-infinite (practically) |
4. Real-World Strategies
- Start with vertical scaling → simplest way to remove bottlenecks.
- Once limits are hit → move to horizontal scaling.
- Often combined:
- DB vertically scaled (bigger instance) + horizontally scaled (read replicas).
- Web tier horizontally scaled with load balancers.
5. Interview Tips
- Always mention both options: “I’d first scale vertically, but once I hit limits, I’d move to horizontal scaling.”
- Acknowledge complexity of horizontal scaling (state management, sharding).
- Bring up SPOF when describing vertical scaling.
- Mention load balancing and replication for horizontal scaling.
6. Next Steps
- Learn about Microservices vs Monoliths.
- Explore Event-driven Architectures.