Free tool · works now

Export manifest generator

Generate stable backup manifests, cryptographic checksum files, and verification scripts for note archives.

Vault Backup Manifest Generator

Structure a permanent verification ledger with SHA-256 hashes, file sizes, format categorizations, and automated check scripts.

Zero Cloud TelemetryCryptographic IntegrityCross-Platform Scripts
Critical Distinction Notice: A manifest is a cryptographic and structural verification index. It is NOT itself a backup and contains no file contents. To protect your data, you must copy your actual physical files to an independent storage drive alongside this manifest file.
Name of this specific backup volume or export archive.
Physical drive or cold storage location holding the archive.
Paste relative file paths, CSV rows (path, size, hash), or output from `shasum -a 256 *`.
Recorded Files8
Total Stated Size1.3 MB
Hashes Recorded8
Missing Hashes0
BACKUP-MANIFEST.md
# Export Backup Manifest: Knowledge-Vault-Cold-Archive-2026

> **Created Date:** 2026-11-19  
> **Storage Target:** External Samsung T7 NVMe SSD (Encrypted APFS)  
> **Status:** Verification Index  
> **Mandatory Notice:** CRITICAL NOTICE: This manifest is a cryptographic and structural verification index. It is NOT itself a backup and contains NO file contents. To ensure data safety, you must copy your actual physical files to an independent external drive, cold storage volume, or secondary device alongside this manifest.

## Archive Summary

- **Total Files Recorded:** 8
- **Aggregate Stated Size:** 1.3 MB
- **Markdown Notes:** 4
- **Attachments (Images/PDFs):** 2
- **Data & Configuration Files:** 2
- **Cryptographic Hashes Provided:** 8 / 8

## File Inventory & Checksums

| Relative Path | Category | Size | SHA-256 Hash |
| :--- | :--- | :--- | :--- |
| `.obsidian/app.json` | data-csv-json | 580 B | `18293a4b5c6d…` |
| `00-Dashboard.md` | markdown-prose | 1.4 KB | `a1b2c3d4e5f6…` |
| `01-Projects/Project-Alpha.md` | markdown-prose | 4.7 KB | `b2c3d4e5f607…` |
| `01-Projects/Project-Beta.md` | markdown-prose | 3.0 KB | `c3d4e5f60718…` |
| `02-Areas/Architecture-Notes.md` | markdown-prose | 8.7 KB | `d4e5f6071829…` |
| `assets/database-schema.pdf` | document-pdf | 874.4 KB | `f60718293a4b…` |
| `assets/system-diagram.png` | image-attachment | 403.2 KB | `e5f60718293a…` |
| `data/metrics-export.csv` | data-csv-json | 44.1 KB | `0718293a4b5c…` |

## How to Verify This Backup Later

### macOS / Linux Verification
```bash
# 1. Navigate to the root directory of your unpacked backup volume
cd /path/to/unpacked-backup

# 2. Verify all checksums against the manifest
shasum -a 256 -c manifest.sha256
```

### Windows PowerShell Verification
```powershell
# Verify files against recorded hashes
Get-FileHash -Algorithm SHA256 (Get-ChildItem -Recurse -File) | Select-Object Path, Hash
```

The Architecture of Cold Storage: Why Unverified Backups Are Mere Wishes

In computing, an axiom holds true across decades: a backup that has never been verified is not a backup; it is merely an unverified hope. Users frequently drag their notes directory to an external USB stick, store a zip archive in cloud storage, and assume their intellectual property is secure.

Three or four years later, disaster strikes: a main laptop drive suffers hardware failure, a cloud provider locks an account, or a database sync error truncates notes. The user plugs in the backup drive only to discover that critical media folders failed to copy, file names with non-Latin characters became silently corrupted, or hardware bit rot altered essential records. Without an authoritative, independent ledger generated at the time of archive creation, it is mathematically impossible to know whether an unpacked archive is intact or degraded.

The Export Manifest Generator solves this existential data vulnerability. By producing canonical, human-readable markdown manifests, cryptographic SHA-256 checksum catalogs, and automated verification scripts, this tool provides the mathematical proof required to confirm that an archive remains 100% byte-for-byte identical to the original vault.

1. The Non-Backup Mandate: Understanding the Boundary Between Index and Content

