Project: a Snapshot Backup Script

The idea

You’ll build snapshot-backup, a script that copies the folders you care about to a backup drive. Each run makes a new folder named for the date and time, a snapshot, that looks like a complete copy. But it isn’t stored as one: files that haven’t changed since the last snapshot are hard links (module 2) to the copies already on the drive, so each new snapshot takes only the space of what changed ¹.

The trick is one rsync option. rsync copies files efficiently, sending only what’s different ². Its --link-dest=DIR option compares each file with the same file in DIR, and if it’s identical, makes a hard link to it instead of copying ¹.

What you get: browse to any snapshot and every file is there as it was that day; delete an old snapshot and nothing is lost from the others, because a hard-linked file’s data stays until its last name is gone.

The script

#!/bin/bash
#
# snapshot-backup: copy chosen folders to a backup drive as dated snapshots.
# Unchanged files become hard links into the previous snapshot, so every
# snapshot looks complete but only changed files take up new space.
#
# Usage: snapshot-backup [-n] [-k COUNT] DESTINATION
#   -n        dry run: list what would be copied, change nothing
#   -k COUNT  keep this many snapshots (default 14)

set -euo pipefail

readonly SOURCES=("$HOME/Documents" "$HOME/photos" "$HOME/shell-course")

usage() {
    echo "Usage: $(basename "$0") [-n] [-k COUNT] DESTINATION" >&2
    exit 2
}

die() {
    echo "$(basename "$0"): $*" >&2
    exit 1
}

log() {
    echo "$(date '+%F %T') $*"
}

