NVMe storage has become the baseline expectation for modern web hosting, but understanding exactly what performance gains you'll see—and how to verify them—separates marketing from measurable improvement. This checklist walks you through every factor that matters when evaluating NVMe hosting benefits, with concrete verification steps you can run yourself.
Understanding NVMe Architecture
Before diving into benchmarks, verify your hosting provider actually delivers NVMe rather than SATA SSDs rebranded as "high-performance storage."
Check Your Storage Interface
SSH into your server and run:
lsblk -d -o name,rota,disc-gran
NVMe devices typically appear as /dev/nvme0n1 rather than /dev/sda. Confirm the interface:
lspci | grep -i nvme
You should see output referencing "Non-Volatile memory controller" with a specific PCIe bus address. No output means you're not on NVMe hardware.
Verify PCIe Generation
NVMe runs over PCIe, and generation matters. Check your interface speed:
sudo lspci -vv | grep -A 10 'Non-Volatile'
Look for "LnkCap" and "LnkSta" lines showing PCIe Gen3 x4 or Gen4 x4. Gen3 x4 provides approximately 3.9 GB/s theoretical bandwidth; Gen4 x4 doubles that. Anything less than Gen3 x4 indicates a bottleneck or older hardware.
IOPS Performance Checklist
Input/Output Operations Per Second (IOPS) is where NVMe truly separates from SATA SSDs. Enterprise SATA SSDs deliver roughly 10,000-90,000 IOPS; NVMe can exceed several hundred thousand.
Random Read IOPS Test
Install fio if not present:
sudo apt-get install fio # Debian/Ubuntu
sudo yum install fio # CentOS/RHEL
Run a 4KB random read test:
fio --name=random-read --ioengine=libaio --iodepth=32 --rw=randread \
--bs=4k --direct=1 --size=1G --numjobs=4 --runtime=60 --group_reporting
Record the IOPS value. Quality NVMe hosting should show 100,000+ IOPS for random reads. Below 50,000 suggests shared storage, throttling, or SATA SSDs misrepresented as NVMe.
Random Write IOPS Test
Writes are typically slower but more critical for databases:
fio --name=random-write --ioengine=libaio --iodepth=32 --rw=randwrite \
--bs=4k --direct=1 --size=1G --numjobs=4 --runtime=60 --group_reporting
Expect 50,000+ IOPS on quality NVMe. Check if write performance degrades significantly after the test—some providers use small SLC caches that perform well initially but collapse under sustained load.
Mixed Workload Test
Real applications mix reads and writes:
fio --name=mixed-rw --ioengine=libaio --iodepth=32 --rw=randrw \
--rwmixread=70 --bs=4k --direct=1 --size=1G --numjobs=4 --runtime=60 --group_reporting
This simulates a 70/30 read/write ratio typical of web applications. Compare results against the provider's advertised specs.
Latency Verification
Low latency is NVMe's killer feature for database-heavy workloads. SATA SSDs operate in milliseconds; NVMe measures in microseconds.
Measure Average Latency
Run a latency-focused benchmark:
fio --name=latency-test --ioengine=libaio --iodepth=1 --rw=randread \
--bs=4k --direct=1 --size=512M --runtime=30 --time_based --group_reporting
With iodepth=1, this isolates pure latency. NVMe should show sub-100 microsecond average latency. SATA SSDs typically range from 100-500 microseconds.
Check Latency Consistency
Low average latency means nothing if 99th percentile spikes:
fio --name=latency-test --ioengine=libaio --iodepth=1 --rw=randread \
--bs=4k --direct=1 --size=512M --runtime=60 --time_based \
--group_reporting --lat_percentiles=1
Review the clat percentiles section in the output. The 99th percentile should remain under 500 microseconds. Values exceeding 1-2 milliseconds indicate contention or noisy neighbor issues on shared infrastructure.
Sequential Performance for Backups
While IOPS matter for application performance, sequential throughput affects backup speeds, log processing, and large file operations.
Sequential Read Test
fio --name=seq-read --ioengine=libaio --iodepth=32 --rw=read \
--bs=128k --direct=1 --size=2G --numjobs=1 --runtime=60 --group_reporting
PCIe Gen3 x4 NVMe should exceed 2 GB/s. Gen4 can push 5 GB/s or higher. Results under 500 MB/s suggest SATA interface or severe throttling.
Sequential Write Test
fio --name=seq-write --ioengine=libaio --iodepth=32 --rw=write \
--bs=128k --direct=1 --size=2G --numjobs=1 --runtime=60 --group_reporting
Write speeds often lag reads but should still exceed 1 GB/s on quality NVMe. Test multiple times—some providers use write caches that perform well on the first test but throttle on subsequent runs.
Database Performance Checklist
Databases are where NVMe's low latency delivers the most visible gains.
MySQL/MariaDB InnoDB Write Performance
Check your current InnoDB flush method:
mysql -e "SHOW VARIABLES LIKE 'innodb_flush_method';"
On NVMe, O_DIRECT typically performs best. Test by running sysbench OLTP benchmarks:
sysbench oltp_read_write --mysql-host=localhost --mysql-user=root \
--mysql-password=yourpass --tables=10 --table-size=100000 prepare
sysbench oltp_read_write --mysql-host=localhost --mysql-user=root \
--mysql-password=yourpass --tables=10 --table-size=100000 \
--threads=16 --time=60 run
Record transactions per second. Compare against SATA baseline if available—NVMe typically delivers 2-4x improvement for write-heavy workloads.
PostgreSQL Transaction Latency
For PostgreSQL, test with pgbench:
pgbench -i -s 100 testdb
pgbench -c 10 -j 2 -T 60 testdb
NVMe should show sub-millisecond average transaction latency under moderate load. Check the latency average and latency stddev values—high standard deviation indicates inconsistent performance.
Redis Persistence Impact
Redis AOF (Append-Only File) persistence hammers storage with write operations. Enable AOF and run:
redis-benchmark -t set -n 1000000 -q
NVMe reduces the performance penalty of appendfsync always from crippling to manageable. Compare throughput with AOF enabled versus disabled—the gap should be narrower on NVMe than SATA.
Application-Level Speed Gains
Benchmarks prove hardware capability, but application metrics prove real-world value.
WordPress Admin Response Time
For WordPress sites, the admin dashboard is extremely I/O intensive. Measure with:
curl -o /dev/null -s -w 'Total: %{time_total}s\n' \
http://yoursite.com/wp-admin/
Time this before and after migration to NVMe. Typical gains range from 20-50% reduction in response time for cache-cold requests. Smaller improvements suggest database or PHP-FPM bottlenecks, not storage.
PHP-FPM Opcode Cache Effectiveness
Check if opcache is leveraging NVMe speed:
php -r "print_r(opcache_get_status());"
Look at opcache_statistics → misses and hits. NVMe won't help opcache hits (served from RAM), but reduces the penalty of misses when PHP must read files from disk. Lower cache sizes become viable on NVMe because refill time decreases.
Static Asset Delivery
Test image and CSS delivery speed:
ab -n 1000 -c 10 http://yoursite.com/path/to/image.jpg
NVMe helps when the web server must read from disk for each request (cache-cold scenarios). If you're already serving from RAM cache or CDN, storage speed becomes irrelevant for static assets.
Cost-Benefit Analysis
Speed alone doesn't justify migration if the cost delta eliminates savings elsewhere.
Calculate True Hosting Cost
NVMe hosting typically costs 20-40% more than SATA SSD hosting for equivalent resources. Calculate monthly cost difference, then estimate:
- Developer time saved from faster deployments and testing
- Server consolidation potential from higher per-server capacity
- Reduced bounce rate from faster page loads (use Google Analytics)
Identify Your Bottleneck
Storage speed only matters if storage is your bottleneck. Run:
iotop -aoP
If your processes spend less than 10% of time in I/O wait, storage upgrades won't help much. Check CPU and RAM utilization first:
vmstat 1 10
If wa (I/O wait) averages under 5%, focus optimization elsewhere before paying for NVMe.
Migration Verification Checklist
After moving to NVMe hosting, verify you're getting what you paid for.
Pre-Migration Baseline
Before migration, record:
fiorandom read/write IOPS- Average database query time from slow query log
- Median page load time from New Relic, Datadog, or similar
- Server backup completion time
Post-Migration Comparison
One week after migration, re-run all baseline tests. You should see:
- IOPS: 3-10x improvement over SATA SSDs
- Database queries: 20-40% latency reduction for random I/O patterns
- Page loads: 15-30% improvement for dynamic content
- Backups: 2-3x faster completion
Smaller gains suggest the provider oversold resources or your application isn't storage-bound.
Monitor Long-Term Performance
Set up continuous monitoring with iostat:
iostat -x 5 > /var/log/iostat.log &
Watch for %util approaching 100% or await times creeping up—signs of storage contention or throttling. Quality NVMe hosting maintains consistent performance under load.
Common NVMe Marketing Traps
Be skeptical of these claims without verification:
"Up to" Performance Claims
Providers often advertise peak burst performance. Run your fio tests for 5+ minutes to measure sustained performance, not brief bursts from SLC caches.
Shared NVMe Storage
Some VPS providers pool NVMe drives across many VMs. Check for dedicated vs. shared:
df -h
If your storage mount shows as network filesystem (NFS, Ceph, GlusterFS), you're on shared network storage that may happen to use NVMe on the backend—but network latency erases most NVMe benefits.
RAID Configuration Impact
RAID rebuilds can temporarily crush I/O performance. Ask your provider:
- What RAID level protects your data?
- How is rebuild traffic isolated from customer I/O?
- What happens to performance during drive replacement?
RAID 5/6 on NVMe often performs worse than RAID 10 on SATA SSDs due to parity calculation overhead.
Conclusion
NVMe hosting delivers measurable performance gains for I/O-bound workloads: databases see lower transaction latency, dynamic content generates faster, and backup operations complete quicker. But speed improvements only matter if storage is your actual bottleneck—and only if your provider delivers true NVMe performance rather than marketing repackaged SATA SSDs.
Work through this checklist before migration to establish baselines, verify provider claims with hands-on benchmarks, and measure real application-level improvements post-migration. The speed matters when it solves your specific bottleneck; the checklist ensures you're buying performance, not promises.