VPS Tutorials
What to Do When Your VPS Is Throttled (2026): How to Identify CPU, Disk, and Network Throttling
When a VPS slows down, many people immediately blame undersized specs or overselling by the provider, but the real cause isn't always that resources are genuinely maxed out—it could be the platform, quotas, credits, or the host layer capping you at some limit. This article focuses on the difference between throttling and normal saturation, breaking down the common limiting signals across the CPU, disk, and network layers to help you determine whether the machine is truly insufficient or the instance is already being throttled.

When a VPS slows down, most people's first reaction is the same:
- The CPU isn't enough
- The machine is junk
- The provider is overselling
- Should I upgrade the specs right away?
The problem is that a slow VPS doesn't necessarily mean "resources are genuinely maxed out."
Sometimes what you're seeing isn't normal saturation, but another, harder-to-diagnose situation: throttling (being limited, speed-capped, or stuck at some ceiling).
For example:
- The CPU can spike very high at first, then suddenly drops to a fixed level
- No matter how much pressure you apply in disk tests, IOPS just won't go up
- The network is rated at 1Gbps, but iperf3 always gets stuck at some neat number
- The workload is light, yet latency suddenly worsens, and monitoring shows no obvious CPU saturation
The trickiest part of these problems is:
If you misdiagnose throttling as ordinary performance shortfall, you'll waste a lot of time and money in the wrong direction.
This article is dedicated to clarifying this: how to distinguish "genuinely maxed out" from "throttled by the platform or host layer," and how to look at each of the CPU, disk, and network layers.
Many troubleshooting efforts go off track from the start because these two situations get conflated.
| Situation | What you're actually dealing with |
|---|---|
| Normal Saturation | Your workload genuinely uses up the resources |
| Throttling (rate limiting/restriction) | The platform, quotas, credits, QoS, or host layer caps you at some ceiling |
The most intuitive difference is:
- Normal saturation: resource usage rises with load and approaches the bottleneck linearly
- Throttling: performance suddenly "hits a wall" near some threshold and shows a very neat ceiling
- The harder you push your workload, the more the resource metrics rise in tandem, eventually maxing out → more like normal saturation
- Your workload wants to go higher, but performance is stuck at a fixed value → more like throttling
This is also the core of the whole article:
First prove you're being limited, then decide whether to upgrade, migrate, or complain to the provider.
The following signals are worth suspecting throttling first:
For example:
- The CPU stays stuck at some fixed baseline for a long time
- Disk IOPS always stops at roughly the same ceiling
- Network throughput stays stuck at some fixed tier for a long time
"Neatness" itself is a very strong signal.
This looks a lot like the behavior after credits run out:
- There's burst up front
- Then it's pushed back down to baseline
For example:
- CPU usage doesn't look high
- But response times start to jitter
- Queues get longer
- The system feels noticeably laggy
At this point you can't just stare at %cpu; you need to look at steal, iowait, credits, and throughput ceilings.
Normal jitter won't be this neat every time. Repeatedly hitting the same ceiling usually means the limit is "rule-based."
CPU is the most common layer and the easiest to misjudge.
In virtualized VPS scenarios, steal time is a very key signal.
It means:
- Your virtual CPU wanted to run
- But the host machine gave the time slice to another VM
This usually means host-layer contention, not your program maxing out the CPU itself.
top
vmstat 1
mpstat -P ALL 1
Focus on:
st/%st
%stclose to 0: usually normal%stpersistently and noticeably high: means you're waiting for the host to give up CPU
If your workload isn't heavy but %st stays high, this isn't something "optimizing your code" can fully solve.
Machines like AWS T series and Azure B series aren't "always at full speed" by design; instead they:
- Accumulate credits normally
- Burst when needed
- Return to baseline once credits run out
The most typical misjudgment here is:
"Why was the stress test so strong for the first 10 minutes, then suddenly it couldn't keep up?"
This may not mean the machine is broken—it may mean you used up the burst.
- Performance is normal or even great at the start
- After sustained pressure it drops to a fixed level
- Credits approach 0 in the provider's monitoring
- The workload isn't finished, but the CPU ceiling seems to have been capped
us/syare very high- Throughput rises as load rises
- It's just that real compute power is the final limit
This looks more like "the machine isn't enough," not "the platform is capping you."
The disk layer is the easiest to misunderstand, because many people only look at one number: disk MB/s.
But the actual bottleneck is often not sequential throughput, but:
- IOPS
- Latency
- Queue depth
- Random read/write capability
Common command:
vmstat 1
iostat -x 1
Focus on:
%wa%utilawait
High iowait doesn't necessarily mean throttling.
It only means:
- The CPU is waiting on I/O
As for why it's waiting, it could be:
- The disk is genuinely slow
- The queue is too long
- Storage latency is high
- IOPS is capped by quota
- You keep adding pressure, but IOPS stops growing
- Latency starts rising noticeably
%utilis very high, but throughput won't go up- Multiple fio results hit the same ceiling
fio --name=randwrite-test --ioengine=libaio --direct=1 --rw=randwrite --bs=4k --size=1G --iodepth=64 --numjobs=4 --runtime=120 --time_based --group_reporting
What you need to look at isn't "how much it ran in a single run," but:
- Whether IOPS keeps growing as
iodepthandnumjobsincrease - Whether p95 / p99 latency suddenly degrades
- Whether random read/write is stuck, or sequential throughput is stuck
If you keep adding pressure and the result always gets stuck at a similar threshold, it looks a lot like an I/O quota or storage-layer rate limiting.
The network layer has the most misjudgments.
Many people see "slow speed" and immediately attribute it to circuit detours, packet loss, or peak hours.
These are of course common, but another possibility should also be considered:
- The platform itself imposes limits on ports, instances, monthly traffic, or certain protocols
## 服务端
iperf3 -s
## 客户端
iperf3 -c <server_ip> -R
If you suspect a single stream isn't accurate, you can also test multiple streams.
- A single stream is stuck at a fixed ceiling
- Multiple streams can't break through that ceiling either
- Tests at different times all hit the same tier
- Rated at 1Gbps, but measured results look long-term capped at a lower value
- Bad routing
- Packet loss
- Peak-hour congestion
- The target end is itself slow
- Local ISP issues
So the network layer must be examined in two steps:
- Path quality
- Whether the throughput ceiling is being hit in a rule-based way
If it only fluctuates during peak hours, it's more like congestion; if it's stuck at the same tier at all times, it's more like a limit.
Some are not instance-layer throttling, but business policy limits, such as:
- Rate limiting after exceeding monthly traffic
- Specific ports / specific protocols being capped
- Outbound port 25 blocked by default for email scenarios
This isn't "host machine preemption," but a limit at the provider's policy layer.
If your application genuinely maxes out the CPU, that's resource saturation, not throttling.
Bad links, peak hours, packet loss, and slow target ends can all make you feel "like it's rate-limited."
It could also just be that the host storage is genuinely busy, or your access pattern itself is unfriendly.
Benchmark scores are only a symptom, not a conclusion. You must combine:
- Metrics
- Timeline
- Quota model
- Results reproduced multiple times
and judge them together.
If you suspect your VPS is being throttled right now, you can follow this order:
Look at:
- CPU usage
- load
- Memory
- iowait
- Network throughput
If the workload itself is heavy, don't rush to blame the platform.
Focus on:
- Whether the CPU drops to a fixed baseline
- Whether IOPS hits a wall
- Whether throughput is always stuck at a fixed tier
Focus on:
- steal time
- credits
- The provider's monitoring panel
- CPU: look at behavior after sustained stress testing
- Disk: use fio
- Network: use iperf3
Don't just run once, but:
- Run at different times
- Run at different pressure levels
- See whether it always hits the same ceiling
If you confirm it's throttling, then consider:
- Upgrading the instance specs
- Switching to a non-burstable instance type
- Migrating to another provider/datacenter
- Contacting the provider with evidence to communicate
- Check whether credits are exhausted
- Switch to a non-burstable instance type
- Avoid running long-term high-CPU tasks on shared burstable instances
- Look at the current disk type and IOPS model
- Check whether higher-spec storage is needed
- Avoid putting high-random-write databases on low-spec shared disks
- Check whether the plan description has traffic/bandwidth/port policies
- Distinguish bad links from rule-based rate limiting
- For high-throughput workloads, try to avoid plans that are "cheap but have many network policies"
Keep evidence before filing a ticket.
Don't just say:
- "I feel it's gotten slower"
Instead, bring:
- Time periods
- Monitoring screenshots
- fio / iperf3 / vmstat / iostat output
- Results of multiple retests
This makes it harder for the provider to brush you off with a template reply.
The following workloads are especially vulnerable to limits that "look minor but actually hurt a lot":
- Database services
- Download sites
- Proxy/gateway/relay services
- High-concurrency API services
- CI/CD build nodes
- Video transcoding and batch processing tasks
Because these scenarios are all sensitive to the following metrics:
- Stable throughput
- Tail latency
- Sustained CPU capability
- Random I/O
It's not that they will definitely be throttled, but:
Once throttled, the impact will be very obvious.
Yes. For example, when steal time is high, credits are exhausted, or I/O wait is severe, the experience can be bad, but the CPU usage you see may not be outrageously high.
Look for whether there's a rule-based ceiling. True saturation is more like hitting a wall linearly; throttling is more like being stuck at some neat threshold.
No. Benchmark scores are only a clue, not a conclusion. You need to judge together with steal, credits, iowait, and fio/iperf3 retest results.
First keep evidence and monitoring results, then decide whether to upgrade, switch instance types, migrate, or take the data to communicate with the provider.
The hardest part of VPS throttling isn't "how to solve it," but how to prove that what you're encountering isn't an ordinary performance bottleneck.
This whole article really just wants to help you build a judgment framework:
- CPU layer: look at steal time, look at credits, look at the speed drop after sustained stress testing
- Disk layer: look at iowait, look at whether IOPS hits a wall, look at whether latency rises abnormally
- Network layer: look at whether throughput is rule-based capped, look at whether there are plan or port policy limits
In one sentence:
First distinguish "resources genuinely maxed out" from "the platform capping you," then decide whether to optimize, upgrade, or migrate.
If you now suspect your VPS is being throttled, don't rush to just run a speed test script once. What's truly useful isn't "I feel it's slow," but whether you can produce a set of sufficiently clear evidence proving that it's slow in a very regular way.