What Actually Happens to Your Document: The Case for a Client-Side Markdown Editor

Short answer: in a client-side editor, your document never crosses the network at all. Parsing, rendering and saving happen inside the browser tab, and the file stays on your disk. In a server-rendered editor, every render is an upload — your text reaches the vendor's infrastructure before it reaches your screen, and it can persist there in logs, caches and backups long after you close the tab.

That distinction is invisible from the outside. Two tools with identical interfaces can sit on opposite sides of it, which is why it is worth asking, before you paste an unreleased architecture spec into a browser tool: between the file on your disk and the pixels on your screen, where does that text actually go?

This article answers it for Prisment specifically — the architecture, the exact network traffic, a five-minute test you can run yourself, everything we do measure, one claim we got wrong and had to delete, and where the guarantee stops. Prisment is free, requires no account and charges no recurring fee; the full privacy policy is one click away and states the same things this article does.

---

1. Three ways to build a browser document tool

Every web-based Markdown tool is one of three architectures, and only one of them keeps your text off the network. They look identical from the outside, so the table is the fastest way to tell them apart.

The middle column is the one that catches people out. "Renders in your browser" is a true statement about a tool that then posts every keystroke to a sync endpoint. The question that separates the columns is not where is it rendered but what leaves the machine, and when.

---

2. Prisment has nowhere to put your document

Prisment compiles to static files — there is no application server, no database and no API route, so there is no endpoint that could accept a document. The strongest privacy guarantee is not a policy; it is an architecture in which the unwanted thing is not possible to do.

The whole application is a static export: HTML, CSS and JavaScript served from a host and a CDN. When you open a .md file, the bytes are read by JavaScript already running in your tab, parsed there, highlighted there, and painted there. The KaTeX engine and the Mermaid renderer run in the same sandbox. No step in that chain could send a document anywhere, because nothing is listening on the other end.

Here is the complete network picture, including the parts most privacy pages leave out:

Diagram

100%

Read the dotted arrows carefully, because they are the whole disclosure. Three things cross the boundary, and none of them is your content: the app's own code coming down, an exported page fetching its stylesheet, and two aggregate feature events going up. The solid arrows — your file, your edits, your rendered document, your export — never leave the box.

---

3. How the file gets in without going out

The browser's File System Access API hands the page a permission-scoped handle to one folder you chose, and reads and writes go straight between the tab and your disk. No cloud proxy sits in between, and no copy is staged anywhere on the way.

Mounting a folder is where local-first tools usually break down, so the mechanism is worth being specific about. You click Open Local Folder, the browser shows you its own picker, and it grants the page access to that one directory. The permission is granted by you, scoped to that folder, mediated by the operating system, and revocable at any time from the address bar.

That same handle is what makes Cmd+S write back to the real file. The document you are editing is the file on disk — not a copy of it in someone's bucket that syncs back if the connection holds. Everything downstream inherits the property: the two-way visual editor, the presentation styles, and HTML export all run against local state.

---

4. Verify it yourself in five minutes

Do not take the claim on trust — watch the network while you work, then pull the connection and keep working. Both halves of the test run in your own browser, and neither needs anything installed.

The network test.

1. Open the app and the developer tools. Open the workspace and press F12, or Cmd+Option+I on macOS.
2. Clear the Network tab. Switch to it and clear the list, so you are only reading traffic your own actions caused.
3. Do the work you care about. Open a local file or drag one in, type into it, change the presentation style, and export it to HTML.
4. Read the request list. Check every request for your content.
5. Run the offline test. Set throttling to Offline, or switch off Wi-Fi, and reload the page.

What step 4 shows, and what it does not:

Step 5 is the more convincing half, because it requires no inspection at all. Offline, the app comes back — its shell is cached by a service worker — and you can still open a file, edit it, render diagrams, switch styles and save to disk. A tool that renders on a server cannot pass that test, and no amount of policy copy changes it.

---

5. What we do measure, stated plainly

Prisment measures aggregate usage and never document content: page views and two feature events on the website, an anonymous daily-active signal in the desktop app, and nothing at all in an exported file. An article about privacy that only lists guarantees is marketing; here is the other half.

