← Back to Blog

Migrating from Anytype to VaultBook: A Technical Writer's Step-by-Step Move to an Encrypted Single-File Vault

Jonas Keller did not leave Anytype angry, and that is worth saying at the start, because most migration stories are written in the heat of a bad afternoon. Jonas is a freelance technical writer and documentation consultant working from a small office in Leipzig, with clients in three industries that rarely agree about anything except deadlines: a payments company whose developer portal he has maintained for four years, a medical-device manufacturer whose instructions for use must survive regulatory review in two languages, and an industrial software firm whose release notes, configuration guides and troubleshooting libraries he rebuilds every quarter. For most of that period, the working memory of the practice lived in Anytype. It held client project spaces, meeting objects, source interviews, terminology decisions, draft structures, research collections and the thousand small facts that documentation work generates and then immediately needs again: which product manager approved which warning wording, which screenshot belongs to which firmware version, which term the legal team banned in March and unbanned, quietly, in September.

He chose Anytype for reasons that still look sound. He wanted his notes on his own devices first, encrypted, workable without a connection, and he liked — genuinely liked — the object idea. In documentation work, everything really is connected to everything else. A procedure belongs to a product version. A product version belongs to a release. A warning belongs to a hazard, a standard clause and a reviewer. Modelling those connections explicitly, instead of burying them in folder names, felt like the first tool that respected how his material actually behaved. For two years the workspace grew in the direction he had hoped. Types multiplied carefully. Relations carried the load they were designed to carry. Sets gathered the right objects at the right moment, most of the time, when he remembered how each one had been built.

The change, when it came, was not a failure. It was an accumulation of small taxes, each one defensible in isolation, until the total cost of thinking in the tool began to exceed the value of the structure it returned. A quick note from a client call could not simply be written; it had to be classified. Was this a meeting object, a decision object, or a note attached to the project object, and which relations did each choice demand before the thought could be allowed to exist? A new client engagement meant an evening of schema design before the first useful page. A set that had behaved perfectly in spring returned subtly different membership in autumn, and tracing why meant auditing relation values across dozens of objects rather than reading a list. None of this was a bug report. It was the predictable price of a system that asks its owner to be a database designer first and a writer second, charged daily, in the currency of attention, to a man whose clients pay for the writing.

The second pressure was quieter and, in the end, heavier. Jonas’s Anytype spaces contained material he held under contract: unreleased product documentation, interview notes with engineers speaking candidly about defects, terminology disputes that revealed a client’s internal disagreements, draft safety wording that must never be mistaken for approved text. Anytype’s local-first design and on-device encryption were precisely why he had trusted it with that material. What began to trouble him was not where the data lived. It was how the data could leave. When he rehearsed an exit — as every consultant who holds other people’s information eventually should — he discovered that the body text of his objects travelled well and the structure that gave them meaning travelled badly. Export to Markdown gave him readable pages stripped of much of the relation data he had spent years entering. The native export preserved far more, but in a form built to return to Anytype, not to become anything else. The knowledge was his. The shape of the knowledge was, in practice, rented from the tool that had modelled it.

That rehearsal, done on a quiet weekend with no client waiting, is the real beginning of this migration. Jonas did not need a new philosophy. He needed a destination where the unit of work was a page he could write first and organise second, where organisation was carried by labels and sections he could see at a glance, where every file he relied on was downloaded and searchable on his own machine, where the most sensitive entries could be sealed individually, and where the whole practice — software and data together — was one file he could copy, back up and open years from now without asking a network, an account or a sync protocol for permission. That destination was VaultBook. This article is the move he made, in the order he made it, with the losses named honestly alongside the gains.

Migrating from Anytype to VaultBook: A Technical Writer's Step-by-Step Move to an Encrypted Single-File Vault

The Modelling Tax: When Structure Starts Charging Rent

Every object-based workspace begins with a promise that sounds like pure gain. Instead of pages in folders, you get typed things with named properties, and the properties let the workspace answer questions a folder never could. Show every procedure whose status is review, whose version is current, whose reviewer has not yet signed. Show every interview connected to this feature and no other. For a documentation consultant juggling parallel clients, those questions are not luxuries. They are Tuesday. Jonas built his types with real care in the first year: Project, Procedure, Concept, Meeting, Interview, Term, Source, Release, Decision. Each carried relations chosen from the work itself — client, product, version, status, reviewer, language, source file, approval date — and for a while the discipline paid him back visibly. A set could assemble a release’s entire documentation surface in seconds. A relation audit could find every page still pointing at a retired product name.

The tax appeared in the places the promise did not mention. The first was capture. Documentation work generates fragments at speed: a sentence an engineer says on a call that redefines a feature, a screenshot annotation, a term to check, a contradiction between two existing pages noticed mid-draft. In a page-first tool, a fragment is written where it lands and classified later, if ever. In Jonas’s Anytype spaces, the fragment arrived as a decision. Choosing the wrong type was not fatal, but it was sticky, because relations, templates and set membership all hung from the choice. He developed the familiar workaround of a holding space full of hastily typed notes awaiting proper modelling, which is to say he rebuilt, by hand, the inbox his tool was supposed to make unnecessary — and then had to model the backlog anyway, usually on Sunday.

The second tax was maintenance of the model itself. Clients rename products. Review processes gain a stage. A relation that began as a single reviewer becomes a panel. Each change was reasonable; each one rippled. Templates built on the old shape produced objects missing the new field. Sets filtered on values that had been renamed returned partial results without announcing their partiality. Jonas is a careful worker, and he caught these drifts, but catching them consumed the exact resource the system was bought to protect: unhurried attention to the words. He began keeping a private list, outside the workspace, of places the model could not be trusted to have told him the whole truth. A tool that requires a shadow list of its own blind spots has inverted its purpose, however elegant its graph looks in a screenshot.

The third tax was cognitive, and it is the one other Anytype users describe most consistently when they talk about why they scaled back or left. The workspace demanded that he hold its schema in his head as a condition of using it. Which relations does a Decision carry that a Meeting does not? Which set is the canonical view of a client’s open items, and which is the near-duplicate built for one presentation last winter? Newcomers to any tool expect a learning curve, and Jonas climbed his willingly. What wore on him was that the curve never quite levelled into fluency, because the model kept growing with the practice. Four years in, opening the workspace still began with a small act of recollection — how did I structure this client, again? — before any actual work could start. The structure had become a second job description.

None of this makes Anytype a bad tool, and this article will return, in its own section, to the things Anytype does better than the destination Jonas chose. It makes Anytype a tool whose costs are charged in a currency some workers have in surplus and others do not. A researcher building a personal knowledge garden over decades may happily pay in modelling effort for decades of compound structure. A consultant whose billable product is finished documentation, whose material arrives in bursts from other people’s projects, and whose organisation must be legible at a glance under deadline pressure, pays the same tax out of a much smaller account. Jonas’s migration began when he admitted that distinction to himself: the question was never whether objects and relations are powerful. The question was whether his practice needed that power in that form, at that price, every single day.

What Four Years in Anytype Actually Contained

Before any export button is pressed, a migration needs an inventory, and Jonas’s is worth describing in detail because the shape of his holdings is the shape many long-term Anytype users will recognise in their own spaces. He did not have one workspace. He had, in effect, five: one space per major client, one for the practice itself, and one personal space that had slowly become a second practice archive because that is where things were put when there was no time to decide. Across them sat several thousand objects. Nobody, including Jonas, knew the exact count until the audit described later in this article, and that ignorance is itself part of the story.

The payments client’s space was the most disciplined. Its backbone was the developer portal: procedure objects for each integration task, concept objects explaining the platform’s moving parts, reference objects for endpoints and error states, all tied by relations to product versions and review status. Around that backbone orbited the working material: meeting objects from the weekly documentation call, decision objects recording why a guide had been restructured or a term chosen, interview objects capturing engineers’ explanations before they were distilled into prose. A set gathered everything awaiting the client’s review. Another gathered everything approved for the next portal release. The space worked — when its relations were current. Its weakness was that its truth lived in those relations, distributed across hundreds of objects, invisible until queried.

The medical-device space was smaller and far more sensitive. Here the objects held instructions-for-use drafts, hazard-related wording under discussion, translation memories in embryo — source sentences paired with approved German renderings — and review threads with regulatory colleagues. Much of it was confidential by contract; some of it was safety-relevant in the plain sense that careless handling of draft warning language could cause real confusion if it escaped its context. This space also contained the practice’s most valuable reusable asset: a terminology collection built over years, each term object carrying the approved rendering, the rejected alternatives, the client contact who had decided, and the date. Losing the body text of those objects would be an inconvenience. Losing the relations between term, decision and approver would be losing the asset itself.

The industrial software space was the messiest, because that client’s work arrived in quarterly surges and the modelling had been done in haste, repeatedly, by a tired man at the end of release weeks. Types overlapped. Two generations of status values coexisted. Some release objects used one relation for version, others a differently named relation with the same intent. The sets built over this uneven ground were correspondingly uneven, and Jonas had learned to double-check their output against his own memory — which is to say, the space had quietly stopped being a system of record and become a system of suggestion. It held excellent material. It could no longer be trusted to gather all of it on demand.

The practice space held the business of being Jonas: engagement records, rate and contract notes, invoice-related correspondence summaries, a set tracking active work against capacity, templates for proposals and documentation plans, and the reusable craft material every consultant accumulates — style decision logs, checklist objects for publication quality assurance, notes on tools and formats. The personal space held reading notes, course material, a long-running collection on the history of technical illustration, and several hundred objects captured quickly and modelled never. Taken together, the five spaces were simultaneously a triumph of connected knowledge and a standing argument that connection had been purchased at the price of legibility. Jonas could ask his workspace intricate questions. He could no longer simply look at it and see his practice.

That inventory dictates everything that follows. A migration that treated these five spaces as one undifferentiated pile of pages would destroy the client separation his contracts require. A migration that tried to reproduce every relation as structured data in the new home would rebuild the tax he was leaving. The plan that emerged — and that the rest of this article sets out step by step — treated each space as its own vault territory, translated types into a deliberately small vocabulary of labels, demoted most relations to clearly headed sections inside entries where a human can read them, promoted only the handful of relations that drove daily work into labels and Kanban columns, and handled files as first-class citizens to be downloaded, renamed and indexed rather than linked and hoped for. The model would get simpler on purpose. The information would not be allowed to get poorer in the process — and keeping that promise is what the verification phase, later, exists to prove.

An Honest Account of What Anytype Does Well

A migration guide that caricatures the tool being left is a sales document wearing a guide’s clothes, so this section states plainly what Jonas was giving up, and what a reader whose work differs from his might be right to keep. Anytype’s object model is not a gimmick. For material whose value lies in structured relationships — a research corpus, a collection, a personal library where each item genuinely has the same meaningful attributes — types and relations do work that labels and prose sections cannot do as precisely. A relation can be filtered, sorted and aggregated. A section heading inside an entry can only be read. If your weekly work depends on computed views over hundreds of uniformly shaped items, Anytype’s sets will answer questions that VaultBook’s label views and Kanban boards answer only approximately, by eye, at smaller scale. Jonas felt this loss concretely in exactly one place — his terminology collection — and the article returns to how he rebuilt that one asset with compensating habits rather than pretending the loss away.

