Horizontal scaling
Horizontal scaling is increasing or decreasing system capacity by adding or removing computing nodes or service instances that share the workload.
The Cloud at Your Service: The when, how, and why of enterprise cloud computing
A scaling technique that increases capacity by adding instances or machines rather than increasing the resources of one machine.
- How it is used
- Uses horizontal scaling to address cloud application capacity and operational resilience.
- How deep it goes
- Explains database sharding, data-model trade-offs, and operational readiness without detailed implementation steps.
- Examples
- Illustrates scaling with partitioned database servers, car records in a key-value store, and added web servers.
- What you can do after
- Evaluate horizontal scaling through database design, automation readiness, and failure-planning trade-offs.
Grokking Software Architecture
Increasing capacity by adding instances of a system component across multiple servers or processes.
- How it is used
- Addresses increased traffic by adding application instances, including independently scaling a busy microservice.
- How deep it goes
- Explains load balancing, server failure, and external session state, but stops short of deployment instructions.
- Examples
- Uses a coffee shop queue, a disappearing shopping cart, and a traffic-heavy inventory service.
- What you can do after
- Evaluate horizontal scaling against capacity needs, state-management complexity, resilience, and business cost.
Read how Grokking Software Architecture explains horizontal scaling →
Spring Microservices in Action
A scaling approach that increases capacity by launching additional service instances rather than relying only on a single instance's threads.
- How it is used
- Uses horizontal scaling to adjust microservice capacity and support resilience as demand and instance availability change.
- How deep it goes
- Explains horizontal scaling through capacity tradeoffs, service discovery, and runtime practices, without an implementation walkthrough.
- Examples
- Illustrates horizontal scaling by adding message consumers when a queue is processed too slowly.
- What you can do after
- Evaluate horizontal scaling against larger hardware or more threads, including its implications for service discovery and instance disposal.
Read how Spring Microservices in Action explains horizontal scaling →
Amazon Web Services in Action, Third Edition: An in-depth guide to AWS
Horizontal scaling is increasing or decreasing system capacity by adding or removing equivalent computing instances.
- How it is used
- Uses horizontal scaling to handle changing EC2 workloads and increase database read and write capacity.
- How deep it goes
- Defines scaling through instance counts and database nodes, then outlines architectural requirements and capacity modes without providing configuration commands.
- Examples
- Illustrates spiky demand with web-application error tracking and a business-hours batch job that briefly raises database throughput.
- What you can do after
- Evaluate/understand it by identifying prerequisites for a dynamic EC2 pool and comparing DynamoDB capacity modes against demand.
MongoDB 8.0 in Action, Third Edition
Horizontal scaling is the practice of increasing capacity by distributing workloads across additional machines or partitions.
- How it is used
- Positions horizontal scaling as MongoDB’s way to accommodate growing datasets and high transaction rates by distributing data and workload.
- How deep it goes
- Explains sharding at collection and cluster level, including trade-offs, but provides no shard-creation commands in the supplied passages.
- Examples
- Uses RAM and disk capacity limits, a sharded-cluster diagram, and Atlas autoscaling behavior as concrete reference points.
- What you can do after
- Evaluate/understand when sharding addresses capacity or write bottlenecks, and why replication or Atlas tier autoscaling is not a substitute.
Read how MongoDB 8.0 in Action, Third Edition explains horizontal scaling →
Acing the Frontend Interview
Horizontal scaling increases capacity by adding or removing system instances or machines rather than enlarging a single instance.
- How it is used
- Frames horizontal scaling as an interview-relevant architectural choice for improving capacity, resilience, and cloud compatibility.
- How deep it goes
- Explains the definition, trade-offs, selection criteria, and load-balancer relationship, while deferring advanced state design and tuning.
- Examples
- Uses a one-server-to-three-server diagram, a scaling-strategies comparison table, and interview questions about scaling and load balancing.
- What you can do after
- Evaluate scaling choices in interviews and explain how load balancing supports multiple application instances.
Read how Acing the Frontend Interview explains horizontal scaling →
Elasticsearch in Action, Second Edition
Horizontal scaling increases system capacity by adding more nodes or machines rather than increasing the resources of an existing node.
- How it is used
- Increases Elasticsearch capacity for growing data, query loads, read throughput, or indexing performance by adding cluster nodes.
- How deep it goes
- Explains node addition, cluster membership, capacity planning, and a 10 TB example, but defers detailed shard-sizing treatment.
- Examples
- Uses a 25-node, 10 TB multi-index cluster and compares adding 20 nodes with enlarging five existing servers.
- What you can do after
- Operate/configure an Elasticsearch cluster by adding nodes and forecasting capacity for data, memory, throughput, and indexing demands.
Read how Elasticsearch in Action, Second Edition explains horizontal scaling →
Fast by Default
Horizontal scaling is increasing system capacity by adding and distributing work across additional instances or nodes.
- How it is used
- Uses added servers, stateless design, shared state, and measured load growth to preserve performance as systems scale.
- How deep it goes
- Explains statelessness, shared storage, sharding, audits, and load measurement, while deferring platform-specific implementation details.
- Examples
- Uses cookies, Redis, projected tenfold or hundredfold datasets, cache failures, load spikes, and database sharding decisions.
- What you can do after
- Evaluate scaling risks, externalize shared state, test projected load, and select decomposition or partitioning only when evidence supports it.
Distributed Machine Learning Patterns
A scaling technique that increases capacity by adding equivalent service instances or machines rather than enlarging one instance.
- How it is used
- Handles growing model-serving traffic by deploying replicated services.
- How deep it goes
- Explains statelessness, replica placement, asynchronous processing, and load distribution, but omits detailed implementation configuration.
- Examples
- Uses video-upload inference, replicated model servers, separate server addresses, and a load-balancer diagram.
- What you can do after
- Apply it via replicated model-serving services to handle more requests asynchronously.
Read how Distributed Machine Learning Patterns explains horizontal scaling →
Microservices Patterns, Second Edition
A scaling technique that increases capacity by adding concurrent instances of a service or processing component.
- How it is used
- Uses horizontal scaling to increase message-processing throughput and assess capacity for CQRS view databases.
- How deep it goes
- Details shard-key routing and receiver assignment, then contrasts partitioned NoSQL growth with vertical relational database scaling.
- Examples
- Uses ordered order-lifecycle events across three receivers and contrasts NoSQL and relational database scaling.
- What you can do after
- Evaluate database scalability against view load and availability requirements, and understand how partitioned receivers preserve message order.
Read how Microservices Patterns, Second Edition explains horizontal scaling →
Building Web APIs with ASP.NET Core
Horizontal scaling increases capacity by adding or removing service instances rather than enlarging one instance.
- How it is used
- Compares database scaling strategies when choosing between SQL and NoSQL storage.
- How deep it goes
- Defines scale-out through clusters, workload sharing, and node changes, while stopping short of implementation details.
- Examples
- Uses multiple database servers forming a cluster and adding or removing nodes to accommodate workload requirements.
- What you can do after
- Evaluate database architectures by comparing scale-out, scale-up, workload distribution, availability, and operational trade-offs.
Read how Building Web APIs with ASP.NET Core explains horizontal scaling →
ScyllaDB in Action
Cluster scaling is the operation of increasing a cluster's capacity by adding nodes while retaining its existing nodes.
- How it is used
- Expands ScyllaDB capacity when application demand exceeds the current cluster’s resources.
- How deep it goes
- Defines node-based expansion and gives a procedural scale-up checklist, including readiness, rack balance, and cleanup.
- Examples
- Uses added cluster nodes, nodetool status, rack balancing, and nodetool cleanup as operational examples.
- What you can do after
- Operate/configure a ScyllaDB scale-up by adding nodes sequentially, checking readiness, balancing racks, and cleaning transferred data.
Refactoring to Rust
Horizontal scaling is increasing service capacity by running additional instances of a system.
- How it is used
- Uses additional service instances to address throughput bottlenecks without adding resources to one machine.
- How deep it goes
- Defines horizontal scaling, contrasts vertical scaling, and demonstrates process duplication before addressing distributed-service code changes.
- Examples
- Demonstrates concurrent Python processes producing the same `single.png` output and overwriting one another.
- What you can do after
- Diagnoses why duplicated service instances can collide on outputs even when the underlying computation is idempotent.
Microsoft Azure in Action
A scaling technique that adds or removes database or virtual-machine instances to change aggregate computing capacity.
- How it is used
- Distributes changing application or database workload across additional instances instead of enlarging one instance.
- How deep it goes
- Defines scaling out, contrasts vertical scaling, and explains VM pools, read replicas, autoscaling, and workload routing.
- Examples
- Uses VM pools, Azure SQL read replicas, and Banning Books peak-sale traffic as concrete examples.
- What you can do after
- Operate elastic compute or database capacity by adding instances, routing suitable reads, and removing capacity as demand falls.
Read how Microsoft Azure in Action explains horizontal scaling →
Kubernetes in Action, Second Edition
Scaling out is increasing application capacity by running additional application instances.
- How it is used
- Scales a deployed application when one instance cannot handle increased user load.
- How deep it goes
- Explains replica changes and desired-state reconciliation, then demonstrates resulting Pods and Service traffic.
- Examples
- Uses kubectl scale, Deployment status, Pod listings, and repeated curl requests to show distribution.
- What you can do after
- Apply it via kubectl by setting a Deployment's desired replica count and checking available Pods.
Read how Kubernetes in Action, Second Edition explains horizontal scaling →
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
Horizontal scaling is the technique of increasing capacity by running multiple instances of a component and distributing its workload among them.
- How it is used
- Uses microservices and Kubernetes to increase capacity, relieve bottlenecks, and support higher workloads.
- How deep it goes
- Explains cluster, service, elastic, and database implications with Terraform and Kubernetes examples, but defers advanced autoscaler customization.
- Examples
- Demonstrates six smaller VMs, three gateway replicas, Kubernetes monitoring, and Terraform autoscaling bounds.
- What you can do after
- Operate/configure cluster and service capacity through Terraform node counts, Kubernetes replicas, and autoscaling limits.
Fast Python: High performance techniques for large datasets
- How it is used
- Distributes computation across multiple computers when data volume or computing demands exceed a single machine's capacity.
- How deep it goes
- Defines scaling out and names scheduler deployment options, while deferring the scheduler's underlying execution model.
- Examples
- Uses Mandelbrot image generation and a local distributed-scheduler setup as a practice workload.
- What you can do after
- Apply it via Dask's distributed scheduler to schedule tasks across machines, starting with a local configuration.
Read how Fast Python: High performance techniques for large datasets explains horizontal scaling →
Build AI-Enhanced Web Apps
Horizontal scaling is the addition or removal of application instances to change processing capacity.
- How it is used
- Supports deployment planning by matching application capacity and operational safeguards to expected traffic.
- How deep it goes
- Defines adding instances and places the practice in a tiered checklist without detailing implementation mechanics.
- Examples
- Uses applications below 10,000 requests per day as the concrete simple-scaling scenario.
- What you can do after
- Operate/configure capacity by planning simple instance expansion for increased application load.
Read how Build AI-Enhanced Web Apps explains horizontal scaling →
Grokking Concurrency
A scaling approach that increases performance by distributing load across existing and additional processing resources.
- How it is used
- Improves program and system performance by distributing load across existing and additional processing resources.
- How deep it goes
- Explains the definition, contrasts scaling up, and extends the idea to concurrency and computing clusters without implementation details.
- Examples
- Uses existing and new processing resources, interconnected machines, computing clusters, real-time systems, and high-volume data as examples.
- What you can do after
- Apply the approach by distributing load across existing and new processing resources, including interconnected machines in a computing cluster.
Also covered in
- Enterprise RAGIn early access (MEAP)
- Apache Kafka in Action
- Designing AI SystemsIn early access (MEAP)
- Building Distributed Applications that Work
- Shipping Go: Develop, deliver, discuss, design, and go again
- ActiveMQ in Action
- Learn Concurrent Programming with Go
- Latency
- Google Anthos in Action
- Build and Orchestrator in Go (From Scratch)
- AI Model EvaluationIn early access (MEAP)
What to know first
- scalabilityScalability is the ability of a system or process to accommodate growth in workload, size, or demand while maintaining acceptable operation.
- performancePerformance is a measure of how effectively a person, process, model, or system achieves its objectives, including qualities such as output quality, speed, and resource efficiency.
- cachingCaching is the temporary storage of data or computed results for reuse, reducing the work or delay of retrieving or computing them again.
- costCost is the monetary expenditure or other resource burden incurred to acquire, produce, operate, or perform something.
Related concepts
- vertical scalingalternative to · Vertical scaling increases or decreases a system’s capacity by changing the resources available to an existing machine, node, or instance.
- replicauses · A replica is an independently maintained copy of data, state, or functionality within a system.
- scalabilitykind of · Scalability is the ability of a system or process to accommodate growth in workload, size, or demand while maintaining acceptable operation.
- autoscalingkind of · Autoscaling is the automatic adjustment of computing resources or service capacity in response to workload demand or system conditions.
- load balancinguses · Load balancing is the distribution or adjustment of work across multiple resources to manage demand and reduce overload or imbalance.
- dataset splitimplemented by · A dataset split is the division of a dataset into distinct subsets assigned different purposes, such as training, validation, or evaluation.
Questions about horizontal scaling
What is horizontal scaling?
Horizontal scaling is increasing or decreasing system capacity by adding or removing computing nodes or service instances that share the workload.
Which Manning books explain horizontal scaling?
The Cloud at Your Service: The when, how, and why of enterprise cloud computing, Grokking Software Architecture, Spring Microservices in Action, Amazon Web Services in Action, Third Edition: An in-depth guide to AWS, MongoDB 8.0 in Action, Third Edition, Acing the Frontend Interview, Elasticsearch in Action, Second Edition, Fast by Default and 11 more.
What should I know before learning horizontal scaling?
Manning books that teach horizontal scaling usually introduce scalability, performance, caching and cost first.
What is the difference between horizontal scaling and vertical scaling?
Horizontal scaling is increasing or decreasing system capacity by adding or removing computing nodes or service instances that share the workload. Vertical scaling increases or decreases a system’s capacity by changing the resources available to an existing machine, node, or instance.
What is horizontal scaling a kind of?
Horizontal scaling is a kind of scalability. Scalability is the ability of a system or process to accommodate growth in workload, size, or demand while maintaining acceptable operation.
What is horizontal scaling also called?
Horizontal scaling is also called scaling out, scale out, horizontally scale, horizontally scaling or scale horizontally.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.


















