Unit
- Scalability: The ability of a system to handle increased load by adding resources, either by upgrading existing components (vertical) or adding more components (horizontal). A scalable system maintains performance and reliability as demand grows.
- Vertical scaling: Also called scaling up. It means adding more power to a single machine, such as faster CPU, more RAM, or larger disk. It is limited by hardware ceilings and often leads to downtime during upgrades.
- Horizontal scaling: Also called scaling out. It means adding more machines to a pool of resources. It offers near-infinite growth but introduces complexity in coordination, data consistency, and network communication.
- Design for growth: Scalability must be considered from the start. Retrofitting scalability into a monolithic system is costly and can introduce architectural debt. Early decisions about statelessness, data distribution, and fault tolerance shape future scaling options.
- Dimensions of scalability: Load scalability handles increasing user requests, geographic scalability serves users across regions, administrative scalability manages growing teams or permissions, and functional scalability adds new features without degrading existing ones.
- Trade-offs: Higher scalability often sacrifices consistency or simplicity. The CAP theorem states that a distributed system can only guarantee two of Consistency, Availability, and Partition Tolerance. Understanding these trade-offs guides architectural choices.
- Cost of scaling: Scaling linearly is rare. As systems grow, coordination overhead, data transfer, and operational complexity can cause sublinear returns. Engineers must analyze cost versus benefit when choosing scaling strategies.
- Real-world pattern: A typical path for startups is to start with vertical scaling for simplicity, then migrate to horizontal scaling using sharding, caching, and load balancers as the user base expands. Each phase introduces new operational challenges.
- Elasticity: The ability to automatically provision and deprovision resources in response to demand. Cloud platforms enable elasticity through auto scaling groups and pay as you go models. This reduces overprovisioning costs while maintaining performance during traffic spikes. Elasticity is a key characteristic of cloud native systems.
- Stateless design: Stateless services do not store session state on the server, allowing any request to be handled by any instance. This simplifies horizontal scaling because new instances can be added without migrating state. Stateful components like databases are externalized. Statelessness reduces coupling and improves fault tolerance.
- Caching strategies: Caching reduces load on backend systems by storing frequently accessed data in fast memory. Common caches include in memory caches like Redis and CDNs for static content. Cache invalidation, expiration policies, and write through versus write behind patterns affect consistency and performance. Effective caching can drastically improve scalability.
Code Example
Python
# Horizontal scaling with a load balancer simulation
import random
servers = ['server1', 'server2', 'server3']
def route_request(request):
server = random.choice(servers)
print('Forwarding {} to {}'.format(request, server))
return server
# Usage
route_request('user_login')This simplified example shows distributing requests across multiple servers using random choice. In production, load balancers use weighted round-robin, least connections, or consistent hashing to ensure even distribution and session affinity.
Quick Revision
- Scalability is the ability to handle increased load by adding resources.
- Vertical scaling (upgrade single machine) has hardware limits and downtime risks.
- Horizontal scaling (add more machines) offers near-infinite growth but adds complexity.
- Design for scalability early to avoid costly retrofits.
- Four dimensions: load, geographic, administrative, functional.
- Trade-offs governed by CAP theorem and cost considerations.