Appearance
Real-time collaboration
Open the same page in two windows and type in both. The text merges character by character; you see the other caret move.
How it works, briefly
A page's live document is a CRDT — a data structure where two people's concurrent edits have one well-defined result, arrived at independently in both browsers rather than negotiated. There is no locking, no "somebody else is editing this", and no last-write-wins overwrite.
The server hosts a room per page. It relays changes between the people in it, and it also records them: a recorder on the server derives ops from what arrives and appends them to the log. That is why history, provenance and the timeline are complete without anybody pressing save.
Presence
You see who else is on the page and where their caret is. Presence is ephemeral — it is not recorded, and it is not history.
Attribution
Every op carries the account that made it. Who you are comes from the session and can never be claimed by a client, which is what makes provenance worth reading.
With sign-in off, each browser is an anonymous actor — enough to keep two people's writing apart, and not a claim about identity.
Saved means saved
Beside the connection pill, an indicator says whether your writing is saved — in the log the page is rebuilt from — and not merely sent:
| It says | Meaning |
|---|---|
| Saved | The server has written everything you changed into the log |
| Saving… | Sent, and not yet confirmed |
| Not saved yet | Unconfirmed for 30 seconds, or the server's log has stalled — you hear about it, not only the operator |
| Saved on this device | Offline; your writing is kept locally and will be sent when you reconnect |
| Not saved | Offline with no local copy — the one case where leaving the page warns you |
It never says Saved about anything the server has not confirmed, however recent. On a phone, while all is well, the pills shrink to their dot.
Writing that was sent but not yet recorded when a server died is carried by the tab until the server confirms it. And every change the app makes over HTTP carries an idempotency key and is retried across a flaky connection, so a merge or a proposal sent twice takes effect once.
Two tabs, one person
Open the same page twice and both tabs see each other's typing, and a change you make over the API — a merge, a restore — reaches your open tabs as well as everybody else's.
Markdown pages
A page written as Markdown is collaborative too, but a block is written by one person at a time: whoever is typing in it holds it, and the rest of the page stays open to everybody. Two people in the same block in the same instant never overwrite each other — one of them is written and the other is filed for review.
Coalescing
A burst of typing is one op, not one per keystroke. The recorder has an idle window; when you stop, the edit is written.
This is why the timeline and history read as a record of edits a person made rather than a machine transcript.
What is not real-time
Block content is. Everything else — creating, renaming, moving or trashing a page, editing properties, comments, sharing — goes through the API. Those are ordinary requests; they succeed or fail, and they need the server.
When access changes
An open page is asked again what you may do, rather than remembered: after any change in the workspace, and once a minute regardless. Removed from a workspace, moved to a role that may only read, a share withdrawn, a session signed out from Settings — any open page whose answer moved is closed or reopened read-only at once. See working offline for what that means when it is unreachable.
Two windows, one process
If you are testing locally: both windows must talk to the same server for the live document and the op log to agree. The app compiles the API's URL into its bundle at build time (NEXT_PUBLIC_NOTESFLOW_API), and the socket follows it automatically.