Backup Strategies for Self-Hosted Servers Guide 2026

Imagine spending months building your home server, configuring services, and storing precious photos—only to lose everything because a hard drive failed or ransomware struck. That’s the nightmare that proper backups prevent.

Backups are your safety net. They’re the difference between a minor inconvenience and a catastrophic data loss. In 2026, with digital data more valuable than ever, having a solid backup strategy isn’t optional—it’s essential.

This beginner-friendly guide will walk you through everything you need to know about backing up your self-hosted server, from basic concepts to practical implementations.

Why Backups Matter

The Reality of Data Loss

What You’re Really Protecting

Your self-hosted server contains:
├── Personal Photos and Videos (irreplaceable)
├── Documents and Files (work, personal)
├── Configuration Files (took hours to set up)
├── Databases (Jellyfin, Nextcloud, etc.)
├── Docker Containers and Volumes
├── Application Data (Plex metadata, etc.)
└── System Configuration (hours of work)

Cost of Not Backing Up

# Time to rebuild from scratch
- Reinstall OS: 1 hour
- Configure services: 2-10 hours
- Recover data: 0-100 hours (if possible)
- Reconfigure settings: 2-5 hours
- Total: 5-100+ hours of work

# Emotional cost
- Loss of precious photos
- Loss of important documents
- Stress and frustration
- Loss of trust in technology

The Backup Fundamentals

The 3-2-1 Backup Rule

This is the golden rule of backups:

3 Copies of your data
├── 1 Original (on your server)
├── 2 Backups (different locations)

2 Different Storage Types
├── Internal Drive (SSD/HDD)
├── External Drive or Cloud

1 Copy Off-site
└── Cloud storage or another physical location

Types of Backups

Backup Storage Options

# Local Storage
├── External Hard Drive (USB)
├── Second Internal Drive
├── NAS (Network Attached Storage)
└── RAID Array

# Remote Storage
├── Cloud Backup (Backblaze, AWS, etc.)
├── Another Server (off-site)
├── Family/Friend's Server
└── Colocation

# Hybrid (Best Practice)
├── Local Backup (fast recovery)
├── Remote Backup (disaster recovery)

What to Backup

Priority Levels

Critical (Must Backup):

# 1. Personal Data
/home/username/Documents/
/home/username/Pictures/
/home/username/Downloads/

# 2. Application Data
/var/lib/docker/volumes/
/var/lib/mysql/
/var/lib/postgresql/

# 3. Configuration
/etc/
/usr/local/etc/
.env files

Important (Should Backup):

# 4. Service Data
/var/www/
/opt/
/var/lib/nginx/

# 5. System State
crontab backups
user lists
package lists

Nice to Have:

# 6. Logs (for debugging)
/var/log/

# 7. Cache (speed up recovery)
/var/cache/

Backup Size Estimation

