Introduction
Losing client files, invoices, or project data is a freelancer’s nightmare. Automated backups ensure you never lose work — even if your laptop dies, gets stolen, or is hit by ransomware.
This post covers free and paid backup strategies that actually work.
The 3-2-1 backup rule
The gold standard for backups:
- 3 copies of your data
- 2 different storage types (local + cloud)
- 1 offsite copy (different location)
Example: Original files on laptop + backup on external drive + backup in cloud.
Option 1: Cloud sync (easiest, free)
Google Drive / Dropbox / OneDrive
- Install the desktop app
- Select folders to sync
- Files are automatically uploaded to the cloud
Pros: Free (15GB Google Drive, 2GB Dropbox, 5GB OneDrive), automatic, accessible from anywhere Cons: Syncs deletions too (if you delete a file, it’s deleted from cloud). Not a true backup.
Fix: Use version history (Google Drive keeps 30 days of versions).
Setup
- Download Google Drive desktop app
- Sign in with your Google account
- Choose folders to sync (Documents, Desktop, etc.)
- Files sync automatically in the background
Option 2: Automated backup with Python
import shutil, os, zipfile
from datetime import datetime
import schedule, time
SOURCE_DIR = "/path/to/your/files"
BACKUP_DIR = "/path/to/backup/location"
CLOUD_DIR = "/path/to/cloud/sync/folder" # e.g., Google Drive folder
def create_backup():
"""Create a timestamped backup zip."""
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
backup_name = f"backup_{timestamp}.zip"
backup_path = os.path.join(BACKUP_DIR, backup_name)
with zipfile.ZipFile(backup_path, "w", zipfile.ZIP_DEFLATED) as zipf:
for root, dirs, files in os.walk(SOURCE_DIR):
for file in files:
file_path = os.path.join(root, file)
arcname = os.path.relpath(file_path, SOURCE_DIR)
zipf.write(file_path, arcname)
print(f"Backup created: {backup_path} ({os.path.getsize(backup_path) / 1024 / 1024:.1f} MB)")
# Copy to cloud sync folder
shutil.copy2(backup_path, os.path.join(CLOUD_DIR, backup_name))
print(f"Copied to cloud: {CLOUD_DIR}/{backup_name}")
# Clean up old backups (keep last 7 days)
cleanup_old_backups(BACKUP_DIR, days=7)
def cleanup_old_backups(directory, days=7):
"""Delete backups older than 'days' days."""
cutoff = datetime.now().timestamp() - (days * 86400)
for f in os.listdir(directory):
if f.startswith("backup_") and f.endswith(".zip"):
path = os.path.join(directory, f)
if os.path.getmtime(path) < cutoff:
os.remove(path)
print(f"Deleted old backup: {f}")
# Schedule: run daily at 2 AM
schedule.every().day.at("02:00").do(create_backup)
print("Backup scheduler started. Running daily at 2 AM.")
while True:
schedule.run_pending()
time.sleep(60)
Option 3: Cloud backup services (paid, automatic)
| Service | Price | Storage | Best for |
|---|---|---|---|
| Backblaze | $7/mo | Unlimited | Full computer backup |
| iDrive | $80/year | 5TB | Multiple devices |
| Carbonite | $72/year | Unlimited | Simple, automatic |
| Google Drive (paid) | $2/mo (100GB) | 100GB-2TB | Already using Google |
| Dropbox (paid) | $12/mo (2TB) | 2TB | Already using Dropbox |
Recommendation: Backblaze ($7/mo, unlimited) for full computer backup. Google Drive (free tier) for important documents.
Option 4: Git for code projects
For code, use Git + GitHub/GitLab:
# Initialize git in your project
git init
git add .
git commit -m "Initial commit"
# Push to GitHub (free private repos)
git remote add origin https://github.com/yourname/project.git
git push -u origin main
Benefits: Version history, rollback, collaboration, free. Limitation: Only for code/text files (not large binaries).
Backup strategy by file type
| File type | Backup method | Frequency |
|---|---|---|
| Code/projects | Git + GitHub | Every commit |
| Client files | Cloud sync (Google Drive) | Real-time |
| Invoices/financial | Cloud sync + local backup | Daily |
| Database (SQLite) | Automated backup script | Daily |
| Design files (Figma, PSD) | Cloud sync | Real-time |
| Passwords | Password manager (encrypted) | Automatic |
The disaster recovery plan
If everything fails, you need a recovery plan:
- What to recover first: Client deliverables, invoices, contracts
- Where to recover from: Cloud backup (Google Drive, Backblaze)
- How long it takes: 1-4 hours to restore from cloud
- Who to contact: Cloud provider support, IT professional
Test your backup: Restore a file from backup monthly to ensure it works. A backup you can’t restore is useless.
Common mistakes
- No backup at all — “It won’t happen to me” (until it does)
- Only one copy — if your laptop dies and your backup is on the same laptop, you’ve lost everything
- Not testing restores — a backup you can’t restore is useless
- Backing up everything — backing up 500GB of movies wastes space. Back up work files only.
- No offsite copy — a fire or theft takes your laptop AND your external drive
- Relying only on cloud sync — sync isn’t backup (deletions sync too). Use version history or a separate backup.
Key Concepts
- 3-2-1 rule = 3 copies, 2 types, 1 offsite
- Cloud sync = real-time file synchronization (Google Drive, Dropbox)
- Backup = point-in-time copy (can restore deleted files)
- Version history = previous versions of files (Google Drive keeps 30 days)
- Disaster recovery = plan for restoring data after a failure
- Cron job = scheduled task that runs automatically
What to Try Next
- Organise client projects with a system
- Track domains and hosting for all clients
- Write SOPs for backup procedures
- Build a backup monitoring dashboard in Streamlit
FAQ
Cloud sync vs cloud backup — what’s the difference?
Cloud sync (Google Drive, Dropbox) keeps files in sync across devices. If you delete a file, it’s deleted everywhere. Cloud backup (Backblaze, iDrive) creates point-in-time copies you can restore. Use both: sync for daily access, backup for disaster recovery.
How much storage do I need?
For work files (code, documents, designs): 50-100GB. For media (videos, photos): 500GB-2TB. Most freelancers need 50-200GB. Google Drive’s 15GB free tier covers basic needs; 100GB costs $2/month.
Should I back up to an external drive AND the cloud?
Yes — this follows the 3-2-1 rule. External drive for fast local recovery; cloud for offsite protection. If your house floods, the external drive is gone but the cloud backup survives.
How do I back up a database (SQLite)?
Copy the .db file to your backup location. For automated backups, add it to your backup script: shutil.copy2("app.db", "backup/app_backup.db"). For production databases (Postgres), use pg_dump. See Streamlit + Supabase.