Three notes on that table, because the details are where privacy claims usually go soft.

• "Aggregate" means what it says. The events record that an export happened, never what was exported: no document title, no length, no file name, no hash of the content — nothing that could be joined back to a document.
• The desktop build strips the web tags entirely. Google Analytics and the ad tag are compiled out of it; the desktop app talks only to its own anonymous telemetry endpoint, and only while you leave it switched on.
• An exported page is not a fully offline bundle. It pulls its stylesheet and viewer runtime from cdn.prisment.io the first time it is opened, then caches them. That request tells the CDN a page was opened; it does not carry the document, which is already inside the file. For a recipient who must open it with no network contact at all, use Print / PDF — that copy is genuinely self-contained.

---

6. Why we say "zero document tracking" instead of "zero tracking"

We scope our privacy guarantees strictly to what matters — your documents — because our hosted marketing website uses Google Analytics for aggregate visitor counts. An exaggerated privacy claim that overreaches destroys credibility the moment a reader opens their browser's Network tab.

Earlier marketing copy claimed "zero tracking and zero cloud uploads." While documents were genuinely 100% client-side, the hosted website loaded Google Analytics to measure aggregate page visits. Rather than hiding behind marketing spin, we deleted the unqualified claim and bound our guarantees to verifiable technical facts:

• Document text, file names, and contents are never tracked, uploaded, or stored.
• Telemetry is strictly aggregate (counting total page views and download button clicks).
• Desktop builds ship zero advertising or analytics SDKs, with an optional daily-active ping that can be disabled anytime.
• Automated regression tests guard our copy, ensuring marketing text never promises "zero site tracking" while web analytics remain active.

---

7. Where the guarantee stops

Client-side rendering removes the vendor from your threat model. It does not remove your machine, your browser extensions, or what you do with the exported file. A boundary you cannot describe is a boundary you cannot rely on.

What it does protect against:

• Your document sitting in a third party's storage, logs or backups.
• A vendor breach exposing work you never intended to publish.
• Retention you did not agree to and cannot audit.
• A subpoena served on a company that holds your text.
• The plain accident of pasting an internal spec into a tool whose terms you never read.

What it does not protect against:

• A compromised machine — nothing running on it is safe, and that includes this.
• A malicious browser extension, which can read the DOM of any page you open.
• A shared or unlocked computer.
• What you do with the output: an exported HTML page is a file like any other, and emailing it to the wrong person is not something an architecture can prevent.

Local-first shrinks the trust surface; it does not eliminate it. You still trust your browser, your operating system and the extensions you install. What you no longer have to trust is a vendor's retention policy, their breach response, or their promise to delete something you cannot verify was deleted.

---

8. What you give up (nothing that matters)

The usual trade for privacy is capability, and that trade is not being made here — everything Prisment does, it does locally. That includes presentation-grade styling with five built-in themes, interactive Mermaid diagrams and KaTeX, a sortable CSV grid, JSON and YAML views, OpenAPI specs rendered as browsable API documentation, multi-file workspaces with live disk sync, and export as single files, interlinked offline wikis or PDF.

It holds for the workflow that made all of this urgent, too. Terminal AI agents now write threat models, architecture RFCs and API specifications straight into your repository, and those files are frequently the most sensitive documents a team owns. Previewing them live as the agent writes is only safe if the preview stays on the machine.

---

9. Summary

The privacy question for a document tool is not "do they promise not to look?" but "is there anywhere for the document to go?" Answer it structurally — static files, no backend, browser-sandboxed rendering, direct disk access — and the promise stops being a promise and becomes a property of the build.

Then check it. Open the Network tab, watch nothing happen, pull the plug and keep working. Do that with every tool you hand a confidential document to, and the good ones become easy to tell apart.

Prisment is free, needs no account, and runs in your browser or as a native desktop app. Open the workspace, read the full privacy policy, or download the desktop build.

Related reading

• Turning raw AI Markdown into presentation-grade HTML — what the local renderer produces once privacy is settled.
• Standalone HTML & offline wiki export — what an exported file carries, and which option is genuinely offline.
• Live Markdown previews for AI CLI agents — keeping agent-written specs on the machine that wrote them.