Cloud Server Bottlenecks: CPU, Memory, Disk & Network

Serdar Tekin
Serdar Tekin
Co-Founder & CTO
Updated Nov 17, 202612 min read
Written for: Developers, system administrators, and small infrastructure teams diagnosing slow cloud servers, CPU bottlenecks, memory pressure, disk I/O issues, and network performance problems.
Cloud Server PerformanceCPU BottleneckMemory BottleneckDisk I/ONetwork BottleneckVM Sizing
Last reviewed:
Guide
Cloud Server Bottlenecks: CPU, Memory, Disk & Network
rafftechnologies.com/learn
On this page

Key Takeaways

A server bottleneck is the resource or dependency that controls latency, throughput, or stability. Diagnose impact and wait evidence together rather than reacting to utilization alone. CPU bottlenecks show sustained compute pressure tied to latency or backlog; memory bottlenecks show swap, PSI, OOM, or restart evidence; disk and network bottlenecks require path-level latency, throughput, and queue measurements. Optimize avoidable work first, then resize, separate, or scale only when the measured constraint supports the change.

Resize CPU and RAM when you find the bottleneck.

  1. 1Pick a Linux imageUbuntu, Debian and more, with your SSH key added.
  2. 2Choose a sizeFrom $4.99 a month. Resize when your app grows.
  3. 3Connect over SSHYour server is up in about 55 seconds.

Ubuntu, Debian and other Linux distributions with full root and SSH access, up and running in about 55 seconds.

A cloud server bottleneck is the resource, dependency, or serialized step that limits latency, throughput, or stability by forcing useful work to wait. The bottleneck may be CPU, memory, disk I/O, network, a database, or an external service.

The busiest metric is not automatically the bottleneck. A server can run at high CPU and still meet every latency target, while another can show moderate CPU and feel slow because requests are waiting on memory reclaim, storage, database locks, DNS, or an external API.

The practical diagnostic question is: where is the affected work waiting, and does that wait control an outcome users or operators care about?

Raff Technologies supports 3,000+ customers and 15,000+ VMs. In infrastructure reviews, a recurring mistake is reacting to the highest utilization graph before correlating it with request latency, queue growth, failed jobs, or service restarts.

How to identify a server bottleneck

Use this five-step sequence before resizing a slow cloud server:

  1. Define the symptom. Is the problem slow requests, growing queues, failed jobs, restarts, long builds, or low throughput?
  2. Measure where work waits. Check CPU pressure, memory pressure, disk latency, network latency, database time, and external dependencies.
  3. Correlate pressure with impact. A metric matters when it rises at the same time as the workload problem.
  4. Change one variable where practical. Optimize, resize, separate, or scale based on the identified constraint.
  5. Repeat an equivalent workload. Confirm the original symptom improves and check whether the bottleneck moved downstream.

A useful rule is impact + wait evidence > utilization alone.

SymptomEvidence to inspectLikely bottleneckBetter first decision
p95/p99 latency rises under loadCPU pressure, traces, DB timeCPU, lock, or dependencyFind the dominant wait before resizing
Queue age keeps growingCPU, worker throughput, downstream latencyCompute or downstream capacityAdd useful concurrency or remove downstream limit
Processes restart or disappearAvailable memory, swap, OOM eventsMemoryReduce demand, fix leak, or add RAM
Database slows during writesQuery time, locks, I/O latencyQuery, lock, memory, or diskDiagnose the database path first
Uploads/downloads are slowRTT, packet loss, retransmits, throughputNetwork path or app limitTest the path before adding compute
Deployments destabilize the VMCPU, RAM, I/O during deployMissing headroomResize or change deployment behavior
Workers hurt web latencyCPU, memory, I/O, queue activityRole contentionLimit or separate workers
Performance drops after a releaseTraces, DB queries, errors, version markerApplication regressionRoll back or isolate the change

Linux Pressure Stall Information (PSI) can help because it reports time tasks lose while waiting for CPU, memory, or I/O resources through /proc/pressure/cpu, /proc/pressure/memory, and /proc/pressure/io on supported systems.

CPU bottleneck: look for sustained compute pressure plus impact

A CPU bottleneck exists when useful compute demand exceeds the processing capacity available within the workload's timing requirement.

Typical signals include:

  • sustained CPU pressure during the affected period;
  • runnable work accumulating;
  • p95/p99 latency rising with CPU demand;
  • queue or worker backlog growing while CPU remains busy;
  • builds or tests taking longer under equivalent work;
  • one thread saturating while machine-wide CPU looks moderate.

Short CPU spikes are not enough. A deployment, cache warm-up, package update, or brief traffic burst can consume all available CPU without creating a persistent server performance problem.

Add vCPU when the workload can use more parallel compute and the result improves. Optimize code when profiling reveals avoidable CPU work. Evaluate dedicated compute when sustained CPU timing consistency matters more than additional shared-vCPU count.