# Check what's taking space
sudo du -sh /* 2>/dev/null | sort -h

# Identify largest directories
sudo du -h --max-depth=1 /home 2>/dev/null | sort -h

# Check Docker volume sizes
docker system df -v

# Calculate backup size needed
echo "Data to backup: $(du -sh /home /var/lib/docker/volumes | cut -f1)"

Backup Tools Comparison

Popular Backup Tools

Quick Tool Comparison

# rsync - Simple and fast
rsync -av /source /destination

# BorgBackup - Efficient with compression
borg create /backup::today /source

# Restic - Works with cloud
restic backup /source

# Duplicati - GUI available
# Configurable via web interface

# Timeshift - System restore
timeshift --create

Method 1: Rsync (Simple and Reliable)

Rsync is the most basic and reliable backup tool.

Local Backup to External Drive

# Basic rsync command
rsync -avh /home/username/ /media/usb/backup/

# With progress
rsync -avh --progress /home/username/ /media/usb/backup/

# Preserve permissions and ownership
rsync -avzh /home/username/ /media/usb/backup/

# Copy only new/changed files
rsync -avh --update /home/username/ /media/usb/backup/

# Delete files in destination that don't exist in source
rsync -avh --delete /home/username/ /media/usb/backup/

# Exclude certain directories
rsync -avh --exclude='.cache/' --exclude='.thumbnails/' /home/username/ /media/usb/backup/

Remote Backup with Rsync

# Backup to remote server
rsync -avzh -e ssh /home/username/ user@remote-server:/backup/

# Using custom SSH port
rsync -avzh -e "ssh -p 2222" /home/username/ user@remote-server:/backup/

# Backup from remote to local
rsync -avzh -e ssh user@remote-server:/data/ /local/backup/

# With compression
rsync -avzh -e ssh --compress-level=9 /home/username/ user@remote-server:/backup/

Automated Rsync Backup Script

#!/bin/bash
# backup.sh - Automated Rsync Backup

# Configuration
BACKUP_SOURCE="/home/username /var/lib/docker/volumes /etc"
BACKUP_DEST="/media/external/backup"
EXCLUDE="--exclude='.cache/' --exclude='.thumbnails/' --exclude='tmp/'"
LOG_FILE="/var/log/backup.log"

# Start backup
echo "=== Backup Started: $(date) ===" >> $LOG_FILE

for SOURCE in $BACKUP_SOURCE; do
    echo "Backing up: $SOURCE" >> $LOG_FILE
    rsync -avzh --delete $EXCLUDE $SOURCE $BACKUP_DEST/ >> $LOG_FILE 2>&1
done

echo "=== Backup Completed: $(date) ===" >> $LOG_FILE
echo "" >> $LOG_FILE

# Make executable
chmod +x backup.sh

# Schedule with cron
sudo crontab -e
# Add:
0 2 * * * /path/to/backup.sh

Method 2: BorgBackup (Efficient and Secure)

BorgBackup provides deduplication, compression, and encryption.

Installation

# Ubuntu/Debian
sudo apt install borgbackup -y

# CentOS/RHEL
sudo yum install borgbackup -y

# Verify installation
borg --version

Initial Setup

# Create backup directory
sudo mkdir -p /backup/borg

# Initialize backup repository
sudo borg init --encryption=repokey /backup/borg

# Set encryption key (store safely!)
# You'll be prompted for a passphrase

# Check repository
sudo borg info /backup/borg

Creating Backups

# Basic backup
sudo borg create --stats /backup/borg::backup-$(date +%Y%m%d) /home

# With compression
sudo borg create --compression zstd,10 --stats /backup/borg::backup-$(date +%Y%m%d) /home

# Backup multiple directories
sudo borg create --stats /backup/borg::backup-$(date +%Y%m%d) /home /etc /var/lib/docker

# Exclude directories
sudo borg create \
    --exclude '/home/*/.cache' \
    --exclude '/home/*/.thumbnails' \
    --stats \
    /backup/borg::backup-$(date +%Y%m%d) /home

# With encryption
sudo borg create --encryption=repokey-blake2 /backup/borg::backup-$(date +%Y%m%d) /home

Automated Borg Backup Script

#!/bin/bash
# borg-backup.sh - Automated Borg Backup

# Configuration
REPO="/backup/borg"
BACKUP_NAME="backup-$(date +%Y%m%d_%H%M%S)"
SOURCE="/home /var/lib/docker/volumes /etc"
EXCLUDE="--exclude '/home/*/.cache' --exclude '/home/*/.thumbnails'"
LOG_FILE="/var/log/borg-backup.log"

# Set passphrase
export BORG_PASSPHRASE="your-secure-passphrase"

# Start backup
echo "=== Borg Backup Started: $(date) ===" >> $LOG_FILE

borg create --stats --compression zstd,10 $EXCLUDE \
    $REPO::$BACKUP_NAME $SOURCE >> $LOG_FILE 2>&1

# Check backup
echo "Backup completed, checking..." >> $LOG_FILE
borg check $REPO >> $LOG_FILE 2>&1

# Prune old backups
echo "Pruning old backups..." >> $LOG_FILE
borg prune --keep-daily 7 --keep-weekly 4 --keep-monthly 6 $REPO >> $LOG_FILE 2>&1

echo "=== Borg Backup Completed: $(date) ===" >> $LOG_FILE
echo "" >> $LOG_FILE

Restoring from Borg Backup

# List available backups
borg list /backup/borg

# Restore entire backup
borg extract /backup/borg::backup-20240101

# Restore specific directory
borg extract /backup/borg::backup-20240101 home/username/Documents

# Mount backup (for browsing)
mkdir /tmp/borg-mount
borg mount /backup/borg::backup-20240101 /tmp/borg-mount
# Browse files at /tmp/borg-mount
borg umount /tmp/borg-mount

Method 3: Restic (Modern and Cloud-Ready)

Restic is a modern backup tool with excellent cloud support.

Installation

# Ubuntu/Debian
sudo apt install restic -y

# Or download latest
wget https://github.com/restic/restic/releases/latest/download/restic_linux_amd64.bz2
bunzip2 restic_linux_amd64.bz2
sudo mv restic_linux_amd64 /usr/local/bin/restic
sudo chmod +x /usr/local/bin/restic

Setting Up Restic

# Initialize local repository
restic init --repo /backup/restic

# Initialize S3 repository
export AWS_ACCESS_KEY_ID=your-key
export AWS_SECRET_ACCESS_KEY=your-secret
restic init --repo s3:s3.amazonaws.com/your-bucket/restic

# Initialize Backblaze B2
export B2_ACCOUNT_ID=your-id
export B2_ACCOUNT_KEY=your-key
restic init --repo b2:bucket-name:restic

# Initialize with encryption
restic init --repo /backup/restic --repository-key mypassword

Creating Backups

# Basic backup
restic backup /home --repo /backup/restic

# With tags
restic backup /home --repo /backup/restic --tag "daily"

# Exclude patterns
restic backup /home --repo /backup/restic \
    --exclude "*.cache" \
    --exclude "*.thumbnails"

# Backup with compression
restic backup /home --repo /backup/restic --compression max

Automated Restic Backup Script

#!/bin/bash
# restic-backup.sh - Automated Restic Backup

# Configuration
REPO="/backup/restic"
RESTIC_PASSWORD="your-password"
BACKUP_SOURCE="/home /var/lib/docker/volumes /etc"
TAGS="daily"
LOG_FILE="/var/log/restic-backup.log"

export RESTIC_PASSWORD
export AWS_ACCESS_KEY_ID="your-key"  # For S3
export AWS_SECRET_ACCESS_KEY="your-secret"

# Start backup
echo "=== Restic Backup Started: $(date) ===" >> $LOG_FILE

restic backup $BACKUP_SOURCE --repo $REPO --tag $TAGS >> $LOG_FILE 2>&1

# Check backup
echo "Checking repository..." >> $LOG_FILE
restic check --repo $REPO >> $LOG_FILE 2>&1

# Prune old backups
echo "Pruning old backups..." >> $LOG_FILE
restic forget --keep-daily 7 --keep-weekly 4 --keep-monthly 6 --repo $REPO >> $LOG_FILE 2>&1

# Remove old snapshots
restic prune --repo $REPO >> $LOG_FILE 2>&1

echo "=== Restic Backup Completed: $(date) ===" >> $LOG_FILE

Restoring from Restic

# List snapshots
restic snapshots --repo /backup/restic

# Restore latest
restic restore latest --target /restore --repo /backup/restic

# Restore specific snapshot
restic restore snapshot-id --target /restore --repo /backup/restic

# Restore specific path
restic restore snapshot-id --target /restore --include /home/username/Documents --repo /backup/restic

Method 4: Duplicati (GUI-Based for Beginners)

Duplicati offers a web interface for easy backup management.

Installation (Docker)

# Create directory
mkdir duplicati
cd duplicati

# Create docker-compose.yml
cat > docker-compose.yml << EOF
version: '3.8'

services:
  duplicati:
    image: lscr.io/linuxserver/duplicati:latest
    container_name: duplicati
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
    volumes:
      - /path/to/config:/config
      - /path/to/backups:/backups
      - /home:/source/home:ro
      - /var/lib/docker/volumes:/source/docker-volumes:ro
    ports:
      - 8200:8200
    restart: unless-stopped
EOF

# Start Duplicati
docker-compose up -d

# Access web interface:
# http://your-server-ip:8200

Configuring Duplicati

# 1. Open http://your-server-ip:8200
# 2. Create a new backup
# 3. Choose backup source (what to backup)
# 4. Choose backup destination (where to save)
# 5. Set schedule
# 6. Choose encryption
# 7. Save and run first backup

# Common destinations:
# - Local folder
# - External drive
# - S3 (AWS, Backblaze)
# - FTP/SFTP
# - Google Drive
# - OneDrive

Method 5: Application-Specific Backups

Docker container Backups

#!/bin/bash
# docker-backup.sh

BACKUP_DIR="/backup/docker"
DATE=$(date +%Y%m%d)

# Backup Docker volumes
for volume in $(docker volume ls -q); do
    echo "Backing up volume: $volume"
    docker run --rm -v $volume:/volume -v $BACKUP_DIR:/backup alpine \
        tar -czf /backup/${volume}-${DATE}.tar.gz -C /volume .
done

# Backup container configuration
docker ps -a --format "table {{.Names}}\t{{.Image}}\t{{.Status}}" > $BACKUP_DIR/containers-$DATE.txt

# Backup Docker Compose files
find / -name "docker-compose.yml" -exec cp {} $BACKUP_DIR/compose-$DATE/ \;

# Backup networks
docker network ls > $BACKUP_DIR/networks-$DATE.txt

Database Backups

MySQL/MariaDB:

#!/bin/bash
# mysql-backup.sh

BACKUP_DIR="/backup/mysql"
DATE=$(date +%Y%m%d_%H%M%S)

# Backup all databases
docker exec mysql-container mysqldump \
    --all-databases \
    --single-transaction \
    --quick \
    --lock-tables=false \
    > $BACKUP_DIR/all-databases-$DATE.sql

# Backup individual databases
for db in $(docker exec mysql-container mysql -e "SHOW DATABASES;" | grep -v Database); do
    docker exec mysql-container mysqldump --single-transaction $db > $BACKUP_DIR/$db-$DATE.sql
done

# Compress backups
gzip $BACKUP_DIR/*-$DATE.sql

# Keep last 7 days
find $BACKUP_DIR -name "*.sql.gz" -mtime +7 -delete

PostgreSQL:

#!/bin/bash
# postgres-backup.sh

BACKUP_DIR="/backup/postgres"
DATE=$(date +%Y%m%d_%H%M%S)

# Backup all databases
docker exec postgres-container pg_dumpall \
    -U postgres \
    > $BACKUP_DIR/all-databases-$DATE.sql

# Backup individual databases
for db in $(docker exec postgres-container psql -U postgres -t -c "SELECT datname FROM pg_database WHERE datistemplate = false;"); do
    docker exec postgres-container pg_dump -U postgres $db > $BACKUP_DIR/$db-$DATE.sql
done

# Compress
gzip $BACKUP_DIR/*-$DATE.sql

# Keep last 7 days
find $BACKUP_DIR -name "*.sql.gz" -mtime +7 -delete

Application Data Backups

#!/bin/bash
# app-backups.sh

# Backup Nextcloud
rsync -av /var/lib/docker/volumes/nextcloud_data/ /backup/nextcloud/

# Backup Jellyfin metadata
rsync -av /var/lib/docker/volumes/jellyfin_config/ /backup/jellyfin/

# Backup Plex
rsync -av /var/lib/docker/volumes/plex_config/ /backup/plex/

# Backup Home Assistant
rsync -av /home/username/homeassistant/ /backup/homeassistant/

# Backup WordPress
rsync -av /var/www/wordpress/ /backup/wordpress/

# Backup configurations
rsync -av /etc/ /backup/etc/

The 3-2-1 Implementation

Complete Backup Strategy

#!/bin/bash
# complete-backup.sh - 3-2-1 Backup Strategy

DATE=$(date +%Y%m%d)
LOG_FILE="/var/log/complete-backup.log"

echo "=== Starting 3-2-1 Backup: $DATE ===" | tee -a $LOG_FILE

# Copy 1: Local Backup (Internal)
echo "1. Local internal backup..." | tee -a $LOG_FILE
rsync -av /home/ /backup/internal/home/ >> $LOG_FILE 2>&1
rsync -av /var/lib/docker/volumes/ /backup/internal/docker-volumes/ >> $LOG_FILE 2>&1
rsync -av /etc/ /backup/internal/etc/ >> $LOG_FILE 2>&1

# Copy 2: External Backup (External Drive)
echo "2. External drive backup..." | tee -a $LOG_FILE
rsync -av /home/ /media/external/backup/home/ >> $LOG_FILE 2>&1
rsync -av /var/lib/docker/volumes/ /media/external/backup/docker-volumes/ >> $LOG_FILE 2>&1

# Copy 3: Off-site Backup (Cloud)
echo "3. Cloud backup..." | tee -a $LOG_FILE
restic backup /home /var/lib/docker/volumes --repo s3:backup-bucket >> $LOG_FILE 2>&1

# Verify backups
echo "4. Verifying backups..." | tee -a $LOG_FILE
restic check --repo s3:backup-bucket >> $LOG_FILE 2>&1

# Database backups
echo "5. Database backups..." | tee -a $LOG_FILE
docker exec mysql-container mysqldump --all-databases > /backup/mysql-$DATE.sql
restic backup /backup/mysql-$DATE.sql --repo s3:backup-bucket >> $LOG_FILE 2>&1

echo "=== Backup Complete: $DATE ===" | tee -a $LOG_FILE

Backup Monitoring and Alerts

Monitoring Script

#!/bin/bash
# check-backups.sh - Monitor backup health

ALERT_EMAIL="admin@domain.com"

# Check last backup age
LAST_BACKUP=$(find /backup -name "*.tar.gz" -type f -printf "%T@ %p\n" | sort -nr | head -1 | cut -d' ' -f1)
NOW=$(date +%s)
AGE=$(( (NOW - LAST_BACKUP) / 3600 ))

# Check backup size
BACKUP_SIZE=$(du -sh /backup | cut -f1)

# Check if backups exist
if [ -z "$(ls -A /backup)" ]; then
    echo "ERROR: No backups found!" | mail -s "Backup Alert" $ALERT_EMAIL
    exit 1
fi

# Check if backup is recent (< 24 hours)
if [ $AGE -gt 24 ]; then
    echo "WARNING: Backup is $AGE hours old" | mail -s "Backup Age Alert" $ALERT_EMAIL
fi

# Check cloud backup
restic snapshots --repo s3:backup-bucket --last | mail -s "Backup Report" $ALERT_EMAIL

# Check disk space for backups
DISK_USAGE=$(df -h /backup | tail -1 | awk '{print $5}')
if [ ${DISK_USAGE%\%} -gt 80 ]; then
    echo "WARNING: Backup disk is $DISK_USAGE full" | mail -s "Backup Space Alert" $ALERT_EMAIL
fi

echo "Backup check completed at $(date)"

Backup Dashboard (Simple Web View)

#!/bin/bash
# backup-dashboard.sh - Generate HTML report

cat > /var/www/backup-status.html << EOF
<!DOCTYPE html>
<html>
<head>
    <title>Backup Status</title>
    <style>
        body { font-family: Arial; margin: 20px; }
        .ok { color: green; }
        .warning { color: orange; }
        .error { color: red; }
        .container { margin-bottom: 20px; }
    </style>
</head>
<body>
    <h1>Backup Status</h1>
    <div class="container">
        <h2>Summary</h2>
        <pre>$(date)</pre>
    </div>
    <div class="container">
        <h2>Local Backups</h2>
        <pre>$(ls -lh /backup | tail -10)</pre>
    </div>
    <div class="container">
        <h2>Disk Usage</h2>
        <pre>$(df -h /backup)</pre>
    </div>
    <div class="container">
        <h2>Recent Restic Backups</h2>
        <pre>$(restic snapshots --repo /backup/restic --last 5 2>/dev/null)</pre>
    </div>
</body>
</html>
EOF

Recovery Testing

Test Your Backups Regularly

#!/bin/bash
# test-backup.sh - Test backup restoration

TEST_DIR="/tmp/restore-test"
BACKUP_TO_TEST="/backup/latest"

echo "Testing backup restoration..."

# Clean test directory
rm -rf $TEST_DIR
mkdir -p $TEST_DIR

# Test restore files
echo "Testing file restore..."
rsync -av --dry-run $BACKUP_TO_TEST/ $TEST_DIR/ > /dev/null
if [ $? -eq 0 ]; then
    echo "✅ File restore test passed"
else
    echo "❌ File restore test failed"
fi

# Test database restore
echo "Testing database restore..."
gunzip -c /backup/mysql/*.sql.gz > $TEST_DIR/test-restore.sql 2>/dev/null
if [ -f $TEST_DIR/test-restore.sql ]; then
    echo "✅ Database restore test passed"
    rm $TEST_DIR/test-restore.sql
else
    echo "❌ Database restore test failed"
fi

# Test Restic restore
echo "Testing Restic restore..."
restic restore latest --target $TEST_DIR --dry-run --repo /backup/restic > /dev/null 2>&1
if [ $? -eq 0 ]; then
    echo "✅ Restic restore test passed"
else
    echo "❌ Restic restore test failed"
fi

# Clean up
rm -rf $TEST_DIR

echo "Backup test completed at $(date)"

Common Backup Mistakes

❌ Don’t Do These

# 1. Only keeping one backup
# Bad: Only latest backup
backup.sh  # Overwrites previous

# Good: Keep multiple versions
backup-$(date +%Y%m%d).tar.gz

# 2. Not testing restores
# Bad: Backup runs but never tested
# Test quarterly!

# 3. Storing backups on same device
# Bad: /backup on same server
# Good: External drive or cloud

# 4. No encryption
# Bad: Sensitive data in plain text
# Good: Encrypt backups

# 5. Not monitoring backups
# Bad: Backups fail silently
# Good: Monitor and alert

# 6. Forgetting application-specific data
# Bad: Only backing up files
# Good: Also backup databases, configurations

Quick Reference

Essential Backup Commands

# Rsync local
rsync -avh /source /dest

# Rsync remote
rsync -avzh -e ssh /source user@remote:/dest

# Borg create
borg create --stats /repo::backup /source

# Borg list
borg list /repo

# Borg extract
borg extract /repo::backup

# Restic backup
restic backup /source --repo /repo

# Restic snapshots
restic snapshots --repo /repo

# Restic restore
restic restore latest --target /dest --repo /repo

# Duplicati
# Open http://server:8200

# Docker volume backup
docker run --rm -v volume:/volume -v /backup:/backup alpine tar -czf /backup/volume.tar.gz -C /volume .

Backup Schedule Template

# Cron schedule for backups
# ┌───────────── minute (0 - 59)
# │ ┌───────────── hour (0 - 23)
# │ │ ┌───────────── day of month (1 - 31)
# │ │ │ ┌───────────── month (1 - 12)
# │ │ │ │ ┌───────────── day of week (0 - 6) (Sunday=0)
# │ │ │ │ │
# │ │ │ │ │

# Daily backup (2:00 AM)
0 2 * * * /path/to/backup.sh

# Weekly full backup (3:00 AM Sunday)
0 3 * * 0 /path/to/full-backup.sh

# Monthly off-site backup (4:00 AM 1st)
0 4 1 * * /path/to/offsite-backup.sh

# Backup verification (5:00 AM daily)
0 5 * * * /path/to/verify-backup.sh

# Clean up old backups (6:00 AM daily)
0 6 * * * find /backup -name "*.tar.gz" -mtime +30 -delete

Conclusion

Backups are the most important thing you can do for your self-hosted server. A good backup strategy protects you from data loss, hardware failure, and disasters.

Key Takeaways:

• Follow the 3-2-1 backup rule
• Use multiple backup methods
• Automate your backups
• Test your restores regularly
• Monitor backup health
• Keep backups encrypted
• Store backups off-site

Your Next Steps:

1. Identify what needs backing up
2. Choose a backup tool (start with rsync)
3. Set up local backup
4. Add cloud backup
5. Create automated schedule
6. Test restore process
7. Set up monitoring

Ready to protect your data? Explore our Complete Server Security Guide for more protection strategies.

Frequently Asked Questions (FAQs)

Q: How often should I backup? A: Daily for important data, weekly for full system, and before any major changes.

Q: How many backup copies should I keep? A: Follow 3-2-1 rule. Keep at least 3 copies with 2 different storage types and 1 off-site.

Q: How much storage do I need for backups? A: At least 2x your current data size. More if keeping historical versions.

Q: Should I backup Docker containers? A: Backup volumes and configurations. Containers themselves can be recreated from Dockerfiles.

Q: How long should I keep old backups? A: Keep daily for 7 days, weekly for 1 month, monthly for 6 months, yearly for longer.

Q: Can I backup running databases? A: Yes, use tools like mysqldump for MySQL or pg_dump for PostgreSQL that work while databases are running.

Q: Is cloud backup safe? A: Yes, if encrypted. Most backup tools offer encryption. Also ensure you trust the cloud provider.

Q: What if I can’t afford cloud backup? A: Use a second drive, external hard drive, or backup to a friend’s location. Something is better than nothing.