What really happens to a file you 'delete' from a website
'We delete your files after an hour' sounds reassuring, but it's a promise you can't check. Here's what really happens to an uploaded file, and the only version you can be sure about.
You upload a document to an online tool, it does its thing, and a reassuring line says your file will be deleted after an hour. You close the tab and feel fine. But what actually happened to that file, and what does “deleted” really mean once it’s on someone else’s servers? It’s worth looking at, because the comfortable answer and the honest one aren’t the same.
“Deleted” is a promise, not a guarantee
Here’s the core problem: once your file is on a server you don’t control, you have no way to verify anything about it. The “deleted after one hour” message is a policy statement. You’re trusting it the way you trust any sentence on a website. There’s no receipt, no confirmation, no way for you to check that it actually happened.
That doesn’t mean every service is lying. Many genuinely try to delete files on schedule. The point is narrower and harder: you cannot confirm it. You’re taking it on faith, and “trust me” is a weak foundation for anything sensitive.
Where a copy survives after “delete”
| Where | Why it is still there |
|---|---|
| Backups | Made on a schedule; the delete does not reach back into yesterday’s snapshot |
| Object storage versions | Many buckets keep previous versions on purpose |
| CDN and proxy caches | A copy served to someone else can outlive the original |
| Logs | Filenames, sizes and timestamps survive even when the bytes do not |
| Sub-processors | The delete has to propagate to everyone the service passed it to |
| The disk itself | Marking a block free is not overwriting it |
Where a “deleted” file can linger
Where a “deleted” file can linger
Even with good intentions, a single delete is rarely the whole story of a file’s life on a server:
- Backups. Servers get backed up routinely. A file deleted from the live system can persist in a backup snapshot for days or weeks, by design, with no malice involved.
- Caches and copies. Files move through caches, temporary storage, and content delivery networks. A “delete” on the main store doesn’t always reach every transient copy instantly.
- Logs. Even if the file itself goes, records about it, when it was uploaded, from where, its name, its metadata, can sit in logs that outlive the document.
- Third parties and jurisdiction. The service may run on infrastructure rented from someone else, in a country with different rules. Your file’s fate is now governed by a chain of parties you’ve never heard of.
None of this requires anyone to be acting in bad faith. It’s just how server infrastructure normally works. “Deleted” is messier than a single confident sentence implies.
And that’s the good case
The above assumes a careful, well-meaning service. The same upload also exposes you to the bad cases: a breach that leaks stored files, a change in the company’s policy or ownership, a legal demand for data, or simply a service that was never as careful as its homepage claimed. Once the file has left your hands, all of these are out of your control.
The only file you can be certain about
There’s exactly one version of a PDF whose fate you can be completely sure of: the one that was never uploaded. A file that never left your machine has no backups on a stranger’s server, nothing in anyone’s logs, no exposure to a breach you’ll read about next year. There’s nothing to delete because there was never a copy to begin with. That’s not a stronger promise; it’s the absence of needing one.
This is the whole idea behind reader.me. The tools run in your browser, on your own device. When you merge, compress, or protect a PDF, the file is read into memory on your machine, processed there, and saved back to you. It is never uploaded. You don’t have to trust a deletion policy, because there’s no server copy whose deletion you’d need to trust.
And you can verify that, which is the part an upload-based tool can never offer. Open any reader.me tool, open developer tools (F12), and watch the Network tab while you work, you’ll see nothing leave. Or turn off your internet entirely and use it offline. It still works, which is only possible because the file was never going anywhere.
The takeaway
“We delete your files” asks you to trust a promise you can’t check, about copies you can’t see, on servers you’ll never visit. For a holiday photo, fine. For anything that actually matters, a contract, a medical record, an ID, the better answer isn’t a better promise. It’s not uploading the file at all. Do the work in your browser, and the question of what happens to your file on someone else’s server simply never comes up.
Frequently asked questions
When I delete a file from a website, is it really gone?
The record of it usually goes. The copies often do not, at least not immediately: backups run on a schedule and hold yesterday's version, object storage frequently keeps previous versions on purpose, caches may hold what was served, and logs keep filenames and timestamps regardless. Deletion in a distributed system is a process, not an instant.
What about services that promise deletion after an hour?
Take them at their word — most mean it — but understand what kind of promise it is. It is a commitment about behaviour, dependent on the schedule working, the backups rotating and every sub-processor honouring it. That is a reasonable thing to rely on for a flyer. It is a different proposition for a payslip or a medical record.
So which file can I be certain about?
The one that was never uploaded. It is the only case where deletion is not a promise but a fact: there is no server-side copy to expire, no backup to rotate out, no log line to keep. Nothing can be retained that never arrived.
How do I check whether a tool uploads my file at all?
Open DevTools with F12, go to the Network tab, tick Preserve log and run a real task. An upload shows as a request carrying your document, and it is hard to miss. The blunter test is to load the page, disconnect from the network and try anyway: a local tool finishes, a cloud one stops.