“VPS” stopped describing a single product around 2015. Today the label covers container slices on a shared kernel, KVM guests with dedicated vCPU reservations, and hourly cloud instances with block storage bolted on. The specs look identical on a pricing table — 2 vCPU, 4 GB RAM, 80 GB disk — and behave nothing alike under load. This is a guide to the four architectures you will actually encounter, and the measurements that tell them apart.
The four architectures in one table
| Property | Shared hosting | Container VPS (LXC/OpenVZ) | KVM VPS | Cloud instance | Bare metal |
|---|---|---|---|---|---|
| Kernel | Shared, no access | Shared with host | Own kernel | Own kernel | Own kernel |
| Isolation | Process-level, weak | Namespaces + cgroups | Hardware virtualization | Hardware virtualization | None needed |
| Root access | No | Yes, container-only | Yes | Yes | Yes |
| Custom kernel / modules | No | No | Yes | Yes (some) | Yes |
| Nested virtualization | No | Rarely | Usually | Sometimes | Yes |
| Typical monthly cost | $3–$15 | $3–$15 | $5–$50 | $10–$200+ | $60–$500+ |
| Noisy-neighbour exposure | High | Medium | Medium | Medium | None |
| Setup effort | None | Low | Medium | Medium–high | High |
The rows that matter most in day-to-day operations are kernel and nested virtualization. Everything else can be tuned around. Those two cannot.
Shared hosting: process isolation only
On shared hosting you get a directory, a database, and whatever the control panel exposes. Open file descriptors, inodes, and PHP workers are all host-wide budgets that other tenants consume. The classic failure signature is an EMFILE or a 508 Resource Limit Reached at exactly the time of day another tenant runs a scraper. You cannot see the cause, because you cannot see /proc beyond your own processes.
Shared hosting is a rational choice for a brochure site with under a few thousand visits a month. It stops being rational the moment you need a single tuned php.ini directive, a Redis socket, or a cron job that runs longer than the panel’s timeout. The upgrade trigger is not traffic; it is the first configuration change you are refused.
Container VPS: cheap, fast, with limits you must verify
An LXC container shares the host kernel and gets its resources from cgroups. There is no emulated hardware, so I/O overhead is minimal and a small plan can deliver surprisingly good disk latency. Boot is near-instant. The catches are structural: you cannot load kernel modules, you cannot change the I/O scheduler (/sys/block/*/queue/scheduler is host-owned), and dmesg is usually restricted.
Containers also report host CPU model and, in some configurations, host memory totals, which makes spec verification harder. Check these three things on any container plan:
cat /sys/fs/cgroup/memory.max # your real memory ceiling
cat /sys/fs/cgroup/cpu.max # quota per period
nproc # vs. advertised vCPU count
grep -c processor /proc/cpuinfo
If memory.max says max, your memory is unbounded and the provider is relying on fair use. That is not automatically bad, but it means a neighbour cannot be contained either, and it is worth asking about before you put a database on it.
KVM VPS: the reference point
A KVM guest has its own kernel and sees paravirtualized devices. You can enable BBR, load wireguard, run Docker, tune sysctl, and nest another hypervisor if the host exposes vmx/svm. This is the architecture most people mean when they say VPS, and it is the one where performance tuning advice from the broader Linux world applies without caveats.
The cost is a thin virtualization layer: roughly 2–5% on CPU-bound workloads, plus traps on emulated devices. Verify the device type once and stop worrying about it:
lspci | grep -Ei 'virtio|ethernet|scsi'
lsblk -o NAME,ROTA,SCHED
systemd-detect-virt # kvm, lxc, or none
systemd-detect-virt returning none on a plan advertised as a VPS is a notable finding: it usually means containers, and the rest of your assumptions about kernel control are wrong.
Cloud instances: VPS with a control plane
Cloud instances are KVM guests with two additions: a network-attached block storage layer and an API that creates and destroys them. The API is genuinely useful — snapshot, resize, and rebuild in seconds. The block storage layer is the performance variable. Local NVMe on a cloud instance is fast; network-attached volumes add 0.2–2 ms of latency per operation and have their own IOPS credits that throttle independently of the instance size.
Measure the delta before you commit an I/O-heavy workload:
fio --name=lat --rw=randwrite --bs=4k --iodepth=1 \
--size=512M --runtime=20 --time_based --direct=1 \
--ioengine=libaio --group_reporting
Compare clat mean on local disk versus the attached volume. A jump from 0.15 ms to 0.9 ms is normal for network storage and will double your fsync-bound transaction rate gap. Budget for egress charges too — they are the line item that makes cloud instances expensive at steady-state traffic, and the reason predictable workloads usually migrate to fixed-price VPS plans such as the ones detailed on virtualserversvps.com.
Bare metal: when the abstraction costs too much
Dedicated hardware removes the hypervisor and the neighbour, but it also removes elasticity and snapshots. The threshold where bare metal beats a large VPS is usually not CPU count but consistency: workloads that need p99 latency under a millisecond, sustained high IOPS, or hardware features like GPUs and SR-IOV. Below roughly 16 vCPU, the price per core of a good KVM VPS is usually lower than bare metal with equivalent availability.
Choosing by workload, not by spec sheet
| Workload | Architecture that fits | Reason |
|---|---|---|
| Brochure site, <5k visits/mo | Shared hosting | Zero operational cost dominates |
| WordPress with Redis and tuned PHP-FPM | KVM VPS, 2 vCPU / 4 GB | Needs kernel control and predictable RAM |
| Small API in Docker | Container VPS | Low overhead, fast deploy |
| PostgreSQL, fsync-bound | KVM VPS with local NVMe | Network storage latency kills commit rate |
| Bursty CI runners | Cloud instance | Create and destroy on demand |
| GPU inference | Bare metal | Passthrough and sustained power |
The practical screening procedure is three commands and fifteen minutes: systemd-detect-virt for the architecture, vmstat 1 for steal, and a fixed-queue-depth fio run for I/O tail latency. Those three results will tell you more about a plan than any provider comparison table, and they are the numbers you will need later when you are deciding whether to tune or to migrate.




Leave a Reply
You must be logged in to post a comment.