academic_project_tracker

💾 Backup & Data Management Guide

Protect your research data with proper backups. This guide covers backup strategies, data export, and recovery procedures.

Quick Backup

The fastest way to backup your data:

# Automatic backup with timestamp
npm run backup

# Manual copy
cp src/backend/data/tracker.db backups/tracker-$(date +%Y%m%d).db

Your data is backed up! The database file contains everything: projects, tasks, goals, tags, and settings.

Understanding Your Data

What Gets Stored

All your research data is stored in a single SQLite database file:

Location: src/backend/data/tracker.db

Contents:

All projects and their metadata
All tasks and checklists
Tags and categories
Goals (monthly, semester, custom)
Deadline information
Whiteboard notes
User preferences
Activity history

File Size: Typically 1-5 MB (even with hundreds of tasks)

What Doesn’t Get Stored

External linked documents (Google Docs, Overleaf, etc.)
Uploaded images or files (if you add this feature)
System logs (stored separately in logs/)

Backup Strategies

Strategy 1: Manual Backup (Recommended for Beginners)

Weekly Manual Backup:

# Create a backups folder
mkdir -p backups

# Copy database with date
cp src/backend/data/tracker.db backups/tracker-$(date +%Y%m%d).db

Pro: Simple, full control Con: Easy to forget

Best For: Getting started, infrequent users

Strategy 2: Automated Backup Script (Recommended for Most Users)

Setup Automatic Backups:

Create backup.sh in project root:

#!/bin/bash

# Create backup directory if it doesn't exist
mkdir -p backups

# Backup with timestamp
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
cp src/backend/data/tracker.db "backups/tracker-${TIMESTAMP}.db"

# Keep only last 30 backups
ls -t backups/tracker-*.db | tail -n +31 | xargs -r rm

echo "Backup created: tracker-${TIMESTAMP}.db"
echo "Total backups: $(ls backups/tracker-*.db | wc -l)"

Make it executable:

chmod +x backup.sh

Run it:

./backup.sh

Automate Daily:

macOS/Linux (cron):

# Edit crontab
crontab -e

# Add daily backup at 11 PM
0 23 * * * cd /path/to/project_tracker && ./backup.sh

Windows (Task Scheduler):

Open Task Scheduler
Create Basic Task
Trigger: Daily at 11 PM
Action: Start Program → bash backup.sh

Pro: Automatic, version history Con: Requires initial setup

Best For: Regular users, important research data

Strategy 3: Cloud Sync (Recommended for Maximum Safety)

Store your database in a cloud-synced folder:

Dropbox/Google Drive/OneDrive:

Option A: Symlink the Database

# Move database to Dropbox
mv src/backend/data/tracker.db ~/Dropbox/ResearchTracker/tracker.db

# Create symlink
ln -s ~/Dropbox/ResearchTracker/tracker.db src/backend/data/tracker.db

Option B: Change Database Path Create .env file:

DATABASE_PATH=/Users/yourname/Dropbox/ResearchTracker/tracker.db

Pro: Automatic sync, accessible from multiple devices Con: Sync conflicts possible with simultaneous access

Best For: Users who switch between computers, want cloud backup

⚠️ Warning: Don’t run the app on multiple devices simultaneously with cloud sync. SQLite doesn’t support concurrent access across machines.

Strategy 4: Git Version Control (Advanced)

Track your database with Git:

# Initialize git in data folder
cd src/backend/data
git init

# Add database
git add tracker.db

# Commit changes
git commit -m "Initial database state"

# Daily commits
git add tracker.db
git commit -m "Daily backup - $(date +%Y-%m-%d)"

# Push to private GitHub repo
git remote add origin git@github.com:yourusername/research-tracker-data.git
git push origin main

Pro: Full version history, can revert to any point Con: Not ideal for binary files, requires Git knowledge

Best For: Power users, those already using Git

Backup Schedule Recommendations

By User Type

Graduate Student (High Stakes):

