Application Capacity Planning: Preparing Your App for Growth

A SaaS company expects customer numbers to increase by 40% over the next year.

At first, the infrastructure calculation seems simple: more customers should mean roughly 40% more capacity.

Production data tells a different story.

The company's newest customers are larger than its historical average. They generate more API traffic, upload more files and schedule more reports. At the same time, the database is growing faster than customer count, while a monthly processing job is already putting considerable pressure on storage throughput.

Customer growth may be 40%.

The application's capacity requirement could be very different.

That is the purpose of application capacity planning.

Application capacity planning is the process of forecasting future workload demand, understanding how that demand consumes application resources, and making sure sufficient capacity will be available before performance begins to suffer.

Microsoft's Well-Architected guidance on capacity planning similarly recommends using historical utilization, expected growth, workload patterns and known limits to determine future resource requirements.

For Levelworks, capacity planning primarily supports Scalable App Health. Performant and Observable also matter because growth should not make important workflows progressively slower, and teams need enough production evidence to understand where future constraints are likely to appear.

Capacity planning is different from scaling

Capacity planning and scaling are related, but they answer different questions.

Capacity planning asks:
What demand is coming, what resources will that demand require, and when will we need more capacity?

Scaling asks:
How will we add that capacity?

An application can use autoscaling and still have weak capacity planning.

For example, additional application instances might appear automatically as traffic rises, while the database approaches its connection limit or a third-party API reaches its quota.

Autoscaling reacts to a condition that already exists.

Capacity planning tries to see that condition coming.

Google's Site Reliability Engineering guidance describes capacity planning as combining expected organic growth, planned business-driven increases in demand and information about how infrastructure resources translate into service capacity.

The planning process therefore starts with the business, not with CPU graphs.

Start by forecasting what will actually grow

"More users" is rarely enough information for a useful capacity forecast.

Growth may come from:

  • more active customers;
  • more simultaneous users;
  • more transactions per customer;
  • larger customer datasets;
  • longer data retention;
  • additional uploaded files;
  • new features generating more work;
  • seasonal events or campaigns.

Different growth patterns put pressure on different parts of the application.

Suppose active users increase by 25%, but a new feature causes each user to make twice as many API requests.

Infrastructure demand will not rise by only 25%.

Similarly, an application could have stable user numbers while its database continues expanding rapidly because each account retains several years of history.

A useful capacity forecast therefore identifies the workload driver behind each important resource.

Resource

Possible workload driver

Application compute

Request volume

Database CPU

Query and transaction rate

Database connections

Concurrent requests

Storage

Retained records and files

Network

Payload and media volume

Queue workers

Background jobs generated

Third-party APIs

Calls produced per workflow

This is much more informative than assuming every resource will grow at the same rate as customer count.

Separate normal growth from known business events

Historical trends can help forecast ordinary growth.

They cannot predict every future event.

Google SRE distinguishes between organic growth, which develops naturally through customer adoption and usage, and inorganic growth, such as launches, campaigns and other planned business changes.

A capacity model should account for both.

For example:

Observed trend: Peak traffic has been increasing about 4% per month.

Known event: A large enterprise customer will migrate onto the platform in January.

Campaign: Marketing expects a substantial increase in new registrations during a November promotion.

A forecast based only on the 4% trend would miss two of the most important future demand changes.

Capacity planning therefore needs regular input from product, sales and business teams—not only infrastructure monitoring.

Translate business demand into technical workload

Once expected growth is understood, convert it into something the application actually processes.

Suppose the business forecasts 20,000 concurrent users during a future peak.

Production data shows that each active user currently generates about 0.1 requests per second.

A simplified estimate becomes:

20,000 users × 0.1 requests per second = 2,000 requests per second

That can then be translated further into expected:

  • database requests;
  • background jobs;
  • storage growth;
  • third-party API calls;
  • network traffic.

These calculations do not need to predict the future perfectly.

Their value is that they make assumptions explicit.

If user behaviour changes and the average user starts generating 0.15 requests per second instead of 0.1, the forecast can be updated.

Without this relationship between business activity and technical work, capacity planning becomes little more than guesswork.

Establish what your current resources can actually handle

Knowing future workload is only half the problem.

