Why processing files in your browser is not just a marketing line
A document tool that uploads your file creates a copy you do not control. Local processing removes that copy entirely, and changes the security model.

Every online tool that asks you to upload a file creates a copy of that file on someone else’s computer. Sometimes that copy is deleted after processing. Sometimes it is retained for hours, logged, cached, or backed up. You usually cannot verify which.
This is not an accusation of bad faith. It is a structural consequence of how upload-based tools work. Understanding it explains why local processing matters.
What uploading actually means
When you select a file on a web page and press a button, one of two things happens:
Upload model. The browser sends the file bytes to a server. The server processes them, returns a result, and disposes of the file according to its policy — which may involve temporary storage, a CDN, a processing queue, and backups. You rely on the operator’s word for what happens.
Local model. The browser reads the file into memory and processes it with your own CPU. The bytes never leave the machine. There is no server-side copy to delete because none was created.
Both can be implemented well or badly. But they have different failure modes.
The failure modes of the upload model
- Retention you did not intend. Files persist in a temp directory, a queue, or a log until a cleanup job runs — or does not run.
- Third-party processing. The server may call an external API, which creates yet another copy under a different policy.
- Account systems. A tool that requires no account today may add one later, with all the associated data.
- Breach exposure. A copy on a server is exposed to a breach in a way a file on your laptop is not.
- Analytics. File names, sizes, and metadata can end up in telemetry without anyone explicitly deciding to collect them.
None of these require malice. They are the normal risks of running a service.
What local processing changes
With local processing:
- The file is read via the browser’s File API into memory.
- Processing happens in JavaScript, WebAssembly, or a Web Worker.
- The result is created as an in-memory blob and downloaded to your device.
- Reloading the page discards whatever was in memory.
The security model shifts from “trust the operator” to “trust the browser sandbox”. That is a meaningful improvement because the browser sandbox is what you already rely on for every website you visit.
What local processing does not mean
Being precise matters here, and Doculven’s own privacy page states this plainly.
It does not mean offline. The page, the fonts, the JavaScript, and any model files still arrive over the network. You are still making requests.
It does not mean the browser keeps nothing. The browser caches decoded image buffers, may keep the downloaded file according to your download settings, and handles memory in ways the page does not control.
It does not protect you from your own extensions. A browser extension that reads page content operates outside the app’s control.
Honest local-processing documentation says all three things. A tool that claims “100% safe” without qualification is overselling.
Where it genuinely matters
Some documents should not be handed to an unknown server at all:
- ID cards and passports
- Medical records and test results
- Contracts and legal documents
- Photos of children
- Anything containing a signature
- Salary slips, tax documents, bank statements
For these, the difference between “uploaded and hopefully deleted” and “never left the device” is not theoretical. It is the whole point.
The practical test
If you want to know whether a tool processes locally, watch the network tab in your browser’s developer tools while using it. Look for requests that carry your file — typically POST requests with a large body — after you press the processing button.
Legitimate local tools make no such request. They may still fetch assets (fonts, models, libraries), and those are GET requests for public files.
This test takes thirty seconds and is more informative than any privacy policy.
The trade-off
Local processing is not free. The device must have the memory and CPU to do the work. A phone processing a 20-megapixel image with a neural network will be slower than a server with a GPU. Very large files may fail on low-end devices where a server would succeed.
That is a real limitation, and it is the honest cost of not uploading. For most everyday image and document tasks on a modern device, the trade-off is worth it.