Anytype’s sync story, at its best, is also genuinely distinctive. Its peer-to-peer design lets devices on a local network synchronise directly, without a company’s server mediating, and its wider sync protocol can run through encrypted backup nodes or infrastructure the user hosts. For a worker whose practice is spread across a desktop, a laptop and a phone that are often in the same building, that model offers something VaultBook deliberately does not attempt: VaultBook has no sync at all, in any form, and moving a vault between machines is an act its owner performs by copying a file. Jonas worked overwhelmingly at one desk and had already simplified his life to a primary machine and a laptop that mirrored it; the sync he was surrendering was, for him, mostly theoretical. A field researcher collecting material on a phone all day would weigh that surrender very differently, and should.

The third strength is philosophical, and it deserves respect rather than a rebuttal. Anytype was built by people visibly trying to hand users real control: accounts created offline around a key the user holds, data encrypted on the device, protocols published for others to build on, self-hosting treated as a legitimate way to live rather than a grudging concession. Jonas’s quarrel was never with those commitments, which VaultBook shares in its own way. His quarrel was with the daily ergonomics of the model those commitments were wrapped in, and with an export path that made the structure he had built difficult to carry elsewhere in usable form. Readers who love the object model, whose sync needs are real, and whose material rewards heavy structure should read this guide as a description of a trade, not a verdict. Jonas traded modelling power and peer-to-peer sync for immediacy, legibility and per-entry encryption inside a single file. The rest of the article shows the trade being made carefully. Whether it is your trade depends on which side of it your working week resembles.

Before Anything Moves: The Audit, the Freeze and the Backup

The most dangerous moment in any migration is the enthusiastic first hour, when exports are run on a living workspace and the mover begins building the new home from whatever came out, without ever establishing what was supposed to come out. Jonas spent his first weekend on three unglamorous tasks — audit, freeze, backup — and later identified that weekend as the reason the rest of the project never turned into archaeology. The audit came first. Space by space, he listed every type in use and counted its objects, using Anytype’s own views and, where the model had drifted, manual passes through the space’s structure. He wrote the counts down outside the tool, on paper, in a table that would become the migration’s contract: this many projects, this many procedures, this many terms, this many meetings, per client, before anything moves. Numbers written down in advance cannot be quietly renegotiated later when a shortfall would be convenient to ignore.

The audit also graded material, because not everything in a four-year workspace deserves a new home. Jonas marked each type, per space, into one of four fates. Active material — current client work, the terminology asset, live templates — would migrate in full and be verified individually. Reference material — completed engagements, past release documentation, older interviews — would migrate in full but be verified by sampling, since its value was archival rather than operational. Superseded material — drafts whose final versions existed, decision objects overturned by later decisions — would migrate as a single consolidated archive entry per topic, preserving the history without importing the clutter as live structure. Dead material — captures never read, duplicate objects created by sync-era confusion, empty objects spawned by abandoned templates — would not migrate at all, and the audit recorded its counts too, so that the final reconciliation could explain every missing object as a decision rather than a loss. In the industrial software space alone, this grading retired a substantial stratum of well-modelled rubbish that had been lending the workspace a false sense of completeness.

The freeze followed. From the Monday after the audit, Jonas stopped creating new material in Anytype. New work — and a consultant cannot simply pause client work for a migration — went into a plain interim notebook file and a dated folder of documents, kept deliberately crude, with a note of where each item would eventually belong. The freeze sounds like deprivation and felt like relief: for the first time in years, the workspace held still long enough to be measured twice. Anything that absolutely had to change in Anytype during the migration fortnight — one client’s urgent correction — was logged in the same interim file, so the frozen counts could be adjusted by a known, written delta rather than by rediscovery. Migrations fail socially before they fail technically: they fail when the source keeps moving and the mover stops believing the destination will ever catch up. The freeze is what makes catching up a finite problem.

The backup closed the weekend, and it was made in triplicate with intent. First, a complete export of every space in Anytype’s native format, with files included, stored untouched: this was the rollback, the guarantee that the old workspace could be reconstituted exactly as it stood if the project collapsed. Second, a complete export of every space as Markdown, with files included, stored separately: this was the raw material the migration would actually consume, kept pristine so that any processing mistake could be restarted from clean inputs. Third, a copy of both exports on a different physical drive, because a backup that shares a disk with its original is a hope, not a backup. Jonas also recorded, in the audit document, the Anytype version he had exported from and the date of each export, details that feel pedantic on the day they are written and priceless on the day an export behaves unexpectedly. Only with the contract counts written, the source frozen, and three copies resting in two places did he allow himself to open VaultBook and begin. The next section explains the uncomfortable discovery the exports themselves were about to confirm — and how the migration plan absorbed it.

The Export Reality: Readable Pages, Missing Skeleton

Jonas ran the Markdown export of the payments space first, as a pilot, and opened the result with the particular optimism of a man who has read the manual. The pages were there. Titles were right. Body text was intact, formatting recognisably preserved, images present as files when he had asked for files. For a few minutes the migration looked like a clerical afternoon. Then he opened the export of a procedure object whose entire usefulness had lived in its relations — the product version it applied to, the reviewer who owned its approval, the release it was scheduled into — and found a clean page of instructions with none of that context attached. The procedure’s steps had survived the journey. The facts that told him when to use it, who was waiting on it and which release would break if it slipped had not travelled in any form he could use. He checked a term object from the medical-device space and found the same shape of loss: the term itself and its discussion were present; the approved rendering, the rejected alternatives and the deciding contact — the relation values that made the object an asset rather than a note — were absent from the Markdown he had been given.

This behaviour is the single best-documented frustration in Anytype’s user community, raised on Reddit and carried into the project’s own forum repeatedly over several years, and it matters to state its exact shape rather than its rumour. The complaint is not that Anytype refuses to export. It exports willingly, in several formats. The complaint is that the human-readable export and the complete export are different objects. Markdown, the format every other tool can consume, has historically carried the body while leaving types and relation values behind, and it litters the output with auxiliary files that mean little outside the source. The native format, built on the AnyBlock structure, preserves far more — properties, formatting, tables, view definitions — but its natural destination is Anytype itself; other applications cannot simply open it, and turning it into something else is a conversion project, not an import. Recent Anytype releases have worked on exactly this seam, with a revised block format and a proper programming interface intended to make data easier to read and to move. A migrant in November, holding a deadline, plans around the export that exists today, not the one a roadmap describes kindly.

Jonas’s response to this discovery is the technical heart of his migration, and it generalises to any reader leaving an object-based tool. He stopped treating export as a single act and split it into two channels with different jobs. The Markdown export became the channel for content: every object’s words, headings, lists and embedded material, destined to become the body of a VaultBook entry. The native export became the channel for truth about structure: opened inside a fresh, temporary Anytype installation — a sacrificial copy of the old world, running only as a reference — it let him read relation values object by object during the rebuild, for exactly as long as the rebuild needed it. Nothing in the plan required a converter that did not exist. It required patience, a written mapping, and the refusal to pretend that a partial export was a complete one. Where relation values existed in bulk and followed a pattern — version, status, reviewer across the payments procedures — he transcribed them in passes, type by type, working from the reference copy with the destination entry open beside it. Where a relation existed on only a handful of objects, he handled those objects individually, like the antiques they were.

Two further export traps deserve naming because both are invisible until they have already cost someone data. The first is attachments. A space export that does not explicitly include files produces beautiful text about documents that are not in the folder. Jonas’s pilot export had included files, but the resulting structure flattened attachments into a shared pool, severing the visible connection between a file and the object it belonged to; the connection had to be rebuilt from the reference copy during migration, file by file for the material that mattered. The second trap is links between objects. Inside Anytype, a mention is a live relationship. In Markdown it degrades to text — sometimes a title, sometimes a truncated one — and the web of references that made the workspace feel intelligent arrives in the new home as prose that merely talks about connections. Jonas accepted this honestly rather than fighting it: internal references would be rebuilt as VaultBook wiki links during each entry’s rebuild pass, for the entries where the connection carried working value, and left as plain mentions in archive material where it did not. A migration that promises to preserve every link is lying. A migration that decides, in advance and in writing, which links earn rebuilding is a plan.

By the end of the pilot he had a rule that governed everything after: the export is not the migration. The export is the quarry. The migration is the building work done from quarried stone, checked against the reference copy, counted against the audit. Readers tempted to skip this distinction — to import whatever a tool gives them and start working — usually discover its importance a quarter later, when a set they trusted turns out to have been rebuilt from pages whose context never arrived. Jonas discovered it on a Saturday, with the old workspace frozen and intact and the cost of the lesson at zero. That is the only cheap time to learn it.

The Translation Map: Objects to Entries, Relations to Labels and Sections

Every migration between differently shaped tools needs a translation map written before the bulk work begins, because decisions made object by object, at midnight, under fatigue, will contradict each other by morning. Jonas’s map fits on one page and rests on a principle he stated at the top of it: VaultBook entries would be organised the way a reader scans, not the way a database queries. Types became entry kinds signalled by labels. The handful of relations that drove daily decisions became labels too, or Kanban positions. Every other relation became a headed section at the top of the entry, written in plain language, readable without opening anything else. Sets became saved ways of gathering — label views for reference, Kanban boards for work in motion. Spaces became territories inside one vault, separated by a client label worn by every entry belonging to that client, without exception, so that a single search could never silently mix two clients’ material.

The type translations were deliberately few. A Project object became a project entry: one per engagement, carrying the client label, a status label, and sections for scope, contacts, agreed terminology sources and delivery rhythm. A Procedure or Concept object became a documentation entry, labelled by client, product and kind, its body imported from Markdown, its former relations rendered as an opening section headed Context, where version, owner and release were written as sentences. A Meeting object became a meeting entry whose relations became its first section — attendees, date, the project it served — and whose decisions were additionally copied into the relevant project entry, because a decision buried in meeting notes is a decision the practice will make twice. An Interview object became a source entry, with sections for the conversation’s circumstances, the material it produced, and the permissions attached to it: who had agreed to be quoted, in what form, and what remained off the record. A Decision object did not become an entry of its own at all in the new map; decisions were folded into the entry they governed, as a dated section, because Jonas had learned from four years of retrieval failures that he looked for decisions where their subject lived, never in a decision register. The register had been elegant. The habit was stronger than the elegance, and the map obeyed the habit.

Relations sorted into three fates under the map, and the sorting is the part of this guide most worth stealing. Relations that answered the question what needs my attention became workflow: status became a Kanban column, due and review dates became entries in VaultBook’s calendar and its Due and Expiring sidebar, and reviewer became a label only where one reviewer owned a whole stream of work. Relations that answered the question what is this connected to became labels or wiki links: client, product and language became labels worn by every relevant entry; connections between specific entries — this procedure implements that decision, this interview explains that concept — became wiki links written during the rebuild. Relations that answered the question what must a future reader know became sections: approval history, rejected alternatives, source provenance, contractual restrictions, the name of the person who decided and the date they decided it. Written as prose, this context is slower to query than a relation field and vastly faster to comprehend. Jonas’s four years had taught him that he comprehended his material a hundred times for every once he computed over it. The map optimised for the hundred.