You also need evidence about current capacity.

That might include statements such as:

Eight application instances sustain 2,500 requests per second while API p95 remains below one second.

Or:

The worker fleet can process approximately 20,000 jobs per minute before queue age begins increasing.

Or:

Database performance remains acceptable until write throughput approaches a particular level.

These numbers should come from production monitoring and representative performance testing rather than assumptions based on infrastructure specifications.

Google's SRE guidance on production services recommends using load testing to determine the real relationship between resources and service capacity because software changes can alter how efficiently those resources are used.

A software release can therefore change capacity even when infrastructure stays exactly the same.

If one release makes an important request 20% more expensive to process, the application effectively has less capacity than it had previously.

[Internal Link: “Load Testing vs Stress Testing: What Does Your App Need?”]

Plan around peaks rather than averages

Average traffic is useful for some cost calculations, but it is dangerous for capacity planning.

Suppose an application averages 600 requests per second during the day but regularly reaches 1,700 during the busiest hour.

Provisioning only for the average would guarantee pressure every day.

Capacity planning should examine recurring peaks such as:

  • business-hour traffic;
  • end-of-month processing;
  • reporting cycles;
  • payroll periods;
  • seasonal demand;
  • scheduled batch activity.

Also look for workload overlap.

A report-generation job that currently runs during a quiet period may become problematic after geographic expansion means there is no longer a truly quiet period.

The important capacity question is not simply how much work exists, but when multiple workloads compete for the same resources.

Maintain enough headroom for uncertainty

An application operating close to 100% of its practical capacity during ordinary peaks has little room for anything unexpected.

A sudden increase in traffic, an inefficient query, a failed application instance or a slower dependency can push it beyond its safe operating range.

Capacity plans therefore need headroom.

There is no universal percentage that every application should reserve because the appropriate margin depends on factors such as:

  • traffic volatility;
  • business criticality;
  • forecast uncertainty;
  • speed of scaling;
  • reliability requirements.

A stateless application tier that can add healthy instances rapidly may tolerate less reserved capacity than a stateful database that takes weeks to resize or redesign.

Google's production guidance also recommends maintaining enough capacity to tolerate expected failures while still serving peak demand acceptably.

The principle is straightforward:

Do not plan normal operation around the absolute maximum the system can handle.

Treat data growth as its own capacity problem

Traffic growth attracts attention because it immediately affects response times.

Data growth is often quieter.

An application can have relatively stable user numbers while databases, indexes, object storage and backups expand every month.

Eventually, that growth affects:

  • query performance;
  • storage capacity;
  • index size;
  • reporting;
  • backup duration;
  • restore duration;
  • batch-processing time.

Suppose customer count is growing 10% annually but transaction history is growing 60%.

A capacity plan based only on users will miss one of the application's most important future constraints.

Track activity growth and stored-state growth separately.

[Internal Link: “How Database Performance Affects the Speed of Your App”]

Track quotas and external limits too

Not every capacity constraint is a server.

Applications operate within:

  • cloud service quotas;
  • database connection limits;
  • API rate limits;
  • network limits;
  • third-party service quotas;
  • contracted usage tiers.

AWS's Well-Architected reliability guidance recommends tracking both adjustable service quotas and fixed constraints because either can become a workload limit.

For each important limit, know:

  • current usage;
  • expected growth;
  • maximum allowed usage;
  • whether the limit can be increased;
  • how long an increase takes.

Third-party services deserve the same treatment.

If checkout depends on payment, fraud and tax APIs, traffic growth may increase requests to all three. Your own infrastructure could have plenty of capacity while one external provider begins throttling requests.

Application capacity extends beyond resources you directly control.

Calculate capacity runway

One of the most useful outputs from capacity planning is time to limit.

Suppose:

  • safe storage threshold: 8 TB;
  • current usage: 5 TB;
  • growth: approximately 250 GB per month.

At the current trend:

3 TB remaining ÷ 250 GB/month ≈ 12 months of runway

That is not a guarantee that the limit will be reached exactly twelve months from now.

It is a planning signal.

If changing the storage architecture requires four months, waiting until month eleven to act would be irresponsible.