For that narrower choice, see 2 vCPU vs 4 vCPU Cloud VMs and Shared CPU vs Dedicated CPU.

Memory bottleneck: look for pressure, swap, OOM, and restarts

A memory bottleneck appears when the workload's active working set no longer fits safely in RAM.

Linux uses otherwise idle memory for useful cache, so raw “used RAM” percentage is not enough. Stronger evidence includes:

  • low available memory during normal peaks;
  • repeated swap-in and swap-out activity;
  • memory PSI or reclaim stalls;
  • out-of-memory events;
  • container or process restarts;
  • process memory that keeps growing after load falls;
  • database or cache behavior degrading as memory pressure rises.

Separate three patterns:

PatternMeaningBetter response
Stable working set is too largeLegitimate capacity demandAdd RAM
Memory grows without stabilizingLeak or unbounded behaviorFix application/configuration
Several services compete for RAMRole contentionAdd memory or separate services

Sustained swap can turn a memory shortage into a disk I/O problem. More CPU does not solve that chain.

Use High Memory VMs (HiMem) when the workload needs more RAM per vCPU. For workload-based memory starting points before resizing, read How Much RAM Do I Need for a VPS?.

Disk bottleneck: separate capacity from I/O performance

A disk bottleneck can exist even when a filesystem still has free space. Disk capacity and disk performance are separate constraints.

Inspect storage across four dimensions:

DimensionEvidence
CapacityFree space, inode use, growth rate, retention
LatencyRead/write completion time
ThroughputBytes transferred per second
QueueingOutstanding operations and wait time

Databases, write-heavy logs, backups, analytics, file processing, and multiple services sharing one VM can all create disk I/O contention.

High I/O wait is supporting evidence, not a complete diagnosis. Correlate it with device latency, queueing, database time, or job duration. When I/O is implicated, tools such as iostat, vmstat, database metrics, and application traces can help locate the responsible path.

Common responses include:

  • fix inefficient queries or indexes;
  • reduce unnecessary logging and temporary writes;
  • move uploads or archives away from the application disk;
  • change backup timing;
  • separate application and database storage paths;
  • expand storage when capacity is genuinely the constraint.

Raff Volumes provide a separate storage boundary at $0.08/GB-month when persistent data should not depend only on a VM's local disk. See Raff Volumes.

Network bottleneck: bandwidth is only one part of the path

A network bottleneck can come from bandwidth, latency, loss, retransmissions, DNS, TLS setup, a proxy, geography, or an external service.

Inspect:

  • round-trip time;
  • packet loss and retransmissions;
  • achieved throughput;
  • DNS lookup time;
  • TLS and connection-establishment time;
  • proxy or load-balancer timing;
  • external API duration;
  • application upload/download limits.

Test each relevant path separately: user-to-application, application-to-database, service-to-service, and application-to-external-provider. This distinguishes a slow server from a slow route or remote dependency.

Raff Cloud Servers use unmetered VM traffic with no normal VM egress fee, but public port speeds are class-specific: Cost-Optimized is 1 Gbps with local NVMe, while General Purpose, CPU-Optimized and Windows are 3 Gbps. That removes a transfer-metering concern for VM traffic, but it does not guarantee every remote route or third-party dependency will be fast. Network diagnosis still requires measured path behavior.

Private networking through Raff VPC is free and can keep internal service traffic off the public path when the architecture requires it.

Database and application bottlenecks can look like infrastructure problems

A larger VM cannot repair every slow application.

Application or database patternVisible server symptom
Missing database indexHigh query time and storage activity
Lock contentionSlow requests with moderate VM utilization
Synchronous external APILow CPU with long request latency
Unbounded worker concurrencyCPU, RAM, and I/O contention together
Excessive retriesNetwork and downstream amplification
Excessive loggingStorage growth and write latency
Cache miss stormDatabase and network pressure
Memory leakRising RAM usage and eventual OOM
Serial processing pathOne busy thread with idle vCPUs

Review database query duration, lock time, connection behavior, cache effectiveness, checkpoint/write activity, and backup traffic beside host metrics.

Adding application servers can make a database bottleneck worse by increasing concurrency against the same constrained data layer. Moving from 2 vCPU to 4 vCPU can expose a downstream bottleneck without reducing total request latency.

Use Application Observability for Small Teams when metrics, logs, and traces need to be connected across one user request or background job.

Optimize, resize, separate, or scale based on the bottleneck

Once the constraint is identified, choose the smallest change that directly addresses it.

EvidenceBetter moveWhy
Inefficient code/query dominatesOptimizeCapacity would hide avoidable work
One VM resource is consistently constrainedResize verticallyOne server still fits the operating model
App and database compete repeatedlySeparate rolesIndependent resource and recovery boundaries help
Workers harm user-facing trafficLimit or separate workersProtect request-path capacity
Stateless app tier reaches repeatable capacityScale horizontallyTraffic can be distributed across nodes
Short bursts exceed headroomBuffer, rate-limit, resize, or scaleBurst handling is the real requirement
External dependency dominatesCache, queue, or redesignLocal compute does not remove remote wait
No clear correlation existsImprove observabilityArchitecture changes would be guesswork