Daily automated backups
Weekly cloud upload
Monthly archive to external drive

Researcher (Medium Stakes):

Daily automated backups
Cloud sync
Quarterly external backup

Casual User (Low Stakes):

Weekly manual backups
Monthly cloud upload

Before Critical Events

Always backup before:

Major software updates
Database migrations
Bulk data imports
System upgrades
Long periods offline

# Pre-event backup
cp src/backend/data/tracker.db backups/tracker-before-update-$(date +%Y%m%d).db

Restoring from Backup

Full Restore

Replace current database with backup:

# CAUTION: This deletes current data!
# Stop the app first
cp backups/tracker-20260107.db src/backend/data/tracker.db

# Restart app
npm run dev

Restore Specific Items

Use SQLite to extract specific data:

# Install SQLite tools
# macOS: brew install sqlite
# Ubuntu: sudo apt-get install sqlite3

# Open backup
sqlite3 backups/tracker-20260107.db

# List tables
.tables

# Export specific project
.mode insert projects
.output restored-projects.sql
SELECT * FROM projects WHERE name LIKE '%Dissertation%';
.quit

# Import to current database
sqlite3 src/backend/data/tracker.db < restored-projects.sql

Data Export

Export to CSV

Export Projects:

sqlite3 src/backend/data/tracker.db -csv -header "SELECT * FROM projects" > projects.csv

Export Tasks:

sqlite3 src/backend/data/tracker.db -csv -header "SELECT * FROM tasks" > tasks.csv

Export Everything:

# Create exports folder
mkdir -p exports

# Export all tables
for table in $(sqlite3 src/backend/data/tracker.db "SELECT name FROM sqlite_master WHERE type='table'"); do
    sqlite3 src/backend/data/tracker.db -csv -header "SELECT * FROM $table" > "exports/${table}.csv"
done

Export to JSON

# Install jq if needed
# macOS: brew install jq
# Ubuntu: sudo apt-get install jq

# Export tasks to JSON
echo "[" > tasks.json
sqlite3 src/backend/data/tracker.db -json "SELECT * FROM tasks" >> tasks.json
echo "]" >> tasks.json

Export for Other Tools

Export for Excel:

Use CSV export (above)
Open in Excel/Google Sheets

Export for Notion:

Export to CSV
Import CSV to Notion database

Export for Trello:

Use JSON export
Convert format for Trello import

Data Import

Import from Backup

# Full restore
cp backups/tracker-20260107.db src/backend/data/tracker.db

Import from CSV

# Import tasks from CSV
sqlite3 src/backend/data/tracker.db

.mode csv
.import tasks.csv tasks

Merge Two Databases

# Attach second database
sqlite3 src/backend/data/tracker.db

ATTACH 'backups/old-tracker.db' AS old;

# Copy specific projects
INSERT INTO projects SELECT * FROM old.projects WHERE id > 100;

# Copy related tasks
INSERT INTO tasks SELECT * FROM old.tasks WHERE project_id > 100;

DETACH old;
.quit

Backup Verification

Test Your Backups

Monthly Backup Test:

Copy backup to temporary location
Start app with test database
Verify data loads correctly
Check a few projects and tasks
Delete test copy

# Test restore
cp backups/tracker-latest.db /tmp/test-tracker.db
DATABASE_PATH=/tmp/test-tracker.db npm run dev

# Check in browser, then stop and clean up
rm /tmp/test-tracker.db

Backup Integrity Check

# Check database integrity
sqlite3 src/backend/data/tracker.db "PRAGMA integrity_check;"

# Should output: ok

Storage Management

Clean Up Old Backups

Keep Last 30 Days:

# Remove backups older than 30 days
find backups/ -name "tracker-*.db" -mtime +30 -delete

Keep Weekly Backups:

# Keep one backup per week
# Archive first backup of each week to long-term storage
ls backups/tracker-2026* | head -n 1 | xargs -I {} cp {} archives/