A common point of confusion among non-technical users is conflating a backup manifest with an actual backup archive. A manifest is an index—a structured ledger recording file paths, byte sizes, categories, and cryptographic hashes. Storing the manifest alone saves none of your actual prose or drawings.

Our engine operates under an explicit non-backup disclosure mandate. It never pretends to be an archive tool or data duplicator. It creates the permanent verification ledger that must be deposited alongside your actual copied files on an independent physical drive. By clearly maintaining this boundary, you are reminded to execute the physical copy operation.

2. The Cryptographic Standard: Why SHA-256 Outperforms Timestamps and File Sizes

Traditional file comparison relies on file size and operating system modification dates. However, both metrics are notoriously fragile:

3. The 3-2-1 Cold Storage Protocol for Note Vaults

For maximum data longevity, professional archival standards recommend the 3-2-1 backup protocol:

  1. Three Copies of Data: Maintain your active working vault, a primary local snapshot on an external drive, and a secondary cold storage volume stored off-site.
  2. Two Different Media Types: Do not rely exclusively on one storage brand or drive type. Combine internal NVMe storage with an external solid-state drive or archival optical media.
  3. One Off-Site or Air-Gapped Volume: Keep one copy completely disconnected from all power and network access. An air-gapped drive is completely immune to ransomware, accidental automated deletions, and cloud synchronization conflicts.

4. Verification Workflow: Validating Your Archive in Ten Seconds

When unpacking a cold archive after years in storage, verification is instantaneous with standard operating system utilities:

On macOS and Linux, navigate to the backup root directory in your terminal and execute:

shasum -a 256 -c manifest.sha256

The operating system recalculates the SHA-256 hash for every file on disk and compares it to the recorded value in the manifest. If every file outputs OK, you have mathematically verified that not a single byte has shifted.

5. Comparative Ledger Architecture: Manifest vs. Unindexed Folder

Integrity CharacteristicUnindexed Drag-and-Drop FolderCryptographic Manifest Archive
Completeness VerificationManual guessing based on rough folder countsExact count of all files and stated byte sizes
Silent Corruption DetectionImpossible (bit flips go completely unnoticed)100% detectable via SHA-256 mismatch flags
Cross-Platform PortabilitySubject to filesystem timestamp shiftsNormalized relative paths sorted alphabetically
Format CategorizationRaw unstructured file dumpClassified into prose, media, data, and metadata
Longevity HorizonFragile (breaks on silent data degradation)Durable for decades across all operating systems

Complement your vault preservation strategy with our suite of data durability tools: inspect your vault dependence with the Offline Note Portability Checklist, establish safe routine maintenance with the Note Maintenance Checklist Builder, generate high-level vault audits with the Note Inventory Generator, and compare round-trip archive exports with the Export Round-Trip Comparator.

Questions

Why is a manifest not considered a backup by itself?

A manifest is a cryptographic and structural ledger recording relative file paths, byte sizes, and SHA-256 hashes. It contains metadata about your files, not the actual contents. A real backup requires copying your actual physical notes and attachment assets to an independent storage device alongside this manifest.

How does a SHA-256 checksum verify archive integrity years later?

A SHA-256 hash is a cryptographic fingerprint computed from every single byte of a file. If even a single character or bit decays due to drive corruption ("bit rot") or file tampering, re-calculating the hash produces a completely different value, instantly flagging the compromised file.

How can I generate the initial list of files and hashes from my local machine?

On macOS or Linux, you can run `find . -type f -exec shasum -a 256 {} +` inside your vault directory, or `find . -type f` for simple paths. On Windows, you can use PowerShell: `Get-ChildItem -Recurse -File | Get-FileHash -Algorithm SHA256`. Paste the output directly into this workbench.

Does this generator transmit my vault file list or hashes over the internet?

No. The manifest generator and parsing engine execute 100% locally within your browser sandbox. Zero file lists, paths, or checksums are sent to any remote server.

Why should I store the manifest inside the backup folder itself?

Storing BACKUP-MANIFEST.md and manifest.sha256 directly alongside the backed-up files ensures that anyone unpacking the archive five or ten years from now has the exact verification instructions and reference checksums ready to run immediately.

Preserve Your Thinking Permanently with Oyma

Your notes are your intellectual legacy. Store your writing in clean, sovereign Markdown on your personal drive and verify archive integrity with mathematical certainty.

export manifest generator downloadDownload for Mac

No account needed. Intel Mac build