The reliable way to monitor a VPS is to combine host metrics with service checks: watch CPU and load, memory and swap, filesystem space and inodes, disk I/O, network traffic and errors, uptime, and the health of the applications users actually reach. For one managed server, provider-native monitoring is usually the fastest option. For several hosts, longer retention, or custom queries, use Prometheus with Node Exporter and Grafana, protected behind a private network or access controls.
Need a server to try this on? Antihost offers Linux VPS plans with NVMe storage, full root access and a 14-day free trial.
What VPS monitoring should tell you
A dashboard is useful only when it helps you answer a decision quickly: Is the server out of compute capacity, short of memory, filling its storage, waiting on slow storage, saturating a network link, or simply running a broken service? Those conditions can look similar if you watch only one percentage.
As an Amazon Associate I earn from qualifying purchases.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Monitor two layers at the same time:
- Host capacity and performance: CPU, load average, memory, swap, filesystems, inodes, disk activity, network throughput, packet errors, and uptime.
- User-visible availability: HTTP or TCP checks, latency, error rate, queue depth, database health, and other application signals.
A VPS can report normal CPU and memory while an HTTP service is returning errors, a firewall is blocking traffic, or a database is refusing connections. Conversely, a short CPU spike may be harmless if requests remain healthy. Monitoring is therefore a correlation exercise, not a hunt for a single “good” number.
Choose a monitoring approach
| Approach | Best fit | Strengths | Trade-offs |
|---|---|---|---|
| Provider-native monitoring | One VPS, especially a managed instance | Quick enablement, no dashboard server to maintain, provider graphs and alert delivery | Less control over retention, query language, dashboard design, and where telemetry is stored |
| Prometheus, Node Exporter, and Grafana | Multiple hosts, custom PromQL, longer history, portable operations | Flexible labels and queries, reusable dashboards, configurable retention and alert routing | You operate exporters, Prometheus, Grafana, storage, upgrades, authentication, and network security |
| External uptime or synthetic checks | Any VPS where reachability and user experience matter | Detects a dead host, broken firewall path, DNS failure, or service outage from outside | Does not replace host metrics; requires an external checking location |
Provider monitoring is usually the shortest path for a single server. For example, DigitalOcean describes its Monitoring service as a free, opt-in service that sends resource metrics to the control panel and supports graphs and alerts. Its documented categories include CPU, memory, disk I/O, and network usage over time. The exact controls and retention depend on your provider and plan, so check the current control-panel documentation before designing an incident process around them.
#1 Best Overall
- Includes Raspberry Pi 5 with 2.4Ghz 64-bit quad-core CPU (8GB RAM)
- Includes 128GB Micro SD Card pre-loaded with 64-bit Raspberry Pi OS, USB MicroSD Card Reader
- CanaKit Turbine Black Case for the Raspberry Pi 5
- CanaKit Low Noise Bearing System Fan
- Mega Heat Sink - Black Anodized
Prometheus and Grafana are preferable when you need one view across many VPS instances, custom PromQL expressions, consistent dashboards, or control over telemetry storage. Node Exporter exposes hardware- and kernel-related metrics, including CPU time, filesystem availability, and network byte counters. Grafana’s Linux integration uses Node Exporter for host CPU, memory, disk, and network panels.
Core VPS metrics and how to interpret them
CPU utilization and load average
Separate CPU time into user, system, I/O-wait, and idle where your collector exposes those states. User time generally reflects application work; system time reflects kernel work; I/O-wait indicates CPUs waiting for storage or other I/O; idle is unused capacity.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Load average is a queue-length signal, not a percentage. Interpret it against the number of virtual CPU cores. A load average near the core count can mean the run queue is consistently busy; a value well above it means runnable or uninterruptible work is accumulating. The reason matters:
- High load with high I/O-wait: investigate storage latency, noisy neighbors, a busy database, backups, or a saturated virtual disk.
- High user or system CPU with little I/O-wait: find a hot process, expensive query, runaway worker, or traffic-driven computation.
- High load but healthy application latency: inspect whether the work is expected (for example, a scheduled batch) before paging anyone.
Use a sustained condition rather than a single sample. A 15-second scrape interval is a common Prometheus example, but alert duration should be long enough to ignore normal short bursts and short enough to protect the service.
Memory, cache, swap, and out-of-memory events
“Used memory” alone is misleading on Linux because the kernel deliberately uses free RAM for filesystem cache. Track available memory, reclaimable cache, swap usage and its rate of change, and out-of-memory (OOM) kills.
- Available memory falling steadily: identify the process or workload consuming it and check whether cache can be reclaimed.
- Swap use rising or swap-in activity increasing: treat it as evidence of memory pressure, especially when application latency rises.
- OOM events: page immediately for production services; an OOM kill is a confirmed failure mode, not merely a warning percentage.
- High used percentage with stable available memory and no swap trend: may be normal cache behavior.
Set alerts around the condition that threatens service: sustained low available memory, increasing swap activity, or an OOM event. Leave enough headroom for kernel operations and short traffic bursts rather than waiting for the last megabytes.
Rank #2
- Includes Raspberry Pi 5 with 2.4Ghz 64-bit quad-core CPU (4GB RAM)
- Includes 128GB Micro SD Card pre-loaded with 64-bit Raspberry Pi OS, USB MicroSD Card Reader
- CanaKit Turbine Black Case for the Raspberry Pi 5
- CanaKit Low Noise Bearing System Fan
- CanaKit Mega Heat Sink - Black Anodized
Filesystem capacity and inode consumption
Measure bytes used and bytes available on every important mount, including separate volumes for databases, logs, uploads, and backups. Also measure inode usage. A filesystem can reject new files when inodes are exhausted even though substantial byte capacity remains.
Capacity and performance are separate signals. A nearly full volume with normal I/O may be a log-retention or backup problem. A half-empty volume with high latency or I/O-wait is a performance problem.
On Linux, a quick local check is:
df -h
df -iUse your monitoring system for continuous history and alerting; use these commands during an incident to identify the affected mount. When capacity rises, locate large directories and recent files before deleting anything. Preserve logs needed for diagnosis, and verify that a backup or rotation policy is not creating the growth.
Disk I/O, latency, and saturation
Collect read and write bytes, read and write operations, latency or utilization when the provider exposes them, and I/O-wait alongside CPU states. Throughput tells you how much data moved; operations describe request intensity; latency tells you how long requests waited. None of these is the same as free disk space.
Recommended Free Tools
Correlate a disk panel with workload changes:
- A backup can create a predictable throughput spike without indicating failure.
- Small random database writes can produce high operation counts and latency with modest byte throughput.
- High I/O-wait and a rising request queue indicate contention even when the filesystem is far from full.
If the provider reports only limited disk statistics, retain the signals it does provide and use process- or database-level instrumentation for the workload that matters.
Network throughput, errors, and drops
Track receive and transmit bytes, packet errors, drops, and both public and private bandwidth when those dimensions are available. A traffic spike may be legitimate growth, a backup transfer, a deployment, or an attack. Errors and drops are stronger evidence of a link, virtual interface, driver, or saturation problem than volume alone.
Rank #3
- CanaKit Raspberry Pi 5 Essentials Starter Kit
Prometheus’s Node Exporter examples include a rate over a network receive-byte counter, such as rate(node_network_receive_bytes_total[1m]). Counter rates are preferable to displaying a raw ever-increasing total. Alert on sustained saturation relative to the VPS plan and on abnormal errors or drops, then check whether application latency or retransmissions changed at the same time.
Uptime, boot time, and service health
Record boot time and uptime so an unexpected restart is visible. Uptime does not prove that the application works: a host can be running while a web server, database, queue consumer, or TLS endpoint is down.
Free tools Windows power users keep installed
One-click scans. No signup required.
Probe the service from outside the VPS. An external HTTP check should validate the expected status code and, where practical, a small response condition; a TCP check can verify that a port is reachable but cannot prove application correctness. Place the checker outside the same provider network so it can detect a provider outage, routing problem, firewall mistake, or unreachable host.
Set up provider-native monitoring on one VPS
- Enable the provider’s monitoring service. In the VPS control panel, look for Monitoring, Metrics, or Observability and opt in. Some providers install a metrics agent inside the guest operating system.
- Confirm data arrival. Verify that CPU, memory, disk, and network graphs have current timestamps. A blank graph usually means the agent is not installed, stopped, blocked, or attached to the wrong instance.
- Add alerts for actionable categories. Start with sustained CPU or load pressure, low available memory, swap growth or OOM events, filesystem and inode exhaustion, abnormal disk I/O, network errors or saturation, and failed service checks.
- Choose a notification route and owner. Ensure alerts reach someone who can act, and document escalation for an unreachable host versus a single failed process.
- Review retention and resolution. Confirm how long the provider keeps history and how often it samples. Short retention can hide weekly patterns; coarse sampling can miss brief incidents.
Provider-native monitoring minimizes maintenance, but it may not expose application metrics, detailed labels, or a query language. Add an external uptime check even when the provider dashboard is enabled.
Set up Prometheus, Node Exporter, and Grafana
1. Plan the topology and security boundary
Run Prometheus and Grafana on a separate monitoring host or protected management network when possible. Install Node Exporter on each Linux VPS. The exporter listens on port 9100 by convention. Do not expose its metrics endpoint or Grafana’s administrative interface to the public internet without a deliberate authentication and network-control design.
- Permit port 9100 only from the Prometheus server or private monitoring network.
- Restrict Prometheus and Grafana to administrators and trusted automation.
- Use TLS or a private network when metrics cross an untrusted network.
- Keep exporter, Prometheus, Grafana, and operating-system packages updated.
2. Install and verify Node Exporter
Install the Node Exporter release appropriate for your Linux distribution, run it as a dedicated service account, and configure it to start automatically. Verify locally that the endpoint returns Prometheus-formatted text:
Rank #4
- Includes Raspberry Pi 5 16GB with 2.4Ghz 64-bit quad-core CPU (16GB RAM)
- Includes 128GB Micro SD Card pre-loaded with 64-bit Raspberry Pi OS, USB MicroSD Card Reader
- CanaKit Turbine Black Case for the Raspberry Pi 5
- CanaKit Low Noise Bearing System Fan
- Mega Heat Sink - Black Anodized
curl http://127.0.0.1:9100/metricsIf this works locally but not from Prometheus, check the service bind address, host firewall, cloud firewall, routing, and the allowed source address. Keep the endpoint private unless you have a specific reason to publish it.
3. Add the VPS as a Prometheus target
Prometheus’s example configuration uses a 15-second scrape interval and a target on port 9100. A minimal target block looks like this:
global:
scrape_interval: 15s
scrape_configs:
- job_name: "vps"
static_configs:
- targets: ["vps-private-address:9100"]
labels:
host: "production-vps-1"Use a private address where available. After reloading Prometheus, check the Targets page and confirm the target is UP. A target marked down is a collection problem; it is not evidence that the VPS itself is down until you test reachability independently.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →4. Connect Grafana and build decision-oriented dashboards
- Add Prometheus as a Grafana data source using the internal URL that Grafana can reach.
- Import or create a dashboard built for Node Exporter host metrics.
- Organize panels into rows for compute pressure, memory pressure, storage capacity, storage performance, network, and availability.
- Use host and job variables so the same dashboard works for every VPS.
- Set a time range that shows both the incident and the preceding baseline.
Grafana publishes reusable VPS dashboards covering uptime, CPU, memory, swap, OOM kills, filesystems, inodes, disk I/O, and network. One published dashboard reports 25 queries and was tested with Grafana 10.4.0 and 13.2.2 against Node Exporter 1.12.1; those are dashboard-test details, not a performance benchmark or a promise that every installation behaves identically.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Design alerts that produce useful incidents
Baseline before setting thresholds
Observe normal hourly and daily patterns before paging. Record expected deployment windows, backups, traffic peaks, batch jobs, and maintenance reboots. A threshold should distinguish a sustained departure from that baseline from an ordinary burst.
There is no universal CPU, memory, disk, or bandwidth percentage that means “failure” for every VPS. A small single-core instance may be constrained at a lower load than a large instance, and an application can be unhealthy while host utilization looks ordinary. Use warning and critical levels that preserve headroom for your workload, then adjust them from observed false positives and missed incidents.
Best Value
- Includes Raspberry Pi 5 with 2.4Ghz 64-bit quad-core CPU (8GB RAM)
- Includes 32GB EVO+ Micro SD Card pre-loaded with 64-bit Pi OS, USB MicroSD Card Reader
- CanaKit Turbine Black Case for the Raspberry Pi 5
- CanaKit 45W PD Power Supply for the Raspberry Pi 5
- Display Cable - 6 foot (Supports up to 4K 60p)
Use duration and severity
Require a condition to remain true for a meaningful window before paging. Keep separate warning notifications for capacity trends and critical notifications for service-impacting events such as OOM kills, failed external probes, or an inode exhaustion condition. A one-sample spike should normally create a dashboard annotation or low-priority event, not an overnight page.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problemsCorrelate related signals
| Observed combination | Likely direction | First checks |
|---|---|---|
| High load plus high I/O-wait | Storage contention or latency | Disk latency/utilization, queue depth, backup jobs, database activity, provider incidents |
| High user/system CPU with low I/O-wait | Compute or process pressure | Top processes, recent deploys, request rate, worker counts, expensive queries |
| Falling available memory plus rising swap | Memory pressure | Largest resident processes, cache reclaimability, recent traffic or workload changes |
| Filesystem or inode usage rising while throughput is normal | Capacity or file-count growth | Logs, uploads, temporary files, backups, rotation and retention policies |
| Network spike with normal errors | Traffic or scheduled transfer | Backups, replication, deployments, user growth, expected public/private bandwidth |
| Normal host metrics with failed external probe | Application, firewall, DNS, routing, or TLS issue | Service logs, listener state, security rules, DNS records, synthetic response body |
A practical troubleshooting workflow
- Confirm the symptom externally. Check the external probe, HTTP status, latency, and whether the failure is global or limited to one region or path.
- Check monitoring freshness. A stopped exporter or stale provider agent can look like a healthy flat line. Confirm the last sample time and target status.
- Identify the leading metric. Compare CPU states, load, memory and swap, filesystem and inode capacity, disk latency or utilization, network errors, and service checks over the same incident window.
- Inspect the workload. Find the process, query, job, deployment, or traffic change that explains the leading signal. Do not restart blindly if doing so would erase evidence.
- Apply the least destructive fix. Examples include stopping an accidental batch job, correcting log rotation, reducing worker concurrency, freeing verified temporary files, or moving a workload after confirming backups and dependencies.
- Verify recovery. Confirm that the leading metric returns toward baseline and that user-visible latency, error rate, and service checks recover.
- Record and tune. Preserve the event window, leading metric, cause, fix, and outcome. Change an alert only when it was noisy, late, or aimed at the wrong symptom.
Common monitoring mistakes
- Watching only CPU: misses inode exhaustion, swap storms, disk latency, packet drops, and broken services.
- Using “used memory” as the only signal: treats useful cache as an emergency and can hide real swap or OOM risk.
- Confusing capacity with performance: free disk space does not prove that storage is fast, and high I/O does not prove that a volume is full.
- Alerting on single samples: creates pages for harmless bursts and teaches operators to ignore notifications.
- Leaving exporters public: exposes host and workload metadata unnecessarily. Restrict access to the collector.
- Monitoring from the same failure domain: a checker on the VPS or provider network cannot reliably detect a host, routing, or firewall outage that affects that domain.
- Ignoring retention: without enough history, you cannot see gradual memory leaks, weekly backups, or capacity trends.
How to choose your final setup
Choose provider-native monitoring when you operate one VPS, need basic resource graphs quickly, and prefer the provider to maintain the agent and alert plumbing. Choose Prometheus, Node Exporter, and Grafana when you operate multiple hosts or need custom queries, reusable dashboards, longer retention, and portability. In either case, add an external uptime or synthetic check and instrument the application paths that matter to users.
The most dependable design has a layered view: trend dashboards for capacity, correlated host metrics for diagnosis, alerts with a duration and an owner, and an external probe for reachability. That combination tells you not only that a VPS is busy, but why it is busy and whether customers can still use the service.
Frequently Asked Questions
What is the single most important VPS metric?
There is no universal single metric. Start with CPU/load, available memory and swap, filesystem and inode usage, disk I/O, network errors, and an external service check, then correlate them during incidents.
Should I use provider monitoring or Prometheus and Grafana?
Use provider monitoring for the shortest setup on one VPS. Use Prometheus with Node Exporter and Grafana for multiple hosts, custom PromQL, longer history, or control over dashboards and telemetry storage.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Why can a VPS fail when CPU and RAM look normal?
The application, firewall, DNS, TLS endpoint, database, or network path can fail independently of host utilization. An external HTTP or TCP probe and application-level metrics reveal those failures.
Is high disk usage the same as slow disk performance?
No. Filesystem capacity and I/O performance are separate. A volume can be nearly full but responsive, or mostly empty while latency and I/O-wait indicate contention.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
