The Internet Doesn’t Remember — It Forgets. Here’s How to Fix It

--

Webpages disappear, links rot, and even archives fail. The real problem isn’t storage — it’s ownership.

People still say: “the internet remembers everything.”
It doesn’t.

For a while, many believed Google Cache had it covered. It didn’t — it was never an archive, just a temporary feature. Now it’s mostly gone.

The truth is uncomfortable.

According to Pew Research (2024):

• ~38% of webpages from 2013 are already gone
• ~25% disappear within a decade

And even when pages survive, their context doesn’t:

• up to ~70% of links break over time
• 23% of news pages contain broken links
• 54% of Wikipedia pages have at least one dead reference
• ~20% of social media posts vanish within months

The internet doesn’t crash —
it rots.

We tried to fix it

In 1996, the Internet Archive started capturing the web.

The Wayback Machine is one of the most important projects on the internet:

• billions of pages saved
• history preserved
• public access

If you’ve ever needed proof that something existed — you’ve probably used it. OSINT researchers and journalists rely on it daily to track deleted pages, statements, and changes over time.

But here’s the problem.

Memory is not the same as control

The Archive doesn’t store the internet.
It stores what it can access, what it’s allowed to keep, and what it manages to capture in time.

Even then:

• coverage is uneven
• social media is barely preserved
• short-lived content often disappears before it’s ever archived

And most importantly — it’s centralised.

Which means:

• one organisation
• one infrastructure
• one set of rules

Content can be:

• blocked
• restricted
• removed

Sometimes for good reasons. Sometimes not.

Either way — you don’t control it.

Press enter or click to view image in full size

The real problem isn’t storage

It’s ownership.

When something is archived:

• you don’t own it
• you don’t control access
• you can’t guarantee it will stay

This matters most when the content matters:

• investigations
• deleted statements
• controversial material

The kind of content that tends to disappear first.

Screenshots don’t solve it

Yes, you can take a screenshot.

But for anyone else, it’s just:

• an image
• with unknown origin
• trivial to fake

In the age of AI, that’s not evidence — it’s noise.

To make it meaningful, you need:

• when it was captured
• from where
• how
• by which system

You need a chain of custody.

But even that isn’t enough — if you create it yourself, it’s still just a file. It only becomes evidence when someone can formally verify how it was produced.

A different approach

Instead of asking:

“Where is this stored?”

ask:

“Who owns this record?”

Now the model changes:

• capture the content
• generate a verifiable record
• assign ownership immediately
• store it in decentralised systems

Not a central archive —
but a distributed set of owned proofs.

What blockchain actually gives you

Not hype. Not magic.

Just guarantees:

• when something was recorded
• who owns it
• which system created it
• that it hasn’t been altered

In this model:

• the smart contract = identity of the capture system
• the wallet = ownership

It doesn’t prove truth.

It proves something more useful:

provenance and integrity.

How it works (without the buzzwords)

• connect wallet
• enter URL
• system captures the page
• generates a certificate (metadata, environment, timing)
• you confirm
• it’s stored and minted as an NFT directly to your wallet — ownership is assigned immediately, not held by the platform

The NFT:

• links the screenshot and certificate
• assigns ownership
• proves origin

The key detail:

the server captures — but never owns.

Why ownership changes everything

There is no single archive anymore.

Each record:

• belongs to a user
• exists independently

To remove it, you don’t just delete a file.

You would need to:

• remove distributed storage
• break references
• affect many independent owners

In practice, that becomes very hard to do at scale.

“But can I trust the system?”

Good question.

Trust shifts from:
“do I trust this organisation?”

to:
“can I verify the process?”

Possible answers:

• open-source capture code
• transparent logic
• verifiable execution (e.g. cloud attestation)

The goal isn’t to prove truth.

It’s to prove:

this was captured in a consistent, verifiable way.

This is not just an archive

It’s something slightly different:

• part archive
• part notarisation
• part ownership layer

A system where:

• records are provable
• ownership is distributed
• deletion is no longer centralised

The shift

The Internet Archive gave the web memory.

But memory is fragile when someone else controls it.

The next step is:

memory that you own — and can prove.

Because today the real question is no longer:

“Did this exist?”

but:

“Can you prove it — and keep it?”

Links

Working prototype: https://app.screenft.com
NFT screenshot gallery (OpenSea): https://opensea.io/…
Project website: https://screenft.com

GitHub (open-source capture code): will be published after launch
Capture verification (cloud attestation / trusted execution): will be available after launch