The $5–$15 monthly band is where most small sites and single-service deployments actually live, and it is also the band with the least honest spec sheets. Two plans at $10 can differ by a factor of three in usable memory once the OS and buffer pool are accounted for, and a plan that looks generous on paper can be capacity-starved by noon. This article works through what each price point delivers in measurable terms, what the limits look like under real load, and how to benchmark a candidate plan in under an hour before you commit a year of billing to it.
Spec Sheets vs Deliverable Capacity
Start by subtracting overhead. A stock Debian 12 install uses 90–140 MB RAM idle; add systemd-journald under load, nginx, PHP-FPM and MySQL and the baseline is 450–700 MB before your application runs a single query. On NVMe plans, expect 4–8 GB of the advertised disk to be consumed by the OS, swap file and logs.
| Plan price | Advertised | Usable after OS | Practical ceiling |
|---|---|---|---|
| $5 | 2 vCPU / 2 GB / 40 GB | ~1.35 GB RAM, 32 GB disk | One small WP site, ~20 concurrent |
| $8 | 2 vCPU / 4 GB / 60 GB | ~3.3 GB RAM, 51 GB disk | Two WP sites or one app + DB, ~60 concurrent |
| $10 | 4 vCPU / 4 GB / 80 GB | ~3.3 GB RAM, 71 GB disk | Same as $8 but better burst; CPU headroom for builds |
| $12 | 2 vCPU / 6 GB / 100 GB | ~5.2 GB RAM, 90 GB disk | WooCommerce with a small catalogue, ~100 concurrent |
| $15 | 4 vCPU / 8 GB / 160 GB | ~7.1 GB RAM, 150 GB disk | Docker stack, staging + prod, ~200 concurrent |
The jump from $5 to $8 buys memory, which is the only resource that cannot be worked around. The jump from $10 to $12 buys the same kind of headroom in a different direction. The jump from $8 to $10, in contrast, mostly buys burst CPU — useful for compile-heavy work and spiky traffic, useless for a steady-state blog.
Where Memory Goes First
On a LEMP stack the memory split at rest on a 4 GB plan typically looks like this: OS and systemd 180 MB, nginx 40 MB, PHP-FPM (4 workers at 60 MB) 240 MB, MySQL buffer pool 512 MB plus 200 MB overhead, Redis 100 MB, leaving roughly 2.7 GB unused. That slack is deliberate — it absorbs traffic spikes and keeps the page cache warm. On a 2 GB plan the same stack leaves only ~700 MB, and a single PHP process handling an image resize can push you into swap.
Two configuration decisions determine whether your plan feels generous or cramped: PHP-FPM pm.max_children and MySQL innodb_buffer_pool_size. Set max_children so that (children × average RSS) stays under 60% of RAM, and set the buffer pool to fit your actual working set — for a site with 200 MB of hot tables, 512 MB is plenty and 2 GB is a waste of memory you could give to PHP.
# measure actual per-worker RSS before tuning
ps -o rss= -C php-fpm8.2 | awk '{s+=$1; n++} END {print "avg MB:", s/n/1024, "workers:", n}'
# buffer pool hit ratio — 0 if sizing is right
mysql -e "SHOW ENGINE INNODB STATUS\G" | grep -A1 "Buffer pool hit rate"
Real Throughput at Each Price Point
Numbers matter more than adjectives. Below are typical results from a cached WordPress site (nginx fastcgi cache enabled, 90% hit rate) served by a stock LEMP stack, measured with wrk from an external node on the same continent. These are medians across several budget hosts, not a single vendor’s marketing figure.
| Plan | Cache hit (req/s) | Uncached PHP (req/s) | p95 latency cached | TLS handshakes/s |
|---|---|---|---|---|
| 2 vCPU / 2 GB | 1,800–2,600 | 55–90 | 12–20 ms | ~400 |
| 2 vCPU / 4 GB | 2,400–3,200 | 90–130 | 9–15 ms | ~550 |
| 4 vCPU / 8 GB | 3,500–5,000 | 160–240 | 6–11 ms | ~900 |
The lesson: cached throughput scales almost linearly with core count, uncached throughput scales with memory and query efficiency, and TLS handshakes scale with CPU. A $5 plan serving 2,000 cached requests a second is fine for most small sites; the same plan serving 70 uncached requests a second will fall over during a traffic spike. Caching is not optional on this band — it is the difference between a plan that works and one that does not.
The CPU Steal Question
Budget plans in the $5–$15 range are oversubscribed by design. The question is not whether your vCPU is shared but how fairly it is shared. A well-run host keeps steal below 2% on average and below 10% at peak; a badly run host shows 15–25% sustained, which feels like a machine running at 75% speed with no explanation.
# sustained steal check during your busiest hour — run for 5 minutes
vmstat 5 60 | awk 'NR>2 {print $15}' | sort -n | awk '{a[NR]=$1} END {print "median steal:", a[int(NR/2)]"%", "max:", a[NR]"%"}'
# compare against a load test you control
sysbench cpu --threads=2 --time=30 run | grep "events per second"
If a host shows high steal only during your own load test, the neighbours are not the problem — your plan is simply too small for the workload, and upgrading within the same host is the correct move. If steal is high when the box is idle, you are packed onto an oversold node and should ask support for a migration before deciding to leave.
Storage Type and What It Changes
At this price band you will see three storage tiers: SATA SSD, consumer NVMe, and enterprise NVMe. The difference is not capacity but write endurance and latency consistency. Consumer NVMe in a shared host often delivers excellent burst IOPS (5,000+) but drops to 200–400 IOPS under sustained write load once the SLC cache fills — a 10 GB database import can take three times longer than expected.
Test sustained write, not burst:
# sustained sequential write for 60s — reveals SLC cache exhaustion
fio --name=w --rw=write --bs=1M --size=4G --runtime=60 --time_based --direct=1 --group_reporting
# look for write latency cliff in the 99th percentile
Bandwidth and Transfer Allowances
Plans in this band usually include 1–4 TB of transfer, which is far more than a typical site uses. A cached WordPress site serving 100,000 page views a month at 400 KB per page uses about 40 GB — nowhere near the cap. Where the allowance bites is media delivery: hosting 50 GB of video or images and serving them directly will burn through 2 TB in a few weeks. That is a CDN problem, not a plan problem, and adding a free-tier CDN usually costs less than upgrading to a plan with more transfer.
A 45-Minute Evaluation Protocol
When trialling a candidate plan, run this sequence in order. Each step rules out a class of failure.
- Reboot test (2 min) — reboot, confirm it comes back, check
chronyc trackingfor sane time. A host that loses time will break TLS and cron. - Disk reality (10 min) —
df -handdf -iagainst the advertised figures; then the 60-second fio write test for sustained throughput. - Network path (10 min) —
mtr -rwc 100to two or three destinations you actually serve; watch for loss above 1% on any hop. - Install your real stack (15 min) — not a synthetic benchmark. Deploy the same nginx/PHP/MySQL config you would use in production and load the actual site.
- Load test (8 min) —
wrk -t4 -c50 -d60sagainst a cached page and an uncached page separately; note p95 latency and any 5xx.
Compare candidates on the numbers from step 5, not on the spec sheet. Our price-banded VPS comparison groups plans by these bands so you can shortlist three candidates before running the protocol.
Choosing Between the Bands
The decision rule that holds up: buy the cheapest plan whose usable memory covers your peak stack footprint plus 30%, then spend the savings on caching and a CDN rather than on more vCPU. In practice that means $5–$8 for a single small site, $10–$12 for anything with a database under real concurrency, and $15 once you need multiple services or a staging copy. Plans above $15 are outside this band and follow different rules — at that point you are buying dedicated resources rather than budget oversubscription.
What to Re-Check at Month Three
Budget hosts change nodes, and a plan that performed well in week one can degrade as a host fills a physical box. Keep a monthly record of three numbers: median steal, sustained 4K IOPS and p95 response time from an external monitor. If any of them move by more than 30% from your baseline, you have a migration conversation to have — either with support or with a new provider. The record also makes a refund or credit claim straightforward, which matters more on cheap plans than expensive ones.




