Snapshots vs Backups: The $50 Mistake I See Every Week — VPS Snapshot Comparison 2026

Every week, without fail, someone in my inbox has the same story. They ran an OS upgrade, a database migration, or a "quick" config change. Something broke. They went to restore from backup. And then they discovered one of three things: (1) they never had automated backups enabled, (2) their last snapshot was from four months ago, or (3) they confused snapshots with backups and only had one of the two. The recovery cost them anywhere from $50 in emergency consultant time to $500 in lost data reconstruction.

The confusion between snapshots and backups is not their fault. Providers use the terms loosely. Marketing pages blur the distinction. And the pricing models are so different across providers that making an informed choice requires reading fine print that nobody reads until they need it.

I spent three weeks documenting the snapshot policies, pricing, limits, restore times, and API capabilities across every major US VPS provider. What I found surprised even me — particularly the gap between providers who treat snapshots as a core feature and those who treat them as a profit center.

1. Snapshots vs Backups: The Difference That Costs People Money

I see people use these terms interchangeably, and it leads to nasty surprises. A snapshot is a point-in-time freeze of your entire server — OS, packages, config files, data, everything. You take it manually before a risky change. If the change breaks something, you restore the snapshot and you are back to exactly where you were two minutes ago. Fast to create, fast to restore, manually triggered.

A backup is an automated, scheduled copy of your data (sometimes the full disk, sometimes incremental). It runs on a schedule — daily, weekly — with retention policies that keep the last N copies. You do not need to remember to create it. It happens in the background.

The $50 mistake: relying on only one. Snapshots protect against your own mistakes (bad config changes, failed upgrades). Backups protect against disasters (hardware failure, ransomware, accidental deletion). If you only have snapshots, you will eventually forget to take one before a critical change. If you only have backups, your most recent backup might be 24 hours old — a full day of data loss after a botched upgrade you could have rolled back in 2 minutes.

The right strategy: Snapshots before every significant change + automated daily backups + periodic off-site backups. The security hardening guide covers the automated backup component.

2. The Full Provider Comparison

I dug into the pricing pages, Terms of Service, and API documentation of every major VPS provider. Some of what I found was genuinely surprising, particularly how much snapshot costs diverge between providers with otherwise similar pricing:

The standout gap: Hetzner offers unlimited free snapshots with full API access while DigitalOcean charges $0.05/GB/mo from the first snapshot. On a server using 20GB of disk space, keeping 5 snapshots costs $0/mo at Hetzner and $5/mo at DigitalOcean. Over a year, that is $60 in pure snapshot costs — potentially more than the VPS itself at the budget tier.

3. What Snapshots Actually Cost Per Month

Assuming your server uses 20GB of disk space, here is the real monthly cost of maintaining different numbers of snapshots across providers that charge:

For developers maintaining 10 snapshots of a 20GB server: $0/year at Hetzner vs $120/year at DigitalOcean vs $144/year at Linode. That is enough to pay for two additional months of the VPS itself at some providers. I found this genuinely amusing when I first calculated it — the snapshot storage fees at some providers exceed the actual compute cost.

4. Best Providers for Free Snapshots

Hetzner — The Gold Standard

Unlimited free snapshots. Full REST API. Terraform provider support. Restore in about 2 minutes. If you manage infrastructure with Terraform or Ansible, Hetzner's snapshot resource integrates natively into your deployment pipelines. I use it to create pre-deployment safety nets in CI/CD workflows automatically — the machine remembers to snapshot even when I forget. The only limitation is geographic: Ashburn, Virginia is the sole US option. If that location works for your audience, Hetzner's snapshot story is the best in the industry.

BuyVM — Generous But Manual

BuyVM matches Hetzner on generosity: unlimited free snapshots with fast restores. The gap is their Stallion control panel — no API, no automation, everything through the web interface. For someone who snapshots before updates and restores occasionally, this works fine. For anyone running automated deployments, the lack of API is a dealbreaker. At $3.50/mo for their entry plan with unlimited free snapshots, BuyVM is hard to argue with for manual workflows.

