Free tool · works now

Migration preflight workbench

Audit note export fidelity, detect unsupported schemas, and evaluate migration risks before switching note systems.

Pre-Flight Vault & Export Auditor

Inspect source exports against destination vault capabilities. Map fidelity across frontmatter, links, callouts, block transclusions, and queries.

Zero Cloud TelemetryNon-Destructive Read-OnlyEvidence-Backed Matrices
Where was this export generated?
Target application environment
e.g., notion-markdown-v1, obsidian-v1.6, unknown-v9
Descriptive label for audit report
Load Test Fixture:
Length: 660 chars
ElevatedMigration Risk Rating
84%Preservation Readiness
9Lossless (1:1 Native)
0Degraded (Fallback Text)
2At-Risk (Brittle / Broken)
0Dropped (Lost Structure)
0Uncertain (Unverified)

Preservation Matrix

Fidelity outcomes mapped per detected syntax feature
CategoryFeature NameCountPreservation TierDestination OutcomeRemediation Advice
metadataYAML Frontmatter Block1LOSSLESSParsed natively as note metadata and properties panel.Ensure property keys contain valid alphanumeric identifier characters.
linksInternal Wikilinks [[Page]]3LOSSLESSResolved directly in graph index and note link cache.No conversion required.
linksNotion 32-Character Hex UUIDs2AT-RISKUgly filenames with brittle link references that break if renamed.Run pre-flight rename script to strip 32-hex suffixes while updating internal reference links.
databasesDataview / Dynamic Query Blocks1LOSSLESSExecutes dynamically when Dataview community plugin is installed.Ensure community plugins are enabled in target vault.
attachmentsInternal Media Embeds ![[file]]1LOSSLESSResolved via vault attachment search folder.Ensure asset files are copied to the designated attachment directory.
linksInfinite Canvas References (*.canvas)1LOSSLESSOpens native Obsidian JSON canvas board.Ensure .canvas JSON files are copied alongside Markdown files.
formattingInteractive Checkboxes (- [ ])2LOSSLESSSupported natively across all modern Markdown environments.Standard - [ ] syntax is universally portable.
Formula-guarded spreadsheet CSV · UTF-8 formatted Markdown · Safe non-destructive diagnostic bash script.

Preflight Diagnostic Report Preview

Copyable Markdown summary for team issue trackers and migration pull requests
# Migration Preflight Audit Report

*Generated on 2026-11-19 for vault: **Engineering-RFC-Archive***
*Source: **notion** (notion-markdown-v1) → Destination: **obsidian***

## Summary Assessment
- **Overall Risk Rating:** Elevated
- **Estimated Fidelity Readiness:** 84%
- **Total Features Evaluated:** 11
- **Lossless (1:1 Native):** 9
- **Degraded (Fallback / Plain Text):** 0
- **At-Risk (Broken Link / Layout Split):** 2
- **Dropped (Proprietary / Lost Structure):** 0
- **Uncertain (Unverified Export Version):** 0

## Feature Preservation Matrix

| Category | Feature | Occurrences | Preservation Tier | Destination Outcome | Remediation |
| :--- | :--- | :---: | :---: | :--- | :--- |
| metadata | YAML Frontmatter Block | 1 | ✅ Lossless | Parsed natively as note metadata and properties panel. | Ensure property keys contain valid alphanumeric identifier characters. |
| links | Internal Wikilinks [[Page]] | 3 | ✅ Lossless | Resolved directly in graph index and note link cache. | No conversion required. |
| links | Notion 32-Character Hex UUIDs | 2 | 🔶 At-Risk | Ugly filenames with brittle link references that break if renamed. | Run pre-flight rename script to strip 32-hex suffixes while updating internal reference links. |
| databases | Dataview / Dynamic Query Blocks | 1 | ✅ Lossless | Executes dynamically when Dataview community plugin is installed. | Ensure community plugins are enabled in target vault. |
| attachments | Internal Media Embeds ![[file]] | 1 | ✅ Lossless | Resolved via vault attachment search folder. | Ensure asset files are copied to the designated attachment directory. |
| links | Infinite Canvas References (*.canvas) | 1 | ✅ Lossless | Opens native Obsidian JSON canvas board. | Ensure .canvas JSON files are copied alongside Markdown files. |
| formatting | Interactive Checkboxes (- [ ]) | 2 | ✅ Lossless | Supported natively across all modern Markdown environments. | Standard - [ ] syntax is universally portable. |

## Recommended Preflight Action Checklist

1. **Remediate Brittle Links & Filenames:** Strip 32-character hex UUID suffixes from filenames and convert unresolvable link targets into relative markdown paths.
2. **Retain Immutable Backup:** Store an untouched, read-only ZIP archive of the original source export prior to applying automated conversions.

