The Single Point of Failure Illusion

We need to talk about what "archiving" actually means. A terrifying number of facilities think of an archive as simply the destination at the end of a project. You finish cutting a feature, you package up the assets, and you dump them onto a spinning hard drive on a shelf, or a single LTO tape in a vault. Problem solved, right?

Wrong. If your data exists in exactly one place, you do not have an archive. You have a ticking time bomb.

What you believe

The archive is permanent

Once data is written to a tape or an S3 bucket, it is safely "put away." You don't have to worry about it anymore because enterprise storage media is designed to last.

What is actually true

All media is mortal

Hard drives suffer bit rot. Tapes get dropped, snapped, or degaussed. Cloud providers suffer localized outages, billing glitches, or go out of business. A single copy is always a single point of failure.

Redundancy is the only permanent solution. That doesn't just mean backing up your active work — it means backing up your archive, too. A true archiving system must guarantee that cold data is securely duplicated before it ever allows the original high-speed copy to be deleted.

N-Way Replication: What It Actually Means

You’ve probably heard of the 3-2-1 backup rule: three copies of your data, on two different media types, with one offsite. It is the gold standard for active production data. But when dealing with petabytes of cold archive data, maintaining three distinct copies gets expensive and architecturally complex.

This is where N-Way Replication comes in. Instead of relying on a human to manually clone drives or a rigid enterprise appliance that only speaks to proprietary tape libraries, HuskHoard lets you define N destinations for any given tiering policy. When a file gets cold, HuskHoard doesn’t just move it. It fans it out.

If you set N=2, HuskHoard writes a copy to your local bulk storage array and a copy to a cloud bucket. If you set N=3, it might write to a local tape, an offsite tape, and a glacier tier simultaneously. You define the N, and the daemon handles the plumbing.

The Media Diversity Rule

Why not just replicate to three hard drives and call it a day? Because identical media types share identical failure domains. If a power surge fries your NAS, it fries all the disks in it. This is why HuskHoard is built to span fundamentally different storage architectures.

01 — LTO Tape
The Physical Air-Gap
Tape is incredibly cheap per gigabyte and boasts extreme longevity (30+ years). More importantly, an ejected tape is physically disconnected from the network. No ransomware script or rogue admin can delete a cartridge sitting on a shelf.
02 — Bulk Disk (HDD)
Immediate Access
Spinning rust is cheaper than NVMe but faster to access than tape or cloud. Keeping a replica on a local ZFS or RAID array means when a user clicks a cold file, it loads instantly without fetching a tape or paying a cloud egress fee.
03 — Cloud (S3/Glacier)
Geographic Separation
The cloud eliminates physical risks like fire, flood, or theft at your local facility. Pushing a replica to a cheap tier like AWS Glacier Deep Archive or Backblaze B2 ensures your data survives even if your building doesn't.
04 — WORM Media
Legal Immutability
Write Once, Read Many (WORM) targets guarantee that a record cannot be altered or deleted once written. Using a WORM tape or an S3 Object Lock bucket as one of your replicas provides a mathematically verifiable audit trail.

How HuskHoard Replicates Under the Hood

In traditional setups, moving data to three different places requires a patchwork of rsync scripts, LTFS mounting utilities, and cloud CLI tools. HuskHoard abstracts all of this into a single atomic operation defined by a simple TOML policy.

# husk-policies.toml — N-way replication policy [[policy]] name = "mission-critical" watch = "/archive/projects" action = "migrate" after-days = 45 # Trigger after 45 days of inactivity # Replica 1: Keep a fast copy on local bulk HDDs [[policy.replica]] target = "cold-storage-nas" type = "disk" required = true # Replica 2: Write an air-gapped copy to LTO-9 [[policy.replica]] target = "lto-9-pool" type = "tape" required = true # Replica 3: Send an offsite copy to the cloud [[policy.replica]] target = "s3-deep-archive" type = "cloud" required = false # Will retry later if network is down

When this policy executes, HuskHoard doesn't just copy the file sequentially. It leverages Rust's asynchronous I/O to perform the entire operation in parallel, ensuring the highest possible throughput while strictly verifying data integrity.

01
File is marked cold
The policy engine identifies a file that hasn't been modified or read in 45 days.
02
Chunking & Checksumming
HuskHoard reads the file from the NVMe drive, breaking it into chunks and generating a cryptographically secure SHA-256 hash.
03
Concurrent N-Way Dispatch
The data streams are dispatched simultaneously to the Disk NAS, the local Tape drive, and the S3 bucket.
04
Confirmation & Stub Replacement
Only when all required replicas report a successful write and matching checksum does HuskHoard delete the local file and drop a metadata stub in its place.
Safety First

If the tape drive is busy or the network connection to S3 drops halfway through the dispatch, HuskHoard simply aborts the migration for that file. The original file stays intact on your fast storage. It will try again during the next policy run. Data is never deleted until redundancy is mathematically proven.

Reading from Replicas: The Fallback Mechanism

We know that HuskHoard uses fanotify to intercept read requests to stub files. But if a file has three replicas, which one does it pull from when a user double-clicks it?

The answer is a latency-aware decision engine built into the HuskHoard daemon. It evaluates the available replicas and automatically selects the path of least resistance, keeping your applications running smoothly without any user intervention.

1
Application Request
User tries to open the archived file. Kernel pauses via fanotify.
user space
2
Decision Engine
HuskHoard checks the Catalog, finds 3 replicas, and ranks them by latency.
router
3
Attempt 1: Local Disk
HuskHoard tries the NAS replica first (fastest). If the NAS is down, it moves to Attempt 2.
fallback
4
Attempt 2: Cloud
It requests the file from S3. If the internet is down, it moves to Attempt 3.
fallback
5
Attempt 3: Tape
As a last resort, it prompts the user to insert the LTO cartridge.
fallback

This fallback mechanism means you can lose your entire local backup array, and your users won't even notice. The next time they try to open an archived project, it might take a few seconds longer to buffer from S3, but the file will open. The path is still valid. The application has no idea that the local disk array is currently on fire.

The Catalog Knows All

Tracking identical chunks of data across completely disparate media types is complex. LTFS indexes only know about the tape they are written on. AWS dashboards only know about what is in the bucket. The Husk Catalog is the centralized ground truth that unifies them.

Because the catalog lives on your host machine and tracks the metadata of every single replica independently, you can verify your redundancy at a glance.

/archive/projects/2026/project_omega_master.mxf
142.1 GB · replicated 3-ways
online · disk-pool

online · s3-glacier

offline · vol 44b1c9f2

You can even ask HuskHoard to proactively verify the integrity of your replicas without pulling the whole file down, by comparing the recorded checksums against the live media.

# Verify all replicas of a specific stub $ husk verify --path /archive/projects/2026/project_omega_master.mxf Verifying 3 replicas for project_omega_master.mxf... ✓ Replica 1 (Disk: cold-storage-nas) — checksum OK (0.8s) ✓ Replica 2 (Cloud: s3-glacier) — checksum OK (API verified) ⚠ Replica 3 (Tape: vol 44b1c9f2) — OFFLINE (Skipped, use --prompt-tape) Status: Healthy (2/3 online)

By treating the filesystem path as merely a pointer to a catalog entry, and treating that catalog entry as a list of potential physical locations, HuskHoard frees your data from the fragility of any single piece of hardware. N-way replication isn't just a backup strategy — it is the only way to build an archive that outlives you.