Vertical resizing is usually the lowest-complexity move when one VM still provides the correct deployment and recovery boundary. Separation becomes useful when roles need different scaling, deployment, security, or recovery behavior. Horizontal scaling becomes useful when the application can distribute traffic and the data layer can support additional concurrency.

Use Horizontal vs Vertical Scaling after diagnosis shows capacity is the actual problem. For an already-running VM, use Right-Sizing Cloud Servers to validate whether reducing waste or changing resource size actually improves the measured workload.

Raff VM options for CPU, memory, and storage constraints

Current September 2026 Raff VM reference points include:

Resource decisionExample Raff optionMonthly price
Low-cost balanced/shared CPUGeneral Purpose 1 vCPU / 1 GB / 25 GB$4.99
Balanced applicationGeneral Purpose 2 vCPU / 4 GB / 80 GB$17.99
Memory-forward workloadGeneral Purpose 2 vCPU / 8 GB / 160 GB$27.99
Dedicated computeCPU-Optimized 2 vCPU / 4 GB / 80 GB$36.99
Independent persistent storageVolume$0.08/GB-month

General Purpose uses shared vCPU. CPU-Optimized uses dedicated compute. Check the live pricing page for current billing terms.

The pricing table should be used only after diagnosis. Buying dedicated CPU for a memory leak or adding RAM for a disk bottleneck increases cost without addressing the root cause.

For current plan details, use Raff Cloud Servers, Raff General Purpose VM Plans, and the live pricing page.

Choose a VM profile based on the resource your workload actually needs.

Validate the fix against the original performance issue

Performance work becomes unreliable when several variables change at once.

For a controlled change:

  1. record the affected workload and healthy baseline;
  2. select one bottleneck hypothesis;
  3. change one variable where practical;
  4. repeat an equivalent workload;
  5. compare latency, throughput, errors, queueing, and resource pressure;
  6. check whether the bottleneck moved downstream.

A successful change improves the workload outcome. A prettier utilization graph by itself is not success.

The bottleneck is the constraint that controls the workload outcome

Cloud server performance diagnosis is most reliable when it begins with a real symptom and follows the wait path to its cause.

A CPU bottleneck points toward more compute only when runnable work is delayed. A memory bottleneck points toward more RAM when the working set cannot remain resident safely. Disk and network bottlenecks require path-level latency, throughput, and queue evidence. Database and application dependencies must be checked before infrastructure is blamed.

The final decision should be proportionate: optimize unnecessary work, resize a constrained VM, separate roles that should no longer compete, or scale a stateless service when one node has reached a repeatable capacity limit.

Return to How to Choose the Right VM Size for Your Workload for initial sizing, or continue with Cloud VM Types & Machine Classes when the constrained resource points toward a different VM profile.

Sources

Was this article helpful?
Serdar Tekin
Serdar Tekin
Co-Founder & CTO

Co-Founder & CTO at Raff, focused on cloud infrastructure, systems architecture, security, reliability, and production operations.

Resize CPU and RAM when you find the bottleneck.

Ubuntu, Debian and other Linux distributions with full root and SSH access, up and running in about 55 seconds.

14-day money-back guarantee

Frequently asked questions

What is a server bottleneck?
A server bottleneck is the resource, dependency, or serialized step that limits latency, throughput, or stability by forcing useful work to wait.
How do I identify a cloud server bottleneck?
Start with the workload symptom, measure CPU, memory, disk, network, database, and dependency waits, and look for pressure that rises at the same time as latency, queue growth, errors, or restarts.
How can I tell whether CPU is the bottleneck?
CPU is likely the bottleneck when sustained CPU pressure or runnable work repeatedly aligns with higher p95/p99 latency, queue growth, lower throughput, or longer job duration.
What indicates a memory bottleneck?
Look for low available memory, sustained swap activity, memory pressure, OOM events, process or container restarts, and workload slowdown that aligns with those signals.
How do I identify a disk bottleneck?
Correlate storage latency, throughput, queueing, database time, and application delays. Free disk space or I/O wait alone does not prove a disk bottleneck.
How do I identify a network bottleneck?
Measure round-trip time, packet loss, retransmissions, throughput, DNS and TLS timing, proxy timing, and external dependency latency across each relevant network path.
Can a server be slow when CPU usage is low?
Yes. Memory reclaim, storage waits, database locks, DNS, network latency, serial code, or external APIs can make a server slow while CPU remains moderate.
When should I resize instead of optimize?
Resize when a necessary workload consistently exhausts a VM resource. Optimize first when inefficient code, queries, retries, logging, leaks, or other avoidable work creates the pressure.