Sets translated last, because a set is a question and the map had to know which questions Jonas actually asked. His audit listed eleven sets across the five spaces; on inspection, four were asked weekly, three were asked at release time, and four had not been opened in over a year and existed mainly as evidence of past tidiness. The weekly four became the vault’s working furniture: two became Kanban boards, described in detail in their own section below, and two became standing label combinations he could summon in seconds — everything for one client carrying the review label, everything in the practice carrying the awaiting-payment label. The release-time three became checklists inside the relevant project entries, because a question asked four times a year does not need a view; it needs a list that cannot drift. The dormant four were not rebuilt at all. Their absence is recorded in the audit, mourned by nobody, and stands as this guide’s small sermon on migration as editing: the best moment to retire a structure is while you are paying to move it, when its cost is finally itemised in your own hours.

One translation deserves its own paragraph because it carried the practice’s crown jewel. The terminology collection could not survive as prose sections alone; a term’s approved rendering, rejected variants, deciding contact and decision date are exactly the kind of uniform, repeated structure that object modelling exists for, and flattening several hundred terms into free text would have traded a searchable asset for a diary. Jonas rebuilt it inside VaultBook as a disciplined compromise: one entry per term, built on a fixed section template — Approved Rendering, Rejected Alternatives, Decided By, Applies To, Example in Context — with labels carrying client, language pair and product line, and the vault’s full search, including search inside attached files, standing in for the queries he used to run. The template is enforced by habit and checked in his weekly routine rather than by the software, which is a real weakening compared with a schema that refuses malformed entries. He accepted it with open eyes, and then did the thing that made it safe: he kept the frozen Anytype reference copy of the terminology space intact and consultable, permanently, as the asset’s cold archive. Some structures deserve a monument. The monument does not have to be the office you work in.

The Move, Phase by Phase

With the audit signed, the source frozen, the backups resting and the map written, the migration itself occupied nine working days spread across a fortnight, sequenced so that Jonas could earn his living in the mornings and move his practice in the afternoons. The sequence matters more than the speed. He began with the practice space, deliberately, because it was the smallest, the least sensitive and the most forgiving of beginner’s mistakes in a new tool — and because rebuilding the templates, checklists and engagement records first meant the machinery of the business was already running in VaultBook when the client material arrived. Day one in the new vault was spent creating its skeleton: the client labels, the kind labels, the status vocabulary, the section templates for each entry kind, and a single welcome entry that recorded the migration’s own rules, so that future Jonas, tired and tempted to improvise a new label at midnight, would meet present Jonas’s reasoning first.

Client spaces followed in ascending order of pain. The payments space came second: disciplined source, disciplined destination. Its procedures and concepts were rebuilt in batches organised by product area, each batch following the same rhythm — import the Markdown bodies, open each entry against the reference copy, write its Context section from the relations, attach its files, apply its labels, rebuild its two or three working wiki links, and tick its line on the audit sheet. A batch was twenty entries, roughly an afternoon, and the rhythm’s monotony was its virtue: any entry that broke the rhythm — a missing attachment, a relation value that contradicted the body — announced itself precisely because everything else was routine. The medical-device space came third, rebuilt more slowly and under the encryption decisions described in the next section, with its terminology collection handled as a separate sub-project across two full days. The industrial space came last and benefited from every lesson the earlier spaces had taught, including the most valuable one: its drifted, duplicated source material was consolidated during the move rather than before it, with pairs of near-identical entries merged into single entries whose version history in VaultBook preserved both ancestors’ content as earlier revisions, so consolidation did not become quiet deletion.

Two working rules kept the fortnight honest. The first was that no entry counted as migrated until it had been read in its new home by a human — Jonas — checking three things: that the body was complete against the Markdown source, that the context the relations had carried was present in words, and that every file the entry claimed was actually attached and opened. Import counts were never trusted; read counts were. The second rule was that the interim notebook, where new client work had been landing since the freeze, was emptied into the vault every evening, so the destination never fell behind the living practice while the archive was still arriving. A migration that delivers a perfect past and a stale present has failed at the only moment that matters, which is the Monday morning when the old tool is closed for the last time and the new one must simply be the place work happens.

The closing of that Monday deserves a sentence of its own. Jonas did not delete Anytype. The frozen installation, with its native export and its reference copies, remains on his machine as a read-only monument, opened perhaps once a month when a client asks about a decision from 2023 and the vault’s consolidated archive entry points him to the original object. The migration’s success is not measured by the old tool’s absence. It is measured by the fact that new work no longer goes there — that the freeze, intended as a fortnight’s discipline, quietly became permanent, because the new home was easier to write in on the first ordinary morning than the old one had ever been on its best.

Documentation consulting runs on files the way carpentry runs on timber. Jonas’s Anytype spaces referenced hundreds of them: source documents supplied by clients, annotated screenshots, specification PDFs, recorded walkthroughs in which engineers narrated their own systems, spreadsheet glossaries, signed approval scans. Inside Anytype those files had lived in the product’s own storage logic, synced by its own rules, and — as the community complaints that recur around attachment sync and export structure suggest — their behaviour at the boundaries of the system was the part of the workspace Jonas trusted least. Images that lagged behind text in sync, attachments whose folder logic dissolved on export, files that were present in the app and elusive everywhere else: none of it had ever caused him a catastrophe, and all of it had taught him to verify rather than assume. The migration treated files not as luggage but as citizens, under a simple law: a file the practice relies on must exist as a downloaded copy, with a human name, attached to the entry it supports, searchable in the vault on his own machine.

The mechanics used three of VaultBook’s built-in tools, and each earned its place on a different class of material. The specification and source PDFs — long, scanned in part, supplied in whatever state a client’s document management had left them — were attached to their entries and indexed locally, with VaultBook’s optical character recognition reading the scanned pages so that a phrase buried on page eighty of a device manual became findable from the vault’s search rather than from memory. Several of these documents had been, in Anytype, effectively write-only: present, referenced, and unsearchable in any practical sense. Jonas found two contractual details during the migration that he had previously answered from recollection, one of them wrong. The PDF tools handled a second, grubbier class of work: client packets that arrived split across a dozen files, or merged into one unwieldy bundle, could be split, merged and compressed inside the vault, locally, instead of being uploaded to a web service whose entire business is receiving other people’s documents. For a consultant whose contracts promise care with client material, performing that surgery on his own machine is not a preference. It is the difference between keeping a promise and describing one.

The recorded material changed character most completely. Engineer walkthroughs and interview recordings, which in Anytype had been attachments to be played, became working text in VaultBook: the audio tools cut a two-hour walkthrough into its topical segments, local transcription turned speech into searchable words without the recording ever leaving the machine, and the resulting transcript lived in the same entry as the audio itself, the relevant screenshots and Jonas’s notes on what the engineer had meant as opposed to said. For the medical-device client, whose walkthroughs discussed unreleased functionality under a strict confidentiality clause, the locality of that pipeline was the entire argument — transcription services that process audio on remote servers were never an option for this material, so before VaultBook the recordings had simply remained untranscribed, mined only by Jonas’s memory and a hand-kept index of timestamps. The Photo and Video Explorer carried the screenshot library: hundreds of interface captures across product versions, browsable with their metadata intact, so that the question which build did this dialog come from could be answered from the file’s own evidence rather than from a filename’s hopeful guess. Files, handled this way, stopped being the migration’s risk and became its dividend — the class of material that was unambiguously better off after the move than before it.

Sealing the Sensitive Entries: Encryption as a Working Decision

Anytype had protected Jonas’s client material with encryption applied at the level of the vault and its sync, which is a sound design and was never the reason he left. What VaultBook offered differently was granularity as a daily tool: individual entries can be encrypted, each sealed with AES-256-GCM, the key derived through PBKDF2, using the Web Crypto facilities of the browser itself — so the decision about what is sensitive is made entry by entry, at the moment of writing, rather than once for the whole archive. That granularity changed Jonas’s working habits in ways a whole-vault lock never had, because it let the ordinary ninety percent of his practice stay frictionlessly open on his own machine while the dangerous ten percent sat behind a passphrase even there. A borrowed laptop, a machine left with a repair shop, a vault file copied to the wrong folder: in each of those small, plausible accidents, the unencrypted bulk of the practice would be embarrassing to expose and the encrypted core would still be sealed. Risk, for a consultant, is rarely a cinematic breach. It is a mundane mishap meeting the wrong paragraph.

Deciding which entries earned encryption was a discipline in itself, and Jonas wrote his criteria into the vault’s welcome entry so the decision would stay consistent after his migration-era vigilance faded. An entry was encrypted if it contained pre-release product information a client had shared under confidentiality terms; if it recorded an identifiable person’s candid assessment of their own employer’s product, process or colleagues; if it held draft safety or warning language whose premature circulation could confuse it with approved text; if it contained credentials, access details or portal instructions of any kind, which in VaultBook could also be supported by the built-in password generator when new access secrets had to be created during an engagement; or if it contained the commercial terms of his own practice — rates, negotiation notes, margin reasoning — whose exposure would damage him without informing anyone. Everything else stayed plain. Meeting logistics, published documentation, general craft notes and public-source research carried no seal, because encrypting the harmless alongside the harmful teaches the hand to resent the lock, and resented locks get left open.

The medical-device terminology work produced the subtlest case. The terms themselves, once approved and published in the client’s instructions, were not secret. The rejected alternatives, however, sometimes revealed why a rendering had been refused — a resemblance to a competitor’s phrasing, a connotation in German that the regulatory team considered unsafe, a decision-maker’s blunt internal reasoning. Jonas split the difference structurally: each term entry’s public skeleton — approved rendering, language pair, product line — remained readable, while the sensitive history lived in a companion entry, encrypted, linked from the first. The split took an extra minute per term across several hundred terms, and he considered it the best-spent time of the whole migration, because it converted a blanket anxiety about the collection into a precise, inspectable boundary. Anyone auditing his handling of that client’s material could now be shown, rather than told, where the confidential layer sat and how it was protected.

Three cautions belong in any honest account of per-entry encryption, and Jonas’s guide would be negligent without them. First, encryption protects content at rest; it does not protect a passphrase chosen carelessly, reused elsewhere, or written on the machine it guards, and his passphrase practice — a long, unique phrase held in his head and in a sealed envelope with his executor documents — is part of the system, not a footnote to it. Second, an encrypted entry’s content is only as searchable as its sealed state allows, so the titles and labels of encrypted entries must carry enough honest signal for their owner to find them without decrypting the shelf; Jonas adopted a titling convention that names client, subject and date while revealing nothing a client would object to. Third, encryption is not backup. A sealed entry lost with its file is exactly as lost as a plain one, which is why the vault’s backup rhythm, described later, treats the single file with the seriousness its concentration deserves. The seal decides who can read. The copies decide whether there is anything left to read. A practice needs both decisions made deliberately, and made separately.

Rebuilding the Working Views: Kanban, Labels and the Calendar

A set in Anytype is a stored question, and the questions Jonas asked most were about motion: what is waiting for the client, what is waiting for me, what is blocked on an engineer, what ships with the next release. VaultBook answers motion with a Kanban board, and rebuilding his two working boards was the moment the new vault stopped being an archive and started being a workplace. The first board belongs to the whole practice rather than to any client, and its columns are the honest states of a consultant’s work rather than the flattering ones: Captured, Drafting, With Client, Blocked, Approved, Delivered. Every active piece of work is a card born from an entry — the entry holds the substance, the card holds the state — and the board’s discipline is that a card may not claim a state its entry cannot prove. With Client means the entry contains the sent draft and the date it went. Blocked names its blocker in the entry’s opening section, a person and a question, never a mood. On Monday mornings Jonas reads the board the way a pilot reads instruments, and the reading takes four minutes because the board, unlike his old sets, cannot silently omit a card whose relations drifted. A card is present because he put it there. Its absence is visible. Its presence is his own testimony, which turns out to be a stronger guarantee than a query he half-trusted.