main() {
    local dry_run=false keep=14 opt
    while getopts ":nk:" opt; do
        case "$opt" in
            n) dry_run=true ;;
            k) keep="$OPTARG" ;;
            *) usage ;;
        esac
    done
    shift $((OPTIND - 1))
    [[ $# -eq 1 ]] || usage

    [[ -d "$1" ]] || die "$1 not found. Is the backup drive mounted?"
    local dest
    dest="$(realpath -- "$1")"
    [[ "$keep" =~ ^[1-9][0-9]*$ ]] || die "-k needs a whole number of snapshots"

    local snapshot latest
    snapshot="$dest/$(date +%F_%H%M)"
    latest="$dest/latest"

    local rsync_opts=(-a --delete)
    if [[ -d "$latest" ]]; then
        rsync_opts+=(--link-dest="$latest")
    fi
    if [[ "$dry_run" == true ]]; then
        rsync_opts+=(--dry-run --itemize-changes)
    fi

    local sources=() src
    for src in "${SOURCES[@]}"; do
        if [[ -d "$src" ]]; then
            sources+=("$src")
        else
            log "skipping $src: not found"
        fi
    done
    [[ ${#sources[@]} -gt 0 ]] || die "nothing to back up"

    log "snapshot $snapshot starting"
    rsync "${rsync_opts[@]}" "${sources[@]}" "$snapshot/"

    if [[ "$dry_run" == true ]]; then
        log "dry run finished; nothing was changed"
        return 0
    fi

    ln -sfn "$(basename "$snapshot")" "$latest"

    find "$dest" -mindepth 1 -maxdepth 1 -type d -name '20*' | sort | head -n -"$keep" |
        while read -r old; do
            log "removing old snapshot $old"
            rm -rf -- "$old"
        done

    log "snapshot $snapshot done"
}

main "$@"

Save it as ~/.local/bin/snapshot-backup, run chmod +x on it, and check it with shellcheck; it passes cleanly ³. Change SOURCES to the folders you actually want.

How it works

The layout follows the style guide: comment block with usage, set -euo pipefail, a constant, small helper functions, all the logic in main, and main "$@" at the bottom ⁴. Errors go to stderr with a nonzero status; usage errors exit 2.

Options. getopts ":nk:" accepts -n (dry run) and -k COUNT (how many snapshots to keep). After the loop, exactly one argument must remain: the destination.

Safety checks before anything happens. The destination must exist, so if the backup drive isn’t plugged in, the script stops instead of filling up your main disk. -k must be a positive whole number. realpath turns the destination into an absolute path; that matters because rsync treats a relative --link-dest path as relative to the destination folder, not to where you ran the command ¹. (An early test of this script with snapshot-backup drive failed for exactly that reason.)

Options as an array. rsync_opts starts as -a --delete and grows: --link-dest only if a previous snapshot exists, --dry-run --itemize-changes only for -n. Building options in an array keeps every one a separate, correctly quoted word.

• -a (archive) copies folders recursively and keeps permissions, times, owners, and symbolic links ¹.
• --delete removes files from the destination that no longer exist in the source, so a snapshot matches the source exactly ¹. In a fresh snapshot folder there’s nothing to delete; it’s there so re-running in the same minute stays accurate.
• --dry-run makes rsync go through the motions without changing anything, and --itemize-changes lists each file it would transfer and why ¹.

Sources. Missing folders are skipped with a log line rather than killing the run. The sources are passed without trailing slashes, so each becomes a folder inside the snapshot: snapshot/Documents, snapshot/photos ^{1 2}.

The latest link. After a real run, ln -sfn points the symbolic link latest at the new snapshot. It stores just the folder name, so the link keeps working if the drive is mounted somewhere else next time. The next run uses latest as its --link-dest.

Pruning. Snapshot folders are named like 2026-10-05_0230, so sorting them by name sorts them by date. head -n -"$keep" prints every line except the last keep, which are the newest, and the while loop deletes those older ones.

Test it safely

Never point a new backup script at real data first.

1. Make a test destination in your Linux home and do a dry run:

   me@linuxbox:~$ mkdir -p ~/backup-test
   me@linuxbox:~$ snapshot-backup -n ~/backup-test
   

   rsync lists what it would copy. Nothing is written ¹.

2. Do two real runs a minute or more apart, then compare:

   me@linuxbox:~$ snapshot-backup ~/backup-test
   me@linuxbox:~$ snapshot-backup ~/backup-test
   me@linuxbox:~$ ls -l ~/backup-test
   me@linuxbox:~$ du -sh ~/backup-test/2*
   

   du counts hard-linked data once, the first time it meets it, so the second snapshot shows only a small size even though it looks complete.

3. Check that a file is shared: ls -li ~/backup-test/*/Documents/somefile shows the same inode number in both snapshots, with a link count of 2.

4. Restore a file by copying it back: cp -a ~/backup-test/2026-10-04_0230/Documents/budget.ods ~/Documents/.

A real backup drive

For real backups, use an external drive formatted for Linux (ext4). --link-dest links only files whose permissions and ownership match exactly, and drives formatted for Windows (NTFS, exFAT) or mounted with generic ownership can stop files from linking, so every snapshot becomes a full copy ¹. On a Linux desktop, a plugged-in drive appears under /media/<you>/<drive name>; give it a short label like backup.

Under WSL, your Windows drives appear under /mnt (module 1) ⁵, but they’re Windows file systems, so treat WSL as a place to practice with ~/backup-test. Set up the real thing after you’ve switched.

Run it every night with cron

cron runs commands on a schedule. Edit your own schedule with crontab -e; each line is five time fields and a command ⁶:

# min hour day month weekday  command
30 2 * * * /home/me/.local/bin/snapshot-backup /media/me/backup >> /home/me/backup.log 2>&1

Fields are minute (0-59), hour (0-23), day of month, month, and day of week (0 or 7 is Sunday); * means “every” ⁶. So this runs at 2:30 every morning. Cron runs jobs with a bare environment, little more than SHELL, HOME, and LOGNAME, not your login setup, so use full paths, and send both output streams to a log so you can check on it: tail ~/backup.log ⁶.

One cron trap: a % in a crontab line means “new line” to cron, so a command like date +%F must be written date +\%F there ⁶. Keeping the logic in a script, as here, sidesteps it.

The machine has to be on, and the drive plugged in, at 2:30. If the drive is missing, the script’s first check stops it and the log says why.

Your turn

So

You’ve built a real backup tool from pieces of every module: paths and links, permissions, redirection and pipelines, quoting and arrays, exit statuses, functions and getopts, and set -euo pipefail. rsync’s --link-dest makes daily snapshots cheap, a dry run and a test folder make it safe to try, and cron makes it automatic. That’s the shell course; next come Linux itself and git.