Appaji - Software Engineer

Ever noticed how some people on the internet seem to perfectly predict the future? You’ll see accounts confidently declaring “This IPO will completely tank” or “This company is going to the moon.” Then, suspiciously, the posts that got it wrong quietly disappear, leaving behind a pristine timeline of seemingly psychic predictions.

Take a look at this tweet highlighting the phenomenon:

it’s still better than the people who post opposing takes then delete one later before retweeting the correct one. or who post things encrypted then never drop the key unless they were right.

someone should make a nostradumbass buster with the x api.<br>— David Schaub (@dsnein) August 3, 2026

This creates a messy secondary problem. It’s not even that silent deletions happen constantly. It’s just that they are so easy to pull off. That alone leaves a permanent sliver of doubt. And because that doubt exists, it’s trivially easy to fake a screenshot of a “deleted post” to ruin someone’s credibility. As an audience, we are left in a bind: do we trust the original poster who claims they never said it, or the person holding the screenshot? Without any “negative proof” to validate either side, it just becomes a guessing game.

How do we actually tackle this?

I was thinking about this last week and sketched out an architecture. I think the design is solid enough that I’m half-tempted to build it myself. I figured I’d put the idea out here to get a second pair of eyes on it and see if it holds water.

Here’s the claim: not even a government takedown order can make a post un-happen. Delete it from every server I own, get a court to sign off on it, doesn’t matter. The post survives, permanently, provably. I want you to try and poke a hole in that.

Let’s build this iteratively by exploring the attack surfaces.

1. What if user wants to delete a post? What if government orders to take down a post?

Nope. User can’t delete a post. Platform disallows user-driven EDITs and DELETEs.

If your first thought is, “Just disable the UPDATE/DELETE endpoints in the backend”, I’m going to stop you right there. That’s just a promise, and promises can be broken by whoever controls the database.

Think about it: how do you actually know a platform like X.com isn’t secretly deleting posts? I know I’m making an impractical, borderline-conspiracy allegation here, and they probably aren’t doing it. But in theory and technically, it is absolutely possible. If they wanted to quietly edit the history for just 1% of their users, there is nothing systematically stopping them. They own the database.

So, it can’t just be a backend rule. It has to be immutable by design.

Instead, what if we take the raw bytes of the post (text, image, video attachments), hash them, and push that hash to a public blockchain?

This means anyone can download the post contents, run the hash themselves, and verify the proof of existence on the ledger. Even if I completely wipe it from my servers.

import hashlib<br>import json

def generate_immutable_proof(user_id, content, media_bytes):<br># Construct a deterministic payload<br>payload = {<br>"user": user_id,<br>"text": content,<br>"media_hash": hashlib.sha256(media_bytes).hexdigest() if media_bytes else None

# Serialize and hash the entire post state<br>serialized = json.dumps(payload, sort_keys=True).encode('utf-8')<br>post_hash = hashlib.sha256(serialized).hexdigest()

# Only this hash goes to the blockchain, not the heavy payload!<br>return post_hash

Obviously, the platform itself won’t allow edits or deletes on a post. But say a government orders me to take one down to keep operating in that country. Comply or get banned, no real choice there.

So I remove it from the DB. The URL 404s. I say I don’t have the data anymore, and technically, I’m right. There’s no post data on the blockchain either, just a hash.

So who actually has the data? Users, on their own machines. How does it keep circulating? Through other social media. Government can go ask them. Not my problem anymore, I deleted it.

Anyone who downloaded the post before I pulled it can still prove it existed. Hash it, compare against the chain, done. There’s no faking it, and there’s nothing I can do to stop it.

Obviously, we can’t expect users to manually stitch together JSON and run SHA-256 commands by hand. So the platform itself provides a “Download Proof” button on every post. Clicking it gives you a ZIP file containing the raw post text, media attachments, the cryptographic signatures, and a small standalone Python or bash script.

Run it locally, and this is basically all it does:

# verify_proof.py — runs entirely offline except the last line<br>post_hash = hashlib.sha256(load_local_files()).hexdigest()<br>onchain_hash = query_blockchain_node(post_hash)

assert post_hash == onchain_hash, "Proof failed — hash not found on chain"<br>print("Verified: this post existed and is unaltered.")<br>The beauty of this: the script never hits the platform’s servers. Even if my entire...