Compress Old Backups

# Compress backups older than 3 months
find backups/ -name "tracker-*.db" -mtime +90 -exec gzip {} \;

# Decompress if needed
gunzip backups/tracker-20251001.db.gz

Estimate Storage Needs

# Check current database size
du -h src/backend/data/tracker.db

# Estimate yearly storage
# Typical: 2MB database × 365 daily backups = ~730MB/year
# With monthly cleanup: ~60MB/year

Cloud Backup Services

Recommended Services

Dropbox:

Pro: Easy setup, good sync
Con: Limited free space (2GB)

Google Drive:

Pro: 15GB free, Google integration
Con: Sync client required

OneDrive:

Pro: Microsoft integration
Con: Slower sync

iCloud (macOS):

Pro: Native integration
Con: macOS only

GitHub Private Repo:

Pro: Free unlimited private repos
Con: Not ideal for binary files

Backblaze B2:

Pro: Very cheap (~$0.005/GB)
Con: Requires API setup

Setup Cloud Backup

Example: Dropbox

# 1. Install Dropbox
# 2. Create folder
mkdir ~/Dropbox/ResearchTrackerBackups

# 3. Add to backup script
cp src/backend/data/tracker.db ~/Dropbox/ResearchTrackerBackups/tracker-$(date +%Y%m%d).db

Disaster Recovery Plan

Full System Failure

If your computer dies:

Get new computer
Install Node.js
Clone or download project
Copy database from cloud backup
Place in src/backend/data/
Run npm install and npm run dev
All your data is back!

Corrupted Database

If database becomes corrupted:

# Try to repair
sqlite3 src/backend/data/tracker.db "PRAGMA integrity_check;"

# If repair fails, restore from backup
cp backups/tracker-latest.db src/backend/data/tracker.db

Accidental Deletion

If you delete important data:

Stop using the app immediately
Restore from most recent backup
Extract deleted data if available
Merge with current database

Best Practices Summary

Do’s ✅

✅ Backup daily (automated)
✅ Test backups monthly
✅ Store backups in cloud
✅ Keep multiple versions
✅ Verify integrity periodically
✅ Backup before major changes
✅ Document restore procedures
✅ Keep backups in multiple locations

Don’ts ❌

❌ Rely on a single backup location
❌ Never test your backups
❌ Keep backups on same drive only
❌ Forget to backup before updates
❌ Run simultaneous instances with cloud sync
❌ Ignore database corruption warnings
❌ Delete old backups too aggressively

Backup Checklist

Initial Setup (Do Once):

Daily (Automated):

Automated backup runs
Cloud sync (if configured)

Weekly (5 minutes):

Verify backups exist
Check backup file sizes
Clean up old backups

Monthly (15 minutes):

Test restore from backup
Archive old backups to external drive
Verify cloud backup integrity
Review storage usage

Quarterly (30 minutes):

Full system test with backup
Update disaster recovery plan
Export data to CSV/JSON
Review and update backup strategy

Advanced Topics

Encrypted Backups

# Encrypt backup with GPG
gpg --symmetric --cipher-algo AES256 src/backend/data/tracker.db

# Creates: tracker.db.gpg

# Decrypt
gpg tracker.db.gpg

Differential Backups

# Only backup if database changed
if ! cmp -s src/backend/data/tracker.db backups/tracker-latest.db; then
    cp src/backend/data/tracker.db backups/tracker-$(date +%Y%m%d).db
fi

Remote Server Backup

# Backup to remote server via SSH
scp src/backend/data/tracker.db user@server:/backups/tracker-$(date +%Y%m%d).db

# Or use rsync
rsync -avz src/backend/data/tracker.db user@server:/backups/

Need Help?

Restore Issues: See TROUBLESHOOTING.md
Technical Questions: Check FAQ.md
Lost Data: Open an issue with details

Remember: Your research data is valuable. Back it up regularly! 💾

This site is open source. Improve this page.