InterServer — Three Free (Enough for Most)

Three snapshots per server. Is that enough? For most workflows: yes. My standard snapshot rotation: one "known good baseline" snapshot, one "pre-update" snapshot, and one "post-successful-update" snapshot. That is exactly three. InterServer covers the common case, and their price lock guarantee means the feature stays free at the same rate indefinitely. For users who need more, look elsewhere — but I suspect most people overestimate how many snapshots they actually use in practice.

Vultr — One Free, Best API

One free snapshot per server, $0.05/GB for extras. Where Vultr shines is API quality. Their snapshot endpoints are clean, well-documented, and integrate into deployment scripts seamlessly. I use them for development workflows where spinning up a fresh environment from a snapshot takes 90 seconds. The one free snapshot covers the "pre-update safety net" use case, and the per-GB pricing is reasonable for users who need more.

5. API Automation: Because You Will Forget

Manual snapshots work until the one time you forget before a critical update. Here is what each provider offers for automation:

# Vultr: Create snapshot via API
curl -X POST "https://api.vultr.com/v2/snapshots" \
  -H "Authorization: Bearer ${VULTR_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "instance_id": "your-instance-id",
    "description": "pre-upgrade-2026-03-21"
  }'

# DigitalOcean: Create snapshot
curl -X POST "https://api.digitalocean.com/v2/droplets/YOUR_ID/actions" \
  -H "Authorization: Bearer ${DO_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{"type": "snapshot", "name": "pre-upgrade-2026-03-21"}'

# Hetzner: Create snapshot (called "image" in their API)
curl -X POST "https://api.hetzner.cloud/v1/servers/YOUR_ID/actions/create_image" \
  -H "Authorization: Bearer ${HETZNER_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{"type": "snapshot", "description": "pre-upgrade-2026-03-21"}'

# Automated weekly snapshot with rotation (example for Vultr):
#!/bin/bash
# /usr/local/bin/snapshot-rotate.sh

VULTR_API="https://api.vultr.com/v2"
INSTANCE_ID="your-instance-id"
KEEP=4  # Keep last 4 snapshots

# Create new snapshot
DESCRIPTION="auto-$(date +%Y-%m-%d)"
curl -s -X POST "$VULTR_API/snapshots" \
  -H "Authorization: Bearer $VULTR_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"instance_id\": \"$INSTANCE_ID\", \"description\": \"$DESCRIPTION\"}"

# List snapshots, delete oldest if more than $KEEP
SNAPSHOTS=$(curl -s "$VULTR_API/snapshots" \
  -H "Authorization: Bearer $VULTR_API_KEY" \
  | jq -r '.snapshots | sort_by(.date_created) | .[].id')

COUNT=$(echo "$SNAPSHOTS" | wc -l)
if [ "$COUNT" -gt "$KEEP" ]; then
  DELETE_COUNT=$((COUNT - KEEP))
  echo "$SNAPSHOTS" | head -n $DELETE_COUNT | while read SNAP_ID; do
    curl -s -X DELETE "$VULTR_API/snapshots/$SNAP_ID" \
      -H "Authorization: Bearer $VULTR_API_KEY"
    echo "Deleted: $SNAP_ID"
  done
fi

# Schedule with cron (every Sunday at 3 AM):
# 0 3 * * 0 /usr/local/bin/snapshot-rotate.sh >> /var/log/snapshot-rotate.log 2>&1

For Terraform users, Hetzner, DigitalOcean, and Linode all have mature providers that support snapshot resources natively. I manage my personal infrastructure entirely through Terraform, and codifying snapshot creation as part of the deployment process means I never forget.

6. Real Snapshot Use Cases

Pre-Update Safety Net

This is the most common and most valuable use. Before any risky change — PHP version upgrade, MySQL major version migration, Nginx configuration rewrite, Ubuntu dist-upgrade — take a snapshot. If the change breaks something, restore in 2 minutes instead of spending 3 hours debugging. I have used this workflow hundreds of times. It has saved me from at least a dozen disasters that would have meant hours of recovery.

Clone Production to Staging