Runway can be calculated for:

  • database storage;
  • transaction capacity;
  • API quotas;
  • queue-processing throughput;
  • database connections.

This changes monitoring from:

We are currently at 62% utilization.

to:

At the current growth rate, we are likely to reach our planning threshold in approximately seven months.

The second statement is much easier to act on.

Factor lead time into the decision

Some capacity can be added quickly.

Other capacity changes require substantial engineering or commercial lead time.

For example:

Capacity area

Typical response

App compute

Autoscaling/minutes

Cloud quota

Request/approval

Database redesign

Weeks or months

Data partitioning

Significant engineering

Third-party contract limit

Commercial lead time

Google SRE notes that capacity forecasts need to extend beyond the time required to provision the resources being planned.

That means the important date is not only:

When will we reach the limit?

It is:

When must we make the decision that prevents us from reaching it?

A database expected to hit its practical limit in six months may require action today if the solution takes four months to design, test and deploy.

Use scenarios instead of one perfect forecast

Future demand is uncertain.

Rather than pretending one projection is exact, create several plausible scenarios.

Expected growth

Current trends continue.

High growth

A major customer, campaign or product success increases demand faster than expected.

Lower growth

Adoption slows and additional capacity can be delayed.

Microsoft's capacity-planning guidance recommends balancing the risk of underprovisioning, which can create bottlenecks, against excessive overprovisioning and unnecessary cost.

Scenario planning helps with that balance.

You may not know whether traffic will increase 30% or 50%.

If both scenarios place the database near its practical connection limit, however, the next engineering decision is already reasonably clear.

Autoscaling does not replace capacity planning

Cloud infrastructure can respond automatically to changing demand, but autoscaling still works within limits.

There may be:

  • maximum instance counts;
  • database ceilings;
  • service quotas;
  • budget limits;
  • external API restrictions.

Even predictive scaling relies on historical patterns and forecasts. AWS's predictive scaling uses previous load patterns to forecast future capacity requirements and provision capacity ahead of anticipated demand.

Automation therefore makes some capacity changes easier.

It does not remove the need to understand what the next constraint will be.

[Internal Link: “How to Know if Your Application Is Ready to Scale”]

Revisit the forecast as the application changes

Capacity models expire.

A new feature can increase API calls per session. A successful database optimization may allow the same infrastructure to process more transactions. A new retention policy may accelerate storage growth.

After significant changes, reconsider:

  • workload assumptions;
  • current capacity;
  • resource efficiency;
  • expected growth;
  • next bottleneck.

Also compare previous forecasts against what actually happened.

If peak traffic was forecast at 3,000 requests per second but reached only 2,000, determine why. If it unexpectedly reached 4,500, that difference matters even more.

Capacity planning improves when forecast errors become inputs to the next forecast rather than being forgotten.

A practical capacity-planning view

For each important constraint, maintain enough information to answer:

Question

Example

What drives demand?

Peak checkout transactions

Current demand?

700 transactions/min

Expected growth?

~6% per month

Safe tested capacity?

1,500 transactions/min

What is the next constraint?

Database write throughput

How much headroom remains?

About 53%

Known future event?

November campaign

How long does additional capacity take?

Six weeks

When should action begin?

Before September

The purpose is not to build an elaborate forecasting spreadsheet.

It is to replace vague discussions such as:

We will probably need to scale soon.

with something more operational:

Current growth plus the November campaign is likely to push checkout demand close to the tested database boundary in Q4. The required database work has a six-week lead time, so the decision needs to happen before September.

That is a capacity plan the business and engineering team can actually use.

Capacity planning turns growth into planned engineering work

Applications rarely hit capacity limits because growth itself was impossible to predict.

More often, teams knew usage was increasing but did not translate that growth into resource requirements early enough.

Good capacity planning connects four pieces of information:

What demand is growing?

How does that demand consume application resources?

Which resource reaches its practical limit next?

How early do we need to act?

For Levelworks, this is the practical value of Scalable App Health. Performant ensures capacity is judged against acceptable user experience rather than maximum theoretical throughput, while Observable provides the data needed to make credible forecasts.

Capacity planning will never predict the future perfectly.

It does not need to.

Its job is to prevent predictable growth from becoming an avoidable production emergency.

‍

Continue Reading