liveBook · Manning

Horizontal scaling

Also called scaling out, scale out, horizontally scale, horizontally scaling, scale horizontally

Horizontal scaling is increasing or decreasing system capacity by adding or removing computing nodes or service instances that share the workload.

How 19 Manning books explain it

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.

Read how The Cloud at Your Service: The when, how, and why of enterprise cloud computing explains horizontal scaling →

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.

Read how Amazon Web Services in Action, Third Edition: An in-depth guide to AWS explains horizontal scaling →

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.

Read how Fast by Default explains horizontal scaling →

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.

Read how ScyllaDB in Action explains horizontal scaling →

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.

Read how Refactoring to Rust explains horizontal scaling →

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.

Read how Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform explains horizontal scaling →

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.

Read how Grokking Concurrency explains horizontal scaling →

Also covered in

What to know first

Related concepts

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.