Snapshot production. Deploy a new VPS from the snapshot. You now have an identical staging environment — same OS, packages, database, config — in under 2 minutes. Test your changes against real data. On hourly-billed providers like Vultr or DigitalOcean, the staging server costs pennies to run for an afternoon. This catches problems that unit tests miss because it runs against real configuration with real data.

Development Environment Template

Set up a clean development environment with your full toolchain: PHP, Node.js, Docker, databases, code editors, SSH keys. Snapshot it. Use this as a template for every new project. When a dev environment gets messy, destroy it and restore from the clean snapshot in minutes instead of spending an hour reinstalling everything.

Disaster Recovery Testing

Take a snapshot. Intentionally break something on the server (corrupt a database, delete a config file, simulate ransomware). Time how long it takes to restore. This exercise reveals gaps in your recovery process before a real incident forces you to discover them at 3 AM under pressure. Run this drill quarterly.

Migration Safety Net

When migrating between hosts, snapshot the old server as your rollback point. If the migration fails, restore the snapshot on the original provider while you troubleshoot. The old server stays intact and accessible within 2 minutes of restoring the snapshot.

7. Snapshot Best Practices

• Label snapshots descriptively. 2026-03-21-pre-php84-upgrade is useful at 2 AM during an incident. snapshot-1 is not. Include date and reason.
• Take "before" and "after" snapshots. Before a risky change, snapshot as your rollback. After a successful change, snapshot as your new baseline. If something breaks days later, you can roll back to the post-change state without losing subsequent work.
• Flush databases before snapshotting. While snapshots do not cause downtime, taking one during heavy disk I/O can result in inconsistent data. For MySQL: FLUSH TABLES WITH READ LOCK; before snapshot, UNLOCK TABLES; after.
• Test your restores quarterly. A snapshot you have never restored is a snapshot you cannot trust. Deploy from it. Verify services start. Confirm database is consistent. On hourly-billed providers, this costs cents.
• Delete old snapshots. Snapshot storage adds up on providers that charge. Keep a maximum of 4-5 recent snapshots and delete older ones. Automate this with the rotation script above.
• Never rely solely on provider snapshots. Maintain off-site backups separately. Provider snapshots protect against your mistakes but not against provider-level failures.

8. The Complete Disaster Recovery Strategy

The strategy I implement for every production VPS I manage. Three layers, each protecting against different failure modes:

Layer 1 is your fast undo button. Layer 2 catches things you forgot to snapshot. Layer 3 survives total provider failure. All three together cost maybe $5-10/mo on top of your VPS. Cheap insurance for irreplaceable data.

9. Off-Site Backups: The Layer Most People Skip

Provider snapshots live on provider infrastructure. If the provider has a catastrophic failure, your snapshots go with it. The probability is low. The impact is total. Off-site backups to a different provider eliminate this risk.

# Option 1: restic to Backblaze B2 (my recommendation)
# B2 storage costs $0.005/GB/mo — 20GB = $0.10/mo
apt install -y restic

# Initialize repository
export B2_ACCOUNT_ID="your-account-id"
export B2_ACCOUNT_KEY="your-account-key"
restic -r b2:your-bucket:/server-name init

# Daily backup of critical directories
restic -r b2:your-bucket:/server-name backup \
  /etc /var/www /var/lib/mysql \
  --exclude='*.log' \
  --exclude='cache'

# Retention: keep 7 daily, 4 weekly, 6 monthly
restic -r b2:your-bucket:/server-name forget \
  --keep-daily 7 --keep-weekly 4 --keep-monthly 6 --prune

# Schedule with cron (daily at 2 AM):
# 0 2 * * * /usr/local/bin/restic-backup.sh >> /var/log/restic.log 2>&1

# Option 2: borgbackup (excellent deduplication)
apt install -y borgbackup

# Option 3: rclone to any cloud storage
# Supports S3, B2, Google Cloud, Wasabi, etc.
apt install -y rclone
rclone config  # Interactive setup
rclone sync /var/www remote:backups/www --progress