The second board is release-shaped and belongs to the payments client, whose portal publishes on a fixed cadence. Its columns follow the portal’s own pipeline — scoped, written, in review, approved, staged — and each release gets its own swim-through of cards drawn from that client’s entries, labelled so the board never borrows another client’s work. What the board replaced is instructive: in Anytype, the equivalent view was a set filtered on status and release relations, elegant when the relations were current and quietly treacherous in the weeks when a busy engineer-reviewer renamed a status value and half the release fell out of the view without leaving a gap shaped like itself. The Kanban board can be wrong only in the ways Jonas can be wrong — a card not moved, a state misjudged — and those errors are visible to the same eyes that made them. He traded a system that could be wrong behind his back for one that can only be wrong in front of his face, and for work that other people’s launches depend on, he considers that the best bargain of the migration.

Labels carry the reference questions, the ones about gathering rather than motion. The vocabulary was kept small enough to memorise — a label per client, a label per product where a client had several, kind labels for procedure, concept, meeting, source, term and project, and a short list of state labels for the handful of distinctions the boards do not cover — because a label system that needs its own documentation has recreated the modelling tax in a cheaper suit. With that vocabulary, the gatherings Jonas actually performs take seconds: one client’s sources, gathered; every entry across the practice carrying the term kind, gathered; the industrial client’s entries from a single product line, gathered. VaultBook’s related-notes suggestions and its ordinary full search, reaching inside attached files as well as entry text, cover the looser questions — what else have I written that touches this error state, this clause, this component — that relations used to answer formally. The looser answers arrive as ranked neighbours rather than computed sets, and for research-flavoured questions Jonas finds them more useful, not less: a computed set tells him what his past self predicted he would need, while search tells him what the material actually contains, including the connections nobody modelled because nobody foresaw them.

Time, the third working dimension, moved into VaultBook’s calendar and its Recent, Due and Expiring sidebar, and this quiet change removed a whole category of low-grade dread from the practice. Documentation work is lousy with dates that matter asymmetrically: a review window that closes, a contract renewal that must be renegotiated before it lapses, a certification document that expires, a client embargo that lifts, a translation delivery promised for a regulatory milestone. In Anytype these dates had lived as relation values — present, structured, and inert, visible only when a view happened to surface them. In the vault they are attached to entries in a system whose sidebar exists to nag: recent work resurfaces, due work announces itself, expiring work cannot slip past in silence. Jonas’s Monday routine now ends with the sidebar rather than the board, and the two together — motion and time, each in the tool shaped for it — reproduce everything his sets did for his working week, at a fraction of the modelling cost, with the failures moved from the system’s blind spots into his own line of sight.

Verification: Proving the New Home Holds Everything

A migration is a claim, and claims about other people’s confidential material should be verified like it. Jonas’s verification phase ran for three evenings after the bulk move and followed the audit contract written before anything had moved. The first pass was arithmetic: entry counts per client and per kind in VaultBook, set against the audit’s numbers, with every discrepancy required to resolve into one of the written explanations — graded as dead and retired, consolidated into an archive entry whose identity was recorded, or merged with its twin named. When the industrial space produced a shortfall of eleven entries beyond its explanations, the process stopped being arithmetic and became detection: the reference copy showed a cluster of release entries whose Markdown export had landed in a subfolder the rebuild rhythm had skipped. They were migrated that evening, and the incident is recorded here because it is the verification working exactly as designed — a small, boring discrepancy, chased to a specific cause, on a night when fixing it cost an hour instead of a client relationship.

The second pass was sampling with intent. For active material, Jonas re-read every project entry and every term entry’s skeleton against the reference copy, because those were the entries whose errors would propagate. For reference material, he sampled by a rule written in advance — every tenth entry, plus any entry whose title contained a date from the current year — reading body against Markdown source and context section against relation values. The sampling found what sampling exists to find: a handful of context sections with a reviewer name transcribed from the wrong row, two interview entries whose permissions section had been copied from a sibling interview with different terms, and one procedure whose attached screenshot belonged to the following procedure in sequence. Each find was corrected, and each was logged, because a verification that reports perfection is a verification nobody should trust, including its author. The log’s modest list of real errors is the strongest evidence that the checking was real.

The third pass tested the vault as a workplace rather than as a container, by replaying the practice’s actual questions against it. Could he assemble everything awaiting the payments client’s review, in under a minute, and did the assembly match the board? Could he find the source of a terminology decision from two years ago, with the decider and the date? Could he produce, from the medical-device entries alone, the list of draft warnings still unapproved, with nothing published mixed in? Could he locate the walkthrough segment where an engineer explained a configuration flag, by searching words the engineer had spoken? Each replay had a written expected answer drawn from the old workspace before the test began, so the vault was graded against the past rather than against optimism. It passed the terminology and walkthrough tests outright, passed the review assembly once a mislabelled entry was corrected, and passed the warnings test only after Jonas admitted that two draft warnings had been living, mislabelled, inside a meeting entry — a fault the old system had also contained, faithfully migrated, and now, for the first time, visible enough to fix.

Only after those three passes did the parallel run begin: one full working week in which VaultBook was the practice’s home and Anytype was opened only as a reference, with a notebook page reserved for every moment Jonas reached for something the vault could not give him. The page collected four entries in five days. Twice he wanted a computed view over the terminology collection that labels and search answered more slowly. Once he wanted his phone to show him a note he had not copied there, the sync-shaped hole discussed elsewhere in this guide. Once he wanted a relation he had chosen not to migrate, and found its substance waiting in the archive entry where the map had sent it. Four honest frictions in a week, none of them blocking, all of them priced into the decision he had already made. At the week’s end he closed the reference installation, changed the interim notebook’s heading to an archive note, and let the freeze become permanent. Verification had done its work: not proving the new home flawless, but proving it complete, legible and his.

Why VaultBook Beats the Market-Leading Note Apps for This Work

Jonas’s destination was never only Anytype’s absence; it was a specific shape of custody, and that shape is best understood against the market-leading note applications a documentation consultant in his position would otherwise be using — the deliberate-choice leaders named in VaultBook’s market research across the United States, the United Kingdom, Germany, Japan and India alike: Notion, Evernote, Microsoft OneNote, Google Keep and Apple Notes. Each of them would happily store a technical writer’s notes. The question this section answers, leader by leader, is what happens to a freelance consultant’s client material inside each one’s architecture, and why the single offline file answered his scenario better. The argument rests on custody, encryption granularity, offline reliability, portability and independence from accounts and servers. It does not rest on price or payment models, which are not the ground this comparison stands on.

Against Notion, the distinction is where the workspace lives and who can compute over it. Notion is a cloud workspace: pages and databases exist on the provider’s infrastructure, reached through an account, and the platform’s considerable power — its databases, its views, its collaboration — is inseparable from that residence. For Jonas, that residence is the disqualifier for client-confidential material, quite apart from Notion’s lack of end-to-end encryption for workspace content: his contracts promise clients that their pre-release documentation will be held on his systems, not distributed across a vendor’s. VaultBook’s answer is architectural rather than promissory. The vault makes zero network requests; there is no server copy for a provider incident, a subpoena aimed at a platform, or an account compromise to reach. Where Notion’s database genuinely outclasses the vault — live multi-user editing, shared client review spaces, a database a whole team maintains together — this guide concedes it without flinching: a documentation team that reviews together in real time should not choose VaultBook as its shared surface. Jonas reviews by delivering documents through his clients’ own systems, and keeps his working memory private. For that division of labour, custody beats collaboration he never used.

Against Evernote, the distinction is the difference between a note service and a file. Evernote’s long history as the default archive for a generation of knowledge workers rests on a synced cloud account: notes live in the service, are reached through it, and inherit its fortunes, its interface decisions and its account requirements. A consultant’s archive inside Evernote is portable in the sense that export exists; it is not portable in the sense that matters at midnight before a deadline — a single self-contained object, on his own drive, openable in a browser with no sign-in, no client application negotiation, no service standing between him and his own terminology decisions. VaultBook’s one-file portability also changes the backup question from a sync setting to a copy: the whole practice, duplicated, in the time it takes to copy any other file. Evernote remains the stronger capture machine for a certain kind of life — its web clipping and its long-cultivated integrations gather material from the internet with a fluency the vault does not attempt. Jonas clips almost nothing; his material arrives as client documents and conversation. The leader’s strength was real, and irrelevant to the workload being housed.

Against Microsoft OneNote, the distinction is the account and the notebook’s home. OneNote’s notebooks live inside the Microsoft account world, ordinarily in OneDrive, with the organisational gravity that brings: excellent for a writer embedded in a client’s Microsoft estate, awkward for a freelancer whose independence is part of his value and whose three clients inhabit three different tenants, none of them his. His own notes must not become a guest in someone else’s directory, subject to that tenant’s policies and to his access surviving the engagement. VaultBook requires no account at all — no identity provider, no tenant, no sign-in between the writer and the file — and its per-entry encryption gives him a protection OneNote’s section-level password features only approximate, at the granularity of the entry rather than the section, sealed with AES-256-GCM rather than held behind an account session. OneNote’s honest strengths are substantial and should be named: its free-form canvas, its handwriting and ink handling, and its deep familiarity inside large organisations make it the right tool for annotators and for anyone whose work is already Microsoft-shaped. Jonas types structured prose for a living. The canvas he needs is a page, and the estate he needs it in is his own.

Against Google Keep, the distinction is depth and custody together. Keep is a superb capture surface — fast, everywhere a Google account is signed in, frictionless for the sentence that must not escape — and it is, by design, a shallow one: labels without hierarchy of commitment, no per-entry encryption, no versioned depth for work that must be audited, and a residence inside a Google account where the notes are one product among many in a large advertising company’s infrastructure. For a consultant, Keep’s account residence carries the same structural objection as the other cloud leaders, in its lightest form: the material is held by a provider, under an account, reachable through a service. VaultBook inverts every term of that arrangement for the practice archive — depth over speed, entries with sections and history over cards, a file over an account — while honestly conceding the capture contest: for the thought caught at a tram stop, Keep on a phone is faster than any vault workflow, and Jonas still scribbles such thoughts wherever is nearest, treating them as raw material to be filed properly at his desk rather than as the archive itself. A tool can win the moment and lose the decade. His migration was about the decade.

Against Apple Notes, the distinction is the ecosystem wall and the shape of the store. Apple Notes has become a genuinely capable application, and for a writer wholly inside Apple’s hardware world it offers quick capture, respectable organisation and, with its locked-notes facility, a gesture toward the protection sensitive material needs. Its limits for this scenario are structural: the notes live in iCloud’s account world, their full life is lived on Apple devices, and a consultant whose clients hand him Windows machines, whose own laptop history spans platforms, and whose archive must be openable on whatever computer survives the next decade cannot build his practice’s memory inside one vendor’s garden, however well kept. VaultBook, a single HTML file opened in a browser, is deliberately unglamorous about platforms: the same file, the same vault, on any machine with a browser, with no account mediating. Apple Notes wins, plainly, on the effortlessness of capture and on handwriting for those who think with a pencil in hand. Jonas’s practice thinks in typed, versioned, searchable prose, under contracts that name custody. On that ground — custody without an account, encryption at the level of the entry, one file that can be carried anywhere and opened by anything — the vault answers his scenario in a way none of the five leaders, each excellent at its own centre of gravity, is built to answer.

