DEV Community

Pocket PDF
Pocket PDF

Posted on

The 'no upload' privacy claim you can verify in 30 seconds

I don't think a website should get to call itself private just because its homepage says "100% secure."

That sentence doesn't tell you much.

I've seen browser-based file tools use privacy as their main selling point without giving visitors a particularly easy way to verify what actually happens to their documents.

I run Pocket PDF, and one of the things I care about is keeping file processing on the user's device.

But rather than asking someone to trust a marketing sentence, I'd rather show them how to check.

You don't need special software. You don't need to understand backend infrastructure. You just need a browser.

The 30-second Network tab test

Here's a simple test you can perform on a browser-based PDF tool.

Open the website.

Press F12 to open Developer Tools.

Select the Network tab.

Enable Preserve log if needed.

Filter requests by Fetch/XHR.

Select a PDF file around 5 MB.

Run a processing operation.

Now watch the requests.

If the tool processes the document locally, you shouldn't see a request containing the document's file bytes being sent to a processing server.

There may still be requests for scripts, stylesheets, fonts or other website resources.

The important distinction is between loading the application and uploading the user's document.

For my own tools, I use this test to check that document processing isn't quietly sending files through an API.

You can also inspect request payloads and request bodies if you want to go further.

A request existing doesn't automatically mean a document was uploaded. You need to inspect what the request actually contains.

Try it offline

There's another test.

Open the tool while connected to the internet and let its required resources load.

Then disconnect your internet connection.

Try processing a document.

Pocket PDF is built around static pages, PDF.js and WebAssembly-based processing engines. Its service worker caches application resources, including HTML, CSS, JavaScript and required engines.

It does not cache users' documents.

Once the necessary application resources are available, many operations can continue without an internet connection.

This is a useful way to distinguish an application that processes files locally from one that merely presents a browser-based interface for a remote processing service.

There is one important limitation: not every operation can be expected to work offline before its required engine has been downloaded and cached.

Offline support depends on the resources the particular tool needs.

Why "browser-based" is overloaded

This is where I think the terminology becomes misleading.

A tool can run inside a browser and still upload your documents.

For example:

The website displays a file picker.

You select a PDF.

JavaScript sends the file to a server.

The server processes it.

The result is returned to your browser.

Technically, you interacted with a browser-based website.

But the actual document processing happened remotely.

There's nothing inherently wrong with server-side processing. Some operations genuinely need it.

The problem is presenting browser-based as if it automatically means local processing.

Those are two different claims.

What local processing actually protects

With my current architecture, documents are processed using browser-side technologies rather than being sent to a document-processing backend.

That reduces the number of places a document needs to travel.

However, I don't think it's honest to turn that into an unlimited privacy promise.

There are still risks.

Browser extensions with sufficient page access can potentially inspect information on a page. A compromised operating system or device can expose files before or during processing. Malware and malicious browser software remain relevant threats.

Local processing doesn't magically protect someone from a compromised computer.

It also doesn't mean the website never makes network requests. The application still needs to download its resources.

A practical standard for privacy claims

If you're building a file-processing website, I'd suggest three things:

Make the processing architecture understandable.

Let users inspect network activity themselves.

Avoid promising protection against threats your application cannot control.

For visitors, I'd suggest testing with a harmless sample document first.

A 5 MB PDF is enough to make the Network tab exercise meaningful. Watch for requests containing file data, inspect their payloads, and repeat the test after processing.

You shouldn't need to trust a badge on a homepage.

You should be able to verify the behaviour yourself.

When you use an online file tool, do you actually check its network requests, or do you usually take its privacy claims at face value?

Top comments (0)