# Option 4: Simple rsync to a second VPS at a different provider
# A $3.50/mo BuyVM instance as a dedicated backup server
rsync -avz --delete /var/www /etc /var/lib/mysql \
  backup@backup-server.com:/backups/main-server/

The cost of off-site backup storage is negligible. Backblaze B2 at $0.005/GB/mo means a 20GB backup costs ten cents per month. Twelve cents if you keep multiple versions. The performance impact of the nightly backup job is minimal if scheduled during low-traffic hours.

Frequently Asked Questions

Do VPS snapshots cause downtime?

No. Snapshots are taken while the server runs. However, for database-heavy workloads, flush writes before snapshotting to ensure consistency. MySQL: FLUSH TABLES WITH READ LOCK; before snapshot, UNLOCK TABLES; after. PostgreSQL: use pg_start_backup() and pg_stop_backup(). For quick snapshots of non-database servers, the risk of inconsistency is minimal.

Can I transfer a snapshot between providers?

Not directly. Snapshots use proprietary formats. To migrate: deploy from the snapshot on the original provider, then use rsync or dd to transfer data to the new provider. Some providers (DigitalOcean, Hetzner) support importing custom disk images (raw, qcow2). For most migrations, rsync + mysqldump is more practical. See the migration guide for the full process.

How much storage space does a snapshot use?

Roughly the size of your used disk space, not the total allocation. A 50GB SSD with 12GB used produces approximately a 12GB snapshot (varies by provider compression). Providers that charge per-GB bill on this compressed size: Vultr at $0.05/GB/mo, DigitalOcean at $0.05/GB/mo, Linode at $0.06/GB/mo. On a 20GB used disk, each snapshot costs $1.00-1.20/mo at paid providers. At Hetzner: free.

Should I use snapshots instead of backups?

Use both. Snapshots are your fast undo button for risky changes. Backups are your automated insurance policy. The common mistake: relying on only one. Snapshots fail when you forget to take them. Backups fail when you need to roll back a change made 10 minutes ago but the last backup was 24 hours ago. The right strategy: manual snapshots before changes + automated daily backups + off-site backups for disaster recovery.

Why does RackNerd not support snapshots?

RackNerd uses SolusVM, which lacks snapshot functionality in its standard configuration. Their focus is ultra-low-cost plans where snapshot infrastructure would add overhead. Alternatives at similar pricing: InterServer (3 free snapshots) or Hetzner (unlimited free at $4.59/mo). If you choose RackNerd, implement off-site backups with restic or borgbackup to compensate.

How often should I take snapshots?

Before every significant change (OS upgrades, package updates, config modifications, database migrations). For ongoing protection: schedule weekly snapshots via API with 4-week retention. For development environments: daily during active work. Cost on providers that charge is minimal — a 20GB snapshot at Vultr costs $1/mo. The question is not "how often" but "can I afford to lose changes since the last snapshot?"

What is the best provider for free snapshots?

Hetzner: unlimited free snapshots, full API, Terraform support, ~2 min restore. The clear winner. BuyVM: unlimited free but no API. InterServer: 3 free, covers most workflows. For API automation needs, Hetzner is the obvious choice. For basic snapshot protection, even Contabo and Hostinger include 1 free snapshot with every plan.

How do I automate snapshot creation via API?

Most cloud providers expose snapshot endpoints: Vultr (POST /v2/snapshots), DigitalOcean (POST /v2/droplets/{id}/actions), Hetzner (POST /v1/servers/{id}/actions/create_image). Wrap the API call in a bash script, schedule with cron, and add a cleanup step to delete snapshots older than your retention period. For infrastructure-as-code workflows, use Terraform — Hetzner, DigitalOcean, and Linode all have mature Terraform providers.

What happens to snapshots if I delete the VPS?

This varies. On Vultr, DigitalOcean, and Hetzner: snapshots persist after VPS deletion and you can create a new VPS from them at any time. On Contabo and Hostinger: snapshots may be tied to the VPS lifecycle and deleted when the VPS is removed. Always check your provider's documentation before destroying a VPS with important snapshots. When in doubt, export critical data separately before deletion.