The Export, Step by Step, Without the Optimism

This section slows the migration down to the level of individual actions, because most published migration advice fails precisely here: it describes intentions where the reader needs a sequence. The sequence Jonas followed for each space began inside Anytype, with the space opened and its contents reviewed against the audit list one final time while the source was still alive enough to answer questions. Archived objects were reviewed deliberately rather than swept along by default, because an export that includes the archive doubles the rebuild surface with material the grading had already assigned to consolidated entries. Where a space contained objects belonging, by an old accident of filing, to a different client, those objects were noted on the audit sheet as cross-filed and assigned to their true client’s batch. A migration is the last cheap moment to correct the filing sins of years; after it, the sins acquire the authority of a system.

The native export came first for each space, taken with files included and stored, untouched, in the rollback folder whose name recorded the space, the format and the date. Jonas treated this export the way a pilot treats a life raft: he did not expect to use it, he verified it existed, and he checked — by starting the sacrificial reference installation and importing one space into it — that it actually opened. An untested backup is a rumour, and the test cost twenty minutes on a Saturday when twenty minutes were free. The Markdown export followed, also with files included, into the working folder the rebuild would consume. He then performed the check this guide has already urged on its readers: he selected the three most relation-rich objects in the space — in the payments space, a procedure, a term-bearing concept and a heavily linked project object — and compared their Markdown files against the living objects, field by field, writing down exactly what the export had carried and what it had dropped. Every space behaved slightly differently in detail, because every space’s modelling habits had differed, and the written comparison for that space became the rebuild checklist for its batches. No batch began until its space’s checklist existed.

The reference installation deserves a fuller description, because it is the piece readers most often improvise badly. It was a separate Anytype profile on the same machine, clearly named as a reference, into which the native exports were imported once and then never edited. During each rebuild batch it sat open on a second screen, or in a window beside the vault, displaying the original object while its successor was assembled. This arrangement converted the relations problem from a data problem into a reading problem: every value that mattered could be seen, judged and rendered into the destination’s labels, sections or links by a person who understood what it meant. The judgement mattered. A relation value that had been entered carelessly in 2023 — a status left at draft long after approval, a reviewer field naming someone who had left the client — was not transcribed into the new home out of fidelity to the export. It was corrected, and the correction was noted in the entry’s context section with its date, so the vault’s history of the matter begins with an honest sentence rather than a faithfully preserved error. Migration by transcription preserves mistakes at scale. Migration by reading gives a practice one supervised chance to stop carrying them.

Files required their own step, performed before the batch work rather than during it, because attachment chaos discovered mid-batch breaks the rhythm that makes errors visible. Jonas listed every file in the Markdown export’s pooled folders, matched each against the reference copy to learn which object it had served, and renamed it on the spot under the convention the rest of this guide assumes: client, subject, kind and date, in plain words, so that the file’s name alone could reunite it with its entry even if every system involved forgot the connection. Files that matched no object — orphans of deleted pages and abandoned drafts — went into a holding folder rather than the bin, and were reviewed once at the end of the fortnight, when their context could be judged with the whole migration in view. Most were deleted then, calmly. A few turned out to be the only surviving copies of signed approvals, which is the entire argument for the holding folder in one sentence.

Only after those preparations did a batch begin, and a batch’s internal order was fixed: bodies first, because an entry without its words is a shell that invites premature organising; context sections second, written from the reference copy while the body’s contents were fresh; files third, attached and opened; labels fourth, applied from the map’s vocabulary and no other; links last, rebuilt only where the map had marked the connection as working rather than decorative. The audit line for each entry was ticked only after the read-through described earlier, and the batch closed with a count — entries rebuilt, entries read, discrepancies open — spoken aloud, written down, and compared against the morning’s expectation. The ritual sounds bureaucratic in description and felt, in practice, like craftsmanship: the same motions, the same checks, the same small satisfactions, twenty entries at a time, until five spaces had become one vault and the counts agreed.

Templates: The Section Shapes That Replaced the Schema

Since VaultBook does not enforce structure, the structure Jonas’s entries rely on lives in templates — fixed section shapes he writes from, kept as entries in the vault itself so they are always one search away. They are reproduced here in substance because they are the working answer to the most common objection to leaving an object tool: without types, everything becomes soup. Soup is what happens without templates. With them, an entry’s shape is as predictable as an object’s ever was; the difference is that the predictability is maintained by a visible habit instead of an invisible schema, and a reader can see the whole shape at once instead of opening a properties panel.

The project entry template opens with a section headed Engagement, carrying the client, the contact who commissions work, the agreed scope in two or three sentences, and the commercial frame in plain words — not the sensitive negotiation history, which lives in its encrypted companion, but the operative facts a working morning needs. A section headed Current State follows, rewritten rather than appended as the engagement evolves, so that the entry always answers the question where does this stand before it answers any other. Then comes Decisions in Force, a dated list in prose, each entry naming the decision, who made it and what it replaced. Then Deliverables and Rhythm, naming what the practice owes this client and on what cadence. Then Sources of Truth, the entry’s most documentation-specific section, listing which repositories, portals and document stores the client regards as authoritative, so that a draft never quietly promotes a secondary source. The template closes with an Open Questions section, emptied into the Kanban board or the client’s correspondence as questions resolve. Six sections, in a fixed order, on every project entry in the vault: Jonas can read any client’s position in under a minute, including a client he has not touched in a month, and that minute is the dividend the template pays.

The documentation entry — the descendant of procedures and concepts — carries a leaner shape. Its Context section comes first and does the work relations once did: product, version, owning reviewer, release, status, each as a short labelled line in prose. The body follows, imported and then edited into the vault’s house style, with the entry’s sections mirroring the published document’s structure where the entry is a draft, or summarising it where the entry is a record of a published page. A Changes That Matter section records the revisions a future maintainer would need explained — not every edit, but every edit whose reasoning is not visible in the text itself. The entry closes with a Related Work section holding its wiki links in sentences rather than as a bare list, because a link explained is a link that will still make sense when its target has been renamed by a busier season: this procedure assumes the configuration described there; this concept entry defines the term as the client approved it in March.

The source entry, descendant of interviews and research objects, is built around provenance. Circumstances comes first: who spoke, when, in what setting, at whose request. Permissions follows immediately and is never optional, because the vault treats a missing permissions section as a defect on sight — what may be quoted, what may be paraphrased, what is background only, what is sealed. Material Produced lists what the conversation yielded: the recording, its transcript, the documents it prompted, each attached or linked. Claims and Corrections records what the source asserted that the practice relies on, and, with equal prominence, what the source corrected from the existing documentation — often the interview’s most valuable yield. The term entry’s template has already been described in its own discussion: approved rendering, rejected alternatives with their reasons held in the encrypted companion where those reasons are sensitive, decider, date, applicability and an example in context. The meeting entry is the shortest shape in the vault — attendees and date in its opening lines, decisions copied out to the entries they govern, actions converted into board cards before the entry is closed, and the entry itself retained as the record of who was in the room when the practice committed itself. Read together, these six templates are the schema, rewritten as literature. They ask more of their author’s consistency than Anytype’s types did, and they give more to their reader in return: everything about an entry, including the facts its old properties panel used to hide behind a click, visible in one downward scroll.

One Procedure, Moved Completely: A Worked Example

Abstract method persuades few people; a single object followed through the entire move is worth a chapter of principle. The object Jonas chose as his pilot — and the one followed here — was a payments-client procedure explaining how a merchant’s developers should rotate the secret keys that authenticate their integration, a page whose correctness matters, whose audience is impatient, and whose relations were unusually rich. In Anytype it carried its client, its product area, the portal release it belonged to, a status of approved, a named reviewer on the client’s platform team, a related concept object explaining the key model, two source interviews with the engineers who owned the authentication service, and a screenshot set that had been revised three times as the client’s console changed its appearance. If this object could arrive whole, anything in the space could.

Its Markdown export arrived as clean steps and broken context, in the pattern this guide has described: the procedure’s numbered actions, its caution about the brief window in which old and new keys must both be honoured, its troubleshooting table — all present, all readable. Absent were the release, the reviewer, the approval, and any usable trace of the concept object and the interviews, which appeared, where they appeared at all, as bare titles in the text. The rebuild therefore began with the reference copy open to the original object, and the entry’s Context section was written first in the new home, before the body was touched, so that the facts most at risk of loss were secured while attention was freshest: product and area in one line, version applicability in the next, the reviewer’s name and the approval date after that, the release named plainly, and a sentence recording that the procedure had been validated against the console’s current interface in a named month. The body was then imported and read against the original with the screenshot set open, because procedures fail in their illustrations more often than in their sentences: two of the exported images belonged to the superseded console design, a fact invisible in the Markdown and obvious the moment the reference object and the export were viewed side by side. The current images were taken from the native export’s files, renamed under the convention, attached, and opened in the vault to confirm they rendered at a size a reader could actually use.

The connections were rebuilt as the map prescribed. The concept object became a concept entry in the same batch, and the procedure’s Related Work section gained a wiki link to it inside a sentence explaining the dependency — a reader who does not understand the key model should start there, because step four assumes it. The two interviews became source entries, linked from a sentence recording that the procedure’s caution about the overlap window came from the service owners’ own account of a past incident, paraphrased in the entry with its permissions respected. The status and release relations became motion and time: a card on the release board in the approved column, and a calendar note at the next release’s documentation freeze, when the procedure must be revalidated against any console changes. The entry was then read once, end to end, by its author wearing a stranger’s eyes, ticked on the audit sheet, and counted. Total elapsed time for the pilot object, including every lesson learned the slow way: just under an hour. The nineteenth procedure in its batch, with the rhythm established and the checklist written, took eleven minutes. That ratio — the first object costing five times the steady rate — is the most reliable budgeting fact in this entire guide, and any reader planning their own move should multiply their pilot’s duration by their object count only after dividing it by the rhythm they will have earned by the twentieth.

Edge Cases: The Objects That Do Not Fit the Map

Every real workspace contains material the translation map did not foresee, and a migration guide earns its credibility in how it treats the exceptions. Jonas’s audit had predicted most of his; the fortnight produced the rest, and the dozen cases below are recorded because each one will recur, in some costume, in any reader’s workspace. The governing principle, stated once, is that an exception gets a written fate in the audit, never an improvised one at the keyboard. Improvisation is how two identical problems receive two different solutions on two tired evenings, and the vault inherits the inconsistency as a permanent feature.

The first case was the composite object: a single Anytype object that had grown, over years, into a small dossier — part meeting record, part decision log, part draft — because its topic kept returning to the agenda. Splitting it in the vault was correct and delicate: the decisions went to the entry they governed, the meeting record kept its date and its room, the draft became a documentation entry, and each of the three carried a sentence naming its siblings, so the dossier’s unity survived as narrative even though its body was divided. The second case was the object whose relations contradicted its body — approved in its status, described in its own text as awaiting a signature. The body won, because bodies are written later and more carefully than fields, and the discrepancy was recorded in the new entry’s context as a small act of source criticism. The third case was duplication with divergence: the same procedure maintained in two spaces after a client reorganisation, each copy edited since the fork. These were merged by reading, not by choosing a winner — the vault entry took the newer structure, admitted the older copy’s two superior passages, and preserved both ancestors in its version history, with a context sentence explaining the fork so a future reader does not mistake the merge for the original state of the world.

The fourth case was the object built entirely from an embedded view — a page whose content was a set rendered inline, meaningful only as the query it displayed. Such objects export as nearly nothing, because their substance was never text. They were rebuilt as what they had always secretly been: standing questions, answered in the vault by a label combination or a board, with a short entry recording the question and where its answer now lives. The fifth case was the attachment that was the object: scanned signed pages, a recorded approval, a marked-up proof, where the surrounding text existed only to say what the file was. These became entries whose first section is a description of the file full enough to serve if the file is ever separated from it — parties, date, subject, outcome — with the file attached and, where the file was a scan, its text made searchable by the vault’s local recognition, so a signature page could be found by the name it bears rather than by the folder it sleeps in. The sixth case was the multilingual pair: source and translation maintained as sibling objects, in the medical-device space especially, where losing the pairing would lose the point. Pairs became paired entries with matched titles, a language label on each, and a first-line sentence in each naming the other, because a translation whose source cannot be found is a claim without evidence.

The seventh case was the template-born empty: objects created by an old template and never filled, dozens of them, haunting the counts. The grading had marked them dead, and they died, but their titles were harvested first into a single archive entry, because a list of questions a practice once meant to answer is itself a small piece of intellectual history. The eighth case was the oversized object — a research collection that had become a book-length monster no export handled gracefully. It was divided along its own headings into a family of entries under one project, each carrying the section it had always been, with the original’s introduction preserved as the family’s head entry. The ninth case was the object with a person inside it: notes about a client’s employee that were fair as working memory and unkind as permanent record. Migration is an editorial act as well as a technical one, and Jonas rewrote those passages into the factual minimum the work required — role, commitment, date — letting the frozen reference copy hold the original wording for as long as retention rules required, and no longer. A new home is a legitimate occasion to ask what deserves to be carried, and by whom it might one day be read.

The tenth case was the broken internal reference, where an object’s text pointed at an object the audit could not find — deleted long ago, or lost in an earlier era of the workspace’s life. These were rendered as plain mentions with a bracketed note that the target no longer exists, preserving the honesty of the reference without inventing a destination. The eleventh case was the object in the wrong client’s space, discovered by content rather than by filing; it migrated with its true client, and its audit line carries the correction, because a migration that silently repairs provenance teaches its owner to trust records that were, in fact, repaired. The twelfth case was the object Jonas simply could not classify — a long, strange research note that served three projects and belonged to none. It became an entry wearing all three project labels and a kind label of its own, an admission that some material is genuinely cross-cutting and that a label system, unlike a folder tree or a strict type, can say so without lying. That last flexibility, small as it sounds, is one of the vault’s quiet superiorities: an entry may wear every label it has earned, and a piece of work with three homes is no longer forced to pretend it has one.

If It Goes Wrong: Rollback, Recovery and the Discipline of Copies

Planning a migration without planning its failure is optimism wearing a project plan’s clothes, so this section states the failure modes Jonas prepared for and the ones that actually visited. The total failure mode — the vault proves unusable in the parallel week — had the simplest answer, and it had been purchased on the first weekend: the freeze lifts, the native exports restore the workspace exactly as audited, the interim notebook’s fortnight of new work is re-entered by hand in a long evening, and the migration is recorded as an experiment whose cost was time and whose yield was a complete audit of the practice’s holdings, which is not nothing. The partial failure mode is more likely and more insidious: the vault works, but a category of material is discovered, weeks later, to have arrived diminished — a relation family nobody sampled, an attachment class whose files were pooled beyond recognition. Against this, the defence is retention: the frozen source and both export sets are kept, unopened and intact, for a full quarter after the move, and the vault’s welcome entry records where they rest. Any late discovery is then a retrieval exercise, not a loss. Jonas’s own late discovery arrived in week six — a set of approval dates for the industrial client that had lived in a relation his checklist had misjudged as decorative — and was repaired from the reference copy in twenty minutes, which is what insurance feels like when it works: boring.

The vault’s own failure modes, once it is home, are the ordinary catastrophes of files, and they are answered by the backup rhythm already described, with two refinements worth adding. The first is that a backup is only counted when it has been opened: Jonas opens the weekly off-premises copy on the machine that holds it, once a month, and scrolls — a ten-second test that converts the copy from a belief into a fact. The second is that the vault’s concentration demands one copy in a form a non-technical rescuer could use: the monthly copy travels with its plain-language note, naming what the file is, what opens it, and which entries inside it are sealed and why, written for the executor or the colleague who might one day hold the practice’s memory without its owner to explain it. A consultant who holds other people’s confidential material owes those people a succession story, and a single HTML file with a lucid note is a better one than most cloud accounts can offer, since an account’s succession runs through password resets, provider policies and proof-of-death paperwork, while a file’s succession runs through an envelope.

Recovery from the small disasters of daily life follows the same philosophy of visible mechanisms. An entry edited badly is recovered from its version history, which is why Jonas treats history not as a comfort blanket but as the vault’s memory of his own fallibility, consulted without shame whenever a paragraph feels thinner than it should. A label applied wrongly in bulk is corrected in the monthly audit, where drift is expected and hunted. A vault file copied over by an older copy — the classic single-file accident, and the one Jonas feared most — is prevented by the naming discipline of his backup folders, in which every copy carries its date in its name and the live file is never renamed at all, so an old copy can never masquerade as the current one by wearing its name. None of these arrangements is clever. All of them are inspectable by the person they protect, at the moment they are needed, without a support ticket. That inspectability, repeated across every layer of the system, is the deepest continuity between the migration method and the destination it chose: at every step, the person who bears the risk can see the mechanism that carries it.

The Fortnight at a Glance

For the reader who wants the whole project on one screen before committing to it, the shape of Jonas’s fortnight was as follows, and it scales down for smaller workspaces roughly in proportion to their object counts. The first weekend belonged to audit, grading, freeze and the three backups, and it ended with the contract counts written down. The Monday and Tuesday of the first week built the vault’s skeleton — labels, templates, the welcome entry with its rules — and migrated the practice space as a rehearsal, mistakes included, at a scale where mistakes were cheap. Wednesday and Thursday rebuilt the payments space in batches of twenty, the rhythm establishing itself by the second afternoon. Friday was given to verification of everything moved so far and to emptying the interim notebook, so the first week closed with the destination already carrying the living business.

The second week’s Monday and Tuesday belonged to the medical-device space, slower by design, with the encryption decisions and the terminology sub-project consuming the better part of both days. Wednesday took the industrial space, consolidation and all, at the rhythm’s full speed. Thursday was verification in full — counts, sampling, the replayed questions — and the repair of everything verification caught. Friday closed the exports into their retention folders, wrote the migration’s own record as an entry in the vault, and opened the parallel week that the following Monday would confirm as permanent. Across the fortnight, client work continued every morning; the migration consumed afternoons and one weekend, roughly thirty hours in total, of which the audit and verification — the parts a hurried mover would cut — accounted for nearly a third. Jonas’s retrospective judgement, offered as this guide’s planning rule, is that the third spent on measuring and proving is what makes the other two-thirds spendable only once. A migration done at twenty hours and repeated at forty is not cheaper than one done properly at thirty. It is merely invoiced twice.

Two numbers from the fortnight deserve to survive it. The first is the ratio met earlier: the pilot object cost nearly an hour, the steady rhythm eleven minutes, and any reader’s estimate should be built from their own pilot, timed honestly, divided by the rhythm they reach — never from a tool’s promise about import speed, since importing was the smallest part of every hour Jonas spent. The second number is four: the frictions recorded in the parallel week, each one a capability surrendered knowingly and priced in advance. A migration whose parallel week records zero frictions has not been observed; it has been celebrated. The notebook page matters more than the champagne, because it is the final audit — the one performed by the working week itself, which cannot be fooled by counts, checklists or hope.

A Working Day in the New Vault

Method persuades the mind; routine persuades the sceptic who has heard methods before and watched them dissolve by Thursday. So here is an ordinary Tuesday in the migrated practice, three weeks after the parallel run ended, described at the level of keystrokes and minutes rather than principles. The day begins, as Jonas’s days now begin, with the vault already open from the night before — a browser tab among others, holding a file on his own drive, asking for nothing: no sign-in ceremony, no sync status to interpret, no workspace loading from anywhere. The Due and Expiring sidebar is read first, with coffee, and on this Tuesday it holds three items: a client review window closing Thursday, a domain registration for the practice’s small website expiring at the month’s end, and a reminder that the medical-device client’s annual confidentiality attestation is due to be re-signed. Each item sits inside the entry that owns it, so reading the reminder and reading its context are the same act. In the Anytype years, the equivalent facts existed — as relation values, on objects, inside spaces — and surfacing them required opening the right space and running the right view, a small expedition he performed faithfully perhaps three mornings in five. A sidebar that simply shows him is not a feature. It is the difference between a system that waits to be asked and a system that reports for duty.

The morning’s first work is the payments client’s weekly documentation call, and the vault’s part in it shows the capture discipline earning its keep. During the call, Jonas writes in a fresh meeting entry, fast and unclassified beyond its client label: an engineer’s aside that the key-rotation window will shorten in the next release, a product manager’s decision to retire a legacy integration guide, a question about error wording that nobody in the room can settle. Nothing is modelled. Nothing waits for a type decision while the conversation moves on. When the call ends, the ten-minute filing pass converts the raw entry into infrastructure: the rotation remark is copied into the procedure entry it will eventually force him to revise, with a calendar note at the release’s freeze date; the retirement decision is written into the project entry’s Decisions in Force, dated and attributed; the unsettled question becomes a card in the Captured column, naming the person who owes the answer. In the old workspace, each of those three artefacts would have been an object to create, type and relate — a quarter of an hour of modelling, at the exact moment when the morning’s other work was queueing. The filing pass took nine minutes, most of it spent thinking rather than clicking, which is the correct distribution of a documentation consultant’s hour.

Midday brings the medical-device client’s translation query, and with it the vault’s most sensitive machinery in ordinary use. A German rendering in a draft instruction has been challenged by the client’s regulatory reviewer, who believes a weaker verb would be safer; Jonas believes the weaker verb would be vaguer, and vagueness in an instruction for use is its own hazard. The term entry settles the factual ground in seconds: the approved rendering, the review history, the example in context, all readable in the entry’s plain skeleton. The argument about the rejected alternative — the very verb now being proposed, refused two years ago for a reason recorded at the time — lives in the encrypted companion entry, and Jonas opens it with his passphrase, reads the recorded reasoning, and finds the precedent is close but not identical: the earlier refusal concerned a different device family, where the weaker verb described a genuinely gentler action. The distinction lets him concede the reviewer’s point for this device while defending the rendering elsewhere, and the new decision is written into both entries before lunch, the companion re-sealed as a matter of fingertip habit. The entire episode — retrieval, precedent, judgement, record — consumed twenty minutes and produced an audit trail a regulated client can be shown. It is difficult to overstate how much of consulting value lives in exactly this: not knowing the answer, but being able to prove why the answer was given, years later, in the room where it is challenged.

The afternoon belongs to drafting, the work the practice is actually paid for, and here the vault’s contribution is mostly absence. The industrial client’s release notes are assembled from entries whose context sections carry their versions and owners, from a walkthrough transcript searched for the engineer’s own explanation of a changed default, and from screenshots whose metadata settles which build each dialog belongs to. Nothing is uploaded anywhere for conversion, transcription or convenience. Nothing requires a connection; when the office internet falters for an hour in the middle of the afternoon — a small, real event, of the kind that cloud workspaces convert into a stall — the drafting does not notice, because the vault was never talking to anyone. At the day’s end, the filing pass runs again, the board is read once more, the vault file is copied to its evening resting place, and the whole apparatus of memory closes without ceremony. A tool’s success, in a working practice, is measured by how little of the day it occupies. On this Tuesday, the vault occupied perhaps twenty minutes of direct attention and returned, by Jonas’s reconstruction, the better part of an hour that the old model would have spent on itself.

The Cost of Staying, Counted Honestly

Migration guides usually price the move and leave the status quo unpriced, as if staying were free. Jonas priced both, during his audit weekend, in the only currency he trusts: his own hours, observed rather than imagined. He had kept rough time notes for a month before deciding, at his accountant’s suggestion and for unrelated reasons, and they gave the modelling tax a number. In that month he had spent a little under six hours on work that existed only to serve the workspace’s structure — designing and repairing types and relations, auditing set membership, re-modelling captures that had landed in the holding space, reconciling the small divergences between what the model said and what the material was. Six hours a month is not a scandal. Compounded across the remaining years of a practice, priced at a consultant’s rate, and weighed against the structure’s actual yield — the computed views he consulted perhaps twice a month, on questions search and labels now answer in minutes — it was a subscription paid in attention, renewing monthly, for a capability he mostly admired rather than used.

Staying carried a second, less countable cost, which the export rehearsal had exposed: the growing share of the practice’s memory whose meaning depended on the continued behaviour of one application’s data model. Every year in Anytype added objects whose value lived in relations that the human-readable export did not carry. The longer the stay, the more expensive the eventual exit, and the more the decision stopped being a decision — a dynamic every long-term user of a structured tool should recognise, because it operates silently and always in one direction. Jonas is careful, in his own notes, not to call this lock-in in the conspiratorial sense: Anytype’s team has answered the export criticism in public, pointed to its native format’s completeness, and shipped work aimed at making data easier to read outside the application. Intent, however, is not the variable a custodian of client material plans around. The variable is the present, testable fact of what an export carries, and on that fact the cost of staying rose with every object he created. Leaving in year four cost a fortnight. Leaving in year eight would have cost the same fortnight’s method applied to twice the material, with twice the relation archaeology, undertaken by an older man with the same number of afternoons.

Against those costs, the move’s price has already been itemised in this guide: roughly thirty hours, a written audit, a verified rebuild, and the permanent acceptance of four frictions — no sync, no computed modelling, no live collaboration, no schema enforcement. A reader performing the same arithmetic should perform it with their own observed hours, not with Jonas’s, because the equation’s answer flips with its inputs. A user whose computed views answer daily questions, whose modelling time is an hour a month because their material is uniform, and whose devices reconcile constantly, will find staying cheap and leaving expensive, and should stay with a clear conscience and this guide’s blessing. The arithmetic, not the destination, is the transferable asset here. Tools charge rent in different currencies — money, attention, custody, risk — and the only reliable way to know what you are paying is to count, in a ordinary month, what the tool actually took.

Questions a Migrant Asks at Midnight

Certain questions recur in every migration conversation, usually at the moment the mover is alone with the export folder, and they deserve direct answers in the mover’s own terms. The first is whether the Markdown export can simply be trusted and the whole affair compressed into an afternoon. The honest answer is that it can be trusted with exactly what it demonstrably carries — body text, structure, attached files when they are requested — and that the demonstration must be performed on the reader’s own richest objects, not assumed from any guide, including this one, because export behaviour shifts between versions and between modelling habits. An afternoon spent discovering a relations gap after the old workspace is closed is an afternoon in a burning building. The same discovery made during a rehearsal, with the source frozen and intact, is a planning input. The difference between the two afternoons is not luck. It is sequence.

The second question is whether something will be lost, asked in the tone of someone hoping to be reassured. Something will be lost, and reassurance would be a lie: computed views lose their computability, relations lose their machine-readability, the graph loses its geometry, and any object whose meaning lived entirely in a view loses its meaning unless a human rehouses it. What need not be lost is information — every fact a relation carried can be carried by a sentence, a label or a card, if the migration is done by reading rather than by importing. The migrant’s real choice is not between loss and preservation. It is between losing structure knowingly, item by item, with each fact rehoused by hand, and losing information unknowingly, in bulk, by trusting a format to carry what it was never built to carry. Jonas’s fortnight was the price of choosing the first. Readers unwilling to pay it should not choose VaultBook and then improvise; they should choose a destination whose importer does the rehousing for their specific source, or stay where the structure is native.

The third question is whether the old workspace should be deleted once the new one feels like home, and the answer, in the strongest terms this guide permits itself, is no — not for a quarter, not until the late discoveries have had their season, and arguably not ever, since a frozen installation and its exports occupy less space than a single client video and stand as the practice’s evidence of its own history. Deletion is the one migration act that cannot be revised, and it is invariably contemplated at the moment of maximum confidence, which is precisely when it should be refused. The fourth question is whether the passphrase regime will become a burden, and the honest answer is that it becomes a habit or it becomes a hazard: entries sealed behind a phrase their owner resents get left open, copied into plain text, or written around. Jonas’s criteria — seal the dangerous tenth, leave the rest plain — exist to keep the burden small enough to be carried for decades, and a reader whose material is uniformly sensitive should expect a heavier daily cost and weigh it as such. The last question is the quietest: whether, having moved, he misses the graph. He does, occasionally, the way one misses a beautiful instrument one was never quite the musician for. Then a client calls, a fragment lands, an entry opens, and the work — the actual work, the sentences other people’s safety and launches depend on — begins in the first second rather than the fifteenth minute. The missing fades. The minutes remain.

A Second Worked Example: The Interview That Became Evidence

The procedure example earlier in this guide showed a documentation object surviving the move. This second example follows the other kind of material a consultant guards: a conversation. In the winter of the practice’s third year, Jonas recorded a long walkthrough with two engineers who owned the payments platform’s authentication service, recorded with their knowledge, on the understanding that their remarks were background for documentation and not for quotation by name. In Anytype the recording lived as an attachment on an interview object, related to the key-management concept, to three procedures and to the release then in preparation. Its value was enormous and almost entirely latent: Jonas remembered its argument, could not search its words, and revisited it by scrubbing through audio whenever a drafting question touched the service’s history — which meant, in practice, that he revisited it rarely and relied on memory often, with memory’s usual confidence and accuracy.

The migration rebuilt that object as a source entry, and the rebuild is worth following because nearly every VaultBook capability this guide has mentioned touched it in turn. The audio file was downloaded from the export’s pool, identified against the reference copy, renamed to carry the service, the subject and the date, and attached to the new entry. Its length made it a candidate for the vault’s audio tools: the recording was cut at its natural joints into the segments the conversation itself had created — the key model explained, the incident history recounted, the future changes previewed — so that a future visit could begin at the relevant movement rather than at the overture. Local transcription then turned the whole conversation into text on Jonas’s own machine. That locality was not a refinement; the engineers had spoken candidly about an incident whose details the client had never published, under a background-only agreement, and sending that audio to a remote transcription service would have broken the agreement’s spirit regardless of any provider’s stated policies. In the vault, the transcript sits in the same entry as the audio it came from, correctable by its owner, searchable by anyone the owner admits to the file — which is to say, by Jonas alone.

The entry’s written sections did the work its relations once pointed at. Circumstances recorded who had spoken, in what roles, at whose invitation, and in what setting. Permissions stated the background-only terms in the entry’s second section, where no reader of the entry can reach the transcript without passing them. Claims and Corrections captured the conversation’s durable yield: the engineers’ explanation of why the overlap window existed, their correction of a widely believed but wrong account of the incident’s cause, and their warning — since borne out — about which part of the key model the next release would disturb. The three procedures the interview had been related to received wiki links from the entry, each inside a sentence saying what the conversation contributes to that procedure, and each procedure’s own entry gained a reciprocal line in its Related Work, so the connection can be walked in either direction by a reader rather than computed by a query. When, two months after the migration, a drafting dispute turned on exactly what the engineers had said about the incident’s cause, the vault answered from the transcript in under a minute, with the permissions section riding along in the same view to govern how the answer could be used. In Anytype, that answer would have required finding the object, opening the attachment, and listening at double speed while taking notes. The information was identical. The distance between the question and the evidence was not.

The Vocabulary, Translated Once and for All

Migrants think in the old tool’s words for months after the move, and a fixed translation, written down, shortens that bilingual period. Jonas kept his on the vault’s welcome entry, and it is reproduced here as the guide’s final piece of apparatus. An object is an entry: the unit of work, written first and organised second. A type is a kind label plus a template: the label says what the entry is, the template gives it the sections its kind requires, and nothing enforces the pairing except the monthly audit and the author’s interest in being able to read his own archive. A relation is, according to its job, a label, a section line or a card: labels for the connections a reader gathers by, section lines for the facts a reader comprehends by, cards for the states a worker acts on. A set is a question, and questions are answered by the instrument shaped for their kind — a board for motion, a label combination for gathering, a checklist inside a project entry for the questions asked four times a year, and search for the questions nobody predicted. A space is a territory marked by an unwavering client label, inside one file, rather than a separate container; the separation is a discipline of labelling, audited like everything else, and its strength is that cross-territory questions — total load, shared deadlines, reusable solutions — become askable for the first time. A graph is a reading practice: wiki links inside sentences, related entries offered by the vault, and a reader walking connections that were written to be walked. A backup node is an envelope, a drive and a habit. A sync is a walk across the room with a small drive in one’s pocket, performed deliberately, at a known moment, by the person who bears the risk.

Read as a whole, the vocabulary confesses the migration’s philosophy more plainly than any argument in this guide. Every translation replaces a mechanism with a practice — a thing the software did with a thing its owner does, visibly, on a schedule, with the failures in the open. That is not a universally superior arrangement, and this guide has said so at every honest opportunity. It is the arrangement that fits a practice whose scarcest resource is attention, whose gravest risk is other people’s information, and whose owner would rather be responsible for his system’s weaknesses than surprised by them. The reader whose scarcest resource is something else — scale, collaboration, computation — should translate their own vocabulary toward a different destination, using this one as evidence that the translation, done deliberately and verified ruthlessly, is the migration itself. The export is an afternoon. The translation is the work. The verification is the proof. Everything else is filing.

Release Morning: The Migration Meets Its First Deadline

The truest test of a migrated system is not the parallel week, when its owner is watching it with a notebook in hand, but the first deadline that arrives indifferent to the migration’s feelings. Jonas’s came eleven days after the move became permanent: the payments client’s portal release, with its documentation freeze, its review queue and its small hours of coordinated publishing, landed on a Thursday that also carried a medical-device review meeting and an industrial client’s urgent correction. The day is recorded here briefly because it is the moment every claim in this guide either earned its keep or did not. The release board held the portal’s cards in their true states, and the morning’s first discovery — that two procedures still sat in review because a client reviewer had changed roles — came from reading the board rather than from a partner’s anxious message, which meant it arrived with time to act on it. The terminology question raised by the device meeting was answered from the term entries during the meeting itself, companion entry opened and re-sealed without ceremony, to the visible reassurance of a regulatory colleague who had not previously believed a freelancer’s notes could carry that quality of record. The industrial correction required a screenshot from two builds ago; the Photo and Video Explorer’s metadata identified it in minutes, where the old workspace would have offered a folder of near-identical images and a hopeful memory.

Nothing in that Thursday was dramatic, and that is the point worth ending the practical account on. No rescue was performed, no heroics were required, no client learned that their consultant’s memory had changed its home three weeks earlier. The system simply held, under load, in the ordinary way that a system must hold a thousand times to earn the name. Migrations are usually narrated as journeys, with a departure and an arrival. In a working practice they are better understood as renovations carried out while living in the house: noisy for a fortnight, dusty for a month, and then — if the measuring was honest and the verification was real — simply the way the rooms are arranged now, so unremarkable that the owner stops noticing the arrangement and goes back to noticing the work. Jonas’s clients pay him to notice the work. The vault’s whole virtue, on the evidence of that Thursday, is that it lets him.

The Honest Limits: What the Vault Will Not Do for You

A guide that has spent this long praising a destination owes its reader a consolidated account of the destination’s refusals, gathered in one place rather than scattered as asides. VaultBook does not sync. There is no peer-to-peer elegance, no encrypted backup node, no background reconciliation between the laptop and the desktop: there is a file, and copies of the file, and the owner’s discipline in knowing which copy is current. Jonas manages this with a rule so simple it sounds like a joke until it has saved him once — the vault lives in one named place, moves between his two machines on a small encrypted drive he physically carries, and is never edited in two places within the same day. A worker whose material is born on three devices before breakfast will find this not a limitation but a disqualification, and should weight Anytype’s sync, or a cloud leader’s, accordingly.

VaultBook does not model. There are no types enforcing their relations, no schema refusing a malformed entry, no computed set guaranteeing that every object matching a condition has been gathered. Labels can be forgotten. Sections can be skipped. A Kanban card can sit in a column its entry no longer deserves. Every guarantee the object model offered automatically must be re-earned in the vault as a habit: the template followed, the weekly review performed, the titling convention honoured. Jonas judges this a fair price because the habits are visible and the failures are his own, but a reader who knows their own discipline honestly — who knows the weekly review will not survive a busy quarter — should hear the warning inside the description. A system that relies on habits you will not keep is worse than a system whose taxes you resent. Resentment, at least, still pays.

VaultBook does not collaborate, capture from the whole internet, or recognise handwriting as a first-class citizen. Clients cannot be invited into a shared space to watch a draft ripen; drafts travel to clients as documents, through the clients’ own channels, and return as comments to be filed. Web material arrives by the owner’s hand, saved and attached deliberately, not clipped by a browser button. Sketches, annotated printouts and whiteboard photographs enter as images — searchable by their metadata, viewable in the Photo and Video Explorer, but not converted into structured diagrams by any magic. The Reader and the data visualisation tools serve the documents and figures the practice already has; they do not conjure new kinds of input. And the vault’s search, for all its reach into attachments and transcripts, answers as a librarian rather than as a database: it finds and ranks, it does not aggregate, total or pivot. The consultant who needs a computed total over three hundred uniform records needs a different instrument for that task, and Jonas keeps a spreadsheet for exactly those rare moments, filing its results back into the vault as entries like everything else that matters.

Finally, the vault concentrates risk even as it distributes control. One file holding an entire practice is one file whose loss would be total, whose corruption would be catastrophic, and whose backup discipline is therefore not an administrative detail but a load-bearing wall. Anytype’s sync, whatever its frictions, meant copies existed on several devices by default. VaultBook’s owner must manufacture that redundancy deliberately — the backup rhythm in the next section is not optional garnish on this migration, it is half of it — and must also reckon with the human fact that a single passphrase now guards the sealed core of a livelihood. The vault gives its owner nobody to blame and nobody to call. For Jonas, that was the point. A reader should adopt it only if it is also, on reflection, theirs.

The First Month: Habits That Replace a Schema

The migration ended on a Monday; the first month is where it was won. Jonas’s experience, offered here as a template rather than a testimony, divides into four weekly disciplines, each one replacing a function the old model had performed automatically. The first is the capture discipline, practised daily: everything new enters the vault as an entry first and an organised entry second. A fragment from a call is written immediately under a working title, wearing only its client label; classification into kind, product and board happens in a ten-minute filing pass at the end of the day, when the fragment’s meaning has settled. This two-step rhythm — write now, organise tonight — is the direct antidote to the modelling tax, and its success is measurable in the absence of a holding pen: there is no backlog space in the vault, because nothing waits more than a few hours for its labels.

The second discipline is the board review, performed on Monday mornings in the four minutes already described and again, more slowly, on Friday afternoons, when cards that claim to be blocked are interrogated and cards delivered during the week are checked against their entries for the evidence of delivery. The Friday pass also empties the week’s interim captures — the phone scribbles, the paper notebook pages photographed and filed, the documents clients sent through their own portals and Jonas downloaded into the vault with proper names. A week is the longest any material is allowed to live outside the vault, because a fortnight’s backlog is a project and a week’s is a chore, and the difference between a system and a mess is usually exactly that ratio.

The third discipline is the terminology and template audit, performed once in the month and monthly thereafter: a sample of term entries read against their fixed section template, a sample of new entries checked for the titling convention, and the label vocabulary itself reviewed for drift — new labels created in haste are merged or renamed in this pass, before the vocabulary grows a dialect. This is the schema maintenance Anytype used to demand continuously, compressed into a scheduled hour where it can do no harm to a deadline. The fourth discipline is the backup rhythm, and it is stated here in full because it carries the weight the limits section assigned it: the vault file is copied at the close of every working day to a second drive in the office; once a week, the copy travels to an encrypted drive kept off the premises; once a month, a copy is made alongside a plain-language note recording the VaultBook version, the date, and the state of the practice, so that a future opener — Jonas in five years, or an executor in worse circumstances — meets context rather than a bare file. The frozen Anytype exports rest beside the monthly copies, unopened and unneeded, the monument beside the house.

By the month’s end, the measurable shape of the practice had changed in ways Jonas had not predicted. Capture had sped up, as expected. Retrieval of context — why is this worded this way, who approved this structure — had sped up more, because context now lives in prose at the top of the entry it concerns instead of in relation values distributed across a graph he had to query correctly to read. Cross-client awareness had improved in a direction he had not sought: with every client’s work wearing its label inside one vault, the practice-level questions — total load, overlapping deadlines, reusable solutions built for one client that another client’s problem resembles — became answerable by search and label in a way five separate spaces had always resisted. And the modelling hour, the Sunday session of schema repair, had simply vanished from his week, returned to him as time in which he read about technical illustration for pleasure. Migrations are usually justified by what they fix. His is justified, in the end, by what it stopped charging.

A Shorter Path for Readers With Smaller Workspaces

Not every reader arrives with four years, five spaces and a fortnight to spend, and the method in this guide compresses without changing its character. A workspace of a few hundred objects, held by one person for their own work, can be moved in a weekend if the sequence is respected: an hour of audit on Saturday morning, counting types and grading material with the same four fates; exports in both formats before lunch, with files included and a copy put somewhere separate; the translation map written on one page before any rebuilding begins, because even a small migration improvised entry by entry will contradict itself by Sunday. The rebuild itself goes fastest when it is organised by type rather than by space — all the meetings together, while the meeting template is fresh in the hands; all the sources together; all the projects last, because project entries link to everything else and benefit from arriving in a vault that already contains their neighbours.

Three shortcuts are safe, and three are not. It is safe to let archive material travel as consolidated entries rather than object by object, provided the native export is kept as its cold reference. It is safe to rebuild only the wiki links that current work actually follows, leaving historical references as plain text. It is safe to postpone the encryption pass by a day or two, provided the list of entries destined for sealing is written during the rebuild and the sealing is verified before the old workspace is closed. It is not safe to skip the counts, because a small workspace’s discrepancy is exactly as silent as a large one’s. It is not safe to trust the Markdown export to have carried relation values it has demonstrably left behind in workspace after workspace; check one richly related object early, learn your export’s true behaviour on your own data, and plan around the evidence. And it is not safe to delete the old installation in the first flush of success. Storage is cheap, regret is expensive, and the frozen source is the migration’s insurance policy, its reference library and its proof — to clients, if ever asked — that the move was a relocation and not a bonfire.

Readers whose workspaces are shared should read this guide with one extra caution. Jonas’s practice was his alone; his client spaces held his notes about collaborations, not the collaborations themselves. A workspace that several people actively maintain in Anytype, with its shared spaces and its peer-to-peer habits woven into a team’s week, presents a social migration layered over the technical one, and the destination in this guide — a personal vault, deliberately without live collaboration — fits only the members whose role is, like Jonas’s, to hold a private working memory beside the team’s shared surface. For them, the move described here can proceed one person at a time, vault by vault, without asking the team to change anything. For a team seeking a new shared home, this is the wrong guide and VaultBook, honestly assessed, is the wrong destination. Knowing which migration you are in is the first entry in the audit.

What Changed, and What Did Not

It would be tidy to end with transformation, but the honest ending is narrower and more useful. Jonas’s clients noticed nothing. The portal documentation shipped on its cadence, the device instructions passed their review, the quarterly release notes arrived with their usual mixture of clarity and apology. The same judgement, the same terminology memory, the same care with other people’s confidential material did the work, as it had before. What changed was the cost of keeping the practice’s memory in a condition to support that work: an hour here, a hesitation there, a schema held in the head, a set quietly doubted — a hundred small withdrawals, refunded. What changed was where the memory lives: in one file, on his drives, under his passphrase where it matters, readable by any browser, beholden to no account, no server, no sync protocol and no roadmap. What changed was the shape of trust. He no longer trusts a model to have gathered everything. He trusts his own labels, his own boards, his own verification log, and a search that reads the actual words — a humbler machinery, inspected more often, failing only in ways he can see.

Anytype remains, on his machine and in his respect, the most thoughtful attempt he has used at making knowledge behave like a graph. For the worker whose material rewards that ambition — whose questions are computed, whose devices must reconcile without a centre, whose structure is the substance — it may still be the right home, and this guide’s account of its export behaviour and modelling costs is offered as planning information, not as an indictment. But for the consultant whose product is finished prose, whose clients’ secrets sit in his notes by contract, whose organisation must be legible at a glance on the worst morning of the quarter, the trade Jonas made has a clear shape. He gave up modelling power he was paying for daily and using weekly. He gave up sync he rarely needed. He received immediacy, legibility, per-entry encryption and a file that is simply, entirely, his. Four years of objects became entries. The relations became sentences a future reader can understand without learning a schema. The sets became boards that cannot lie to him silently. And the workspace became a vault — smaller in ambition, larger in trust, and open every morning without asking anyone’s permission, including the internet’s.

Want to build your second brain offline?
Try VaultBook and keep your library searchable and under your control.
Get VaultBook free