The Real Mechanics of Note Migration: Beyond File Copying

Switching note-taking tools is rarely as simple as copying a directory of text files. Modern personal knowledge management (PKM) ecosystems—including Notion, Obsidian, Roam Research, Bear, Logseq, and Evernote—are not merely text editors; they are database runtimes, graph indices, and proprietary styling engines layered over diverse data structures.

When you trigger an export from one application and import it into another, files may appear on disk, but the semantic fabric connecting those files frequently disintegrates. Internal links resolve to missing anchors, metadata frontmatter fails to parse, custom query blocks render as dead code fences, and visual canvas layouts become unreadable JSON blobs. This breakdown is known as semantic migration drift.

The Migration Preflight Workbench exists to diagnose these risks prior to initiating a migration. By analyzing representative samples of your exported notes against evidence-backed capability matrices, this tool maps exactly which syntax features will survive losslessly, which will degrade to inert fallback text, which will break into dangling references, and which will be completely dropped by your destination environment.

The 5 Preservation Tiers: A Taxonomy of Migration Fidelity

To evaluate migration outcomes objectively, our engine categorizes every detected syntax feature into one of five rigorous preservation tiers:

1. Lossless (1:1 Native)

The destination environment natively understands and renders the feature with zero data loss, styling distortion, or syntax modification. Examples include standard CommonMark headings, basic task checkboxes (- [ ]), standard fenced code blocks, and valid YAML frontmatter blocks between triple dashes.

2. Degraded (Fallback Plaintext)

The semantic capability is lost, but the underlying text remains human-readable as a graceful fallback. For instance, an Obsidian callout box (> [!NOTE]) in standard CommonMark renders as a regular blockquote with literal marker text; a Mermaid diagram renders as a code snippet rather than an interactive SVG diagram.

3. At-Risk (Brittle / Dangling Pointers)

The feature survives in text, but its operational integrity is severely compromised. Prominent examples include Notion 32-character hexadecimal UUIDs appended to filenames and internal links, internal wikilinks ([[Page]]) exported to strict CommonMark readers that expect relative file paths, and heading anchors with inconsistent slugification rules.

4. Dropped (Structural Loss)

The underlying feature cannot be interpreted or rendered by the destination tool, resulting in total loss of functionality. Examples include dynamic Dataview query blocks (```dataview) which depend on an in-memory metadata engine, infinite canvas files (.canvas), proprietary database relations and rollups, and client-side passphrase-encrypted notes.

5. Uncertain (Unverified Format)

The export version or source syntax variant is unrecognized or undocumented in our capability profile database. In accordance with strict epistemic standards, the preflight engine never assumes or reports unverified features as supported. It flags the entire document with an uncertainty warning and advises sandbox testing.

Ecosystem-by-Ecosystem Preservation Profiles

Understanding the architectural peculiarities of your source system is vital for planning remediation steps before executing an import:

1. Notion to Markdown / Obsidian

Notion organizes information as an object-relational database. When exported to Markdown, Notion appends a 32-character hexadecimal hash to every filename and cross-page URL (for example, Engineering Plan 8d39f40c749b40bfa8167f08d591012a.md) to avoid name collisions. If you rename these files manually, internal links across your vault will immediately break. Furthermore, relational database properties, formulas, and rollups are flattened into static CSV tables, permanently severing bidirectional database relations.

2. Obsidian to Portable CommonMark

Obsidian vaults store plain text on disk, which makes them inherently portable. However, heavily customized vaults rely heavily on community plugins. Dynamic queries authored with Dataview or DataviewJS operate exclusively inside Obsidian; when opened in a standard CommonMark viewer or minimalist editor, these blocks become inert text. Similarly, wikilinks ([[Target]]), callouts (> [!TIP]), and canvas boards (.canvas) require pre-flight transformation if long-term software independence is your goal.

3. Roam Research & Logseq to Standard Markdown

Outliner-first knowledge bases represent thoughts as atomic bulleted blocks identified by unique cryptographic hashes (((abcdef123))). Moving from an outliner to a page-oriented Markdown editor is fundamentally difficult: block references lose their transclusion rendering and appear as confusing random character strings unless you explicitly inline the referenced text prior to migration.

4. Evernote (ENEX) to Markdown

Evernote exports rely on the proprietary XML-based ENEX schema. Notes often contain complex nested HTML styling, web clips with extraneous JavaScript, proprietary GUIDs, and embedded multimedia attachments. During conversion, unclosed HTML elements and proprietary font tags frequently corrupt Markdown parsers, requiring aggressive HTML tag stripping and sanitization.

The 6-Step Sovereign Migration Protocol

To ensure zero data loss during an application transition, adhere to this systematic, battle-tested migration protocol:

  1. Create an Immutable Master Archive: Before opening, unzipping, or modifying your exported files, duplicate the raw archive into cold storage. Flag the folder as read-only. Never perform migrations or automated scripts on your sole backup copy.
  2. Execute Preflight Workbench Diagnostics: Paste representative notes containing your most complex features—frontmatter, wikilinks, callouts, tables, and embeds—into this workbench. Review the resulting preservation matrix and risk score.
  3. Bake Dynamic Queries into Static Records: For all Dataview queries or database rollups that will be dropped, run the queries in your original application and copy the rendered tables into static Markdown tables or CSV files.
  4. Sanitize Brittle Filenames and Relative Links: Use automated scripts to strip Notion 32-hex suffixes, normalize spaces in file paths to hyphens or URL encoding (%20), and convert proprietary wikilinks into relative CommonMark links where necessary.
  5. Ingest into a Quarantined Sandbox Vault: Create an isolated, blank directory in your target application. Import only a 5% sample of your notes. Verify graph link resolution, image embed rendering, and frontmatter property indexing before proceeding.
  6. Perform Parity and Checksum Audits: Compare total note counts, attachment tallies, and file sizes between the source export and target vault. Utilize our Export Manifest Generator to establish cryptographic SHA-256 checksum baselines for your library.

Manual Eyeball Inspection vs. Deterministic Preflight Auditing

Diagnostic DimensionManual Eyeball ReviewMigration Preflight Workbench
Coverage & SpeedSpot-checks 3–5 popular notes; misses edge casesInstant deterministic regex audit across all syntax features
Link Brittleness DetectionManual link clicking; easily overlooks hex UUIDsAutomated detection of Notion 32-hex patterns and broken wikilinks
Dynamic Query WarningAssumes queries will continue workingFlags Dataview and script blocks as dropped with remediation steps
Handling Unknown VersionsAssumes backwards compatibilityExplicitly generates uncertainty warnings for unverified versions
Export ArtifactsAd-hoc handwritten notesFormula-safe CSV matrix, Markdown report, and diagnostic shell script
Data Privacy & SecurityOften relies on third-party cloud migration services100% browser-local computation with zero network transmission

Complement your vault migration workflow with our suite of focused browser utilities: audit long-term vault independence with the Offline Note Portability Checklist, generate cryptographic backup manifests with the Export Manifest Generator, compare markdown syntax discrepancies using the Markdown Dialect Laboratory, and normalize legacy callouts with the Callout Portability Converter.

Questions

Why does an unknown export version produce an uncertainty warning?

Ecosystem export engines frequently update their serialisation formats without publishing breaking change logs. If an export version is unrecognized or unverified against our evidence-backed capability matrices, the engine treats every detected feature as uncertain rather than falsely claiming seamless compatibility.

Does this preflight tool upload or modify my local notes?

Never. The entire analysis runs deterministically inside your browser JavaScript runtime. No text, file paths, or private metadata are uploaded to remote servers or stored across page refreshes. Furthermore, the tool only reads the sample text you paste; it never modifies your local filesystem files.

How should I remediate Notion 32-character hexadecimal UUIDs?

Notion appends 32-character hex hashes to exported markdown filenames and internal links to ensure uniqueness. Before migrating to Obsidian or standard CommonMark, run a batch script to strip these hex suffixes from filenames while simultaneously updating internal relative links, restoring clean human-readable note titles.

What happens to dynamic queries like Dataview when switching apps?

Dynamic queries execute code against an in-memory vault index provided by specialized app plugins. Standard Markdown environments and minimalist plain-text archives do not have an active runtime to execute these queries; they render merely as inert code fences. We recommend baking critical query tables into static markdown tables or CSV files before exporting.

Can infinite canvas boards (.canvas) be opened in standard Markdown editors?

No. Infinite canvas boards use custom JSON structures with 2D coordinate nodes, edges, and card references. They cannot be rendered as linear prose documents. You should export visual canvas boards to high-resolution PNG or PDF files and author structured outline notes to preserve conceptual connections.

What is the recommended protocol before starting a large vault migration?

First, create an immutable, read-only ZIP archive of your untouched source export. Second, run a representative sample of notes through this preflight workbench to map fidelity risks. Third, execute dry-run remediation scripts in a sandboxed quarantine directory. Finally, verify backlink and attachment parity before discarding your original notes.

Own Your Thought Architecture with Oyma

Your thinking belongs to you, not your tools. Protect your knowledge base with sovereign local files and transparent, plain-text standards.

migration preflight workbench downloadDownload for Mac

No account needed. Intel Mac build