You wrote the runbook. You linked it in three channels. Two sprints later someone pings you: "Hey, is this doc still right?" And you already know the answer is no, because the only person who ever opened it was you, on the day you wrote it.
This is the standalone wiki problem. Confluence, a separate Notion workspace, a folder of Google Docs. The content is fine. The location is the bug. Documentation that lives in a different tool than the work it describes drifts out of date the moment you hit publish, because updating it means context-switching away from the thing you're actually doing.
For technical writers and engineering leads, that drift is the whole job hazard. You're not paid to write docs once. You're paid to keep them true. And a wiki that nobody opens during the work is structurally impossible to keep true.
Key takeaways
- Standalone wikis rot because reading and editing them requires leaving the work. Distance is the root cause, not laziness.
- Docs that live next to the board get opened in the natural flow of work, so they get corrected when they're wrong.
- Real-time collaborative editing (built on CRDTs) means a writer and an engineer can fix the same doc at once without overwriting each other.
- Nested pages and inherited permissions let documentation mirror how your projects are actually structured.
- The goal isn't more docs. It's docs your team trusts enough to act on without double-checking.
The real reason your wiki is stale
Engineers don't avoid documentation because they hate writing. They avoid it because of the tax. The doc lives in Confluence. The work lives in the issue tracker. Updating the doc means: stop coding, open a new tab, find the right space, find the right page, remember the formatting, make the edit, switch back, lose your place.
That tax is small per edit and enormous in aggregate. So people skip it. The doc says the deploy process has four steps; production reality has six. Nobody updated it because updating it cost more attention than the moment could spare.
A technical writer can fight this with process. Review cycles, doc owners, quarterly audits. It works, sort of, until headcount shifts or a launch eats the quarter. Process is a tax on top of a tax. The underlying distance is still there.
The most accurate documentation is the documentation that's easiest to fix the instant you notice it's wrong.
What changes when the doc lives next to the work
Now imagine the runbook is a page that sits in the same workspace as the board tracking the release. The engineer moving cards across that board doesn't switch tools to read it. They don't switch tools to fix it. The doc and the work share an address.
When the deploy gains a step, the person who hit that step is already in the same place. Fixing the page is a few keystrokes away from the card they were just looking at. The tax drops toward zero, and edits that used to never happen start happening on their own.
This is the quiet argument for keeping documentation and project work under one roof. It's not about features on a comparison grid. It's about removing the gap that makes docs go stale in the first place.
Rich text that doesn't fight you
Proximity only helps if the editor is good enough to actually write in. A doc surface built on a modern rich-text engine handles the things technical writers need without ceremony: headings, lists, nested structure, attachments for the diagram or the spec, cover images so a page reads like a real document and not a sticky note.
The point is that writing the doc feels like writing, not like fighting a markup syntax or a clunky table widget. The lower the friction to author, the more likely the doc gets authored at all.
Two people, one page, no overwrites
Here's where standalone tools quietly fail teams. A writer is cleaning up the onboarding guide. An engineer realizes one section is wrong and wants to fix it now. In a lock-based editor, one of them waits, or worse, one of them overwrites the other's work and nobody notices until later.
Real-time collaborative editing built on CRDTs solves this at the data layer. Both people edit the same page at the same time, and the changes merge without conflict. You can see who else is on the page with you through live presence, so you're not editing into a void. The writer polishes the prose while the engineer corrects the facts, in the same minute, on the same page.
Most documentation tools still treat collaboration as "we both have access." True real-time editing is rarer than the marketing copy suggests. It's the difference between a shared document and a document you actually share.
Structure that matches your projects
Technical documentation isn't flat. There's the architecture overview, and under it the service docs, and under those the runbooks. Nested pages let your documentation hierarchy mirror the shape of the system it describes, instead of forcing everything into one long page or a tag soup.
Permissions follow the same logic. Page access can inherit from the workspace or the parent page, so you set the boundary once at the top and the structure underneath respects it. A writer can grant viewer, commenter, editor, or owner roles per page when a specific doc needs a different audience than its parent.
Standalone wikis aren't wrong. They're just far away.
None of this is a knock on Confluence or Notion as writing tools. They're capable. The issue is architectural: when your docs and your work live in separate applications, you pay a switching cost every time you want to keep them aligned, and that cost compounds into staleness.
Putting documentation next to the board doesn't make your team write more. It makes the writing they already do stay accurate, because correcting a doc stops being a detour and becomes part of the same motion as the work.
For an engineering lead, that means the runbook your on-call engineer opens at 2am is more likely to be true. For a technical writer, it means you spend less time chasing drift and more time on docs that matter. Same documentation discipline, far less distance to fight.
FAQ
What does "real-time pages" actually mean?
Documentation pages that multiple people can edit at the same time, with changes merging instantly via CRDT technology. You also see live presence indicators showing who else is currently viewing or editing a page.
How is this different from a wiki like Confluence?
A wiki is a separate application from your project work. These pages live in the same workspace as your boards and cards, so updating a doc doesn't require switching tools. The closer the doc is to the work, the more current it stays.
Can a writer and an engineer edit the same doc simultaneously?
Yes. Real-time collaborative editing built on CRDTs lets multiple people edit one page at once without overwriting each other. The merge happens at the data layer, so there's no "who saved last wins."
Can I organize docs into a hierarchy?
Yes. Pages support nested parent-child structure, and permissions can inherit from the workspace or the parent page. You can also set per-page roles: viewer, commenter, editor, or owner.
Do I have to start every doc from scratch?
No. Page templates exist by category, including project, meeting, planning, and docs, so common document types come pre-structured.
Stop fighting drift. Keep your docs where the work happens. See how real-time pages work in Zoobbe at zoobbe.com.
Photo by Kelly Sikkema on Unsplash