2026-11-16 · 8 min read

Your Old Short Link Is a Pointer You Don't Own

Flat isometric diagram of a chain of glowing indigo link nodes on a near-black background, with one node replaced so the chain branches to a different destination, and a single green node marking the correct path.

On 24 July 2011, Burger King's account posted a tweet pointing followers to "our handy restaurant locator." The link in it was a Bitly short link: bit.ly/19BFiM. Fifteen years later, in November 2026, that same tweet sent readers to Wikipedia's list of Nazi concentration camps. Nobody broke into Burger King's account. Nobody edited the tweet. The destination changed because someone else registered the name.

It would be easy to file this under "shortener company has a bad week." That's the wrong lesson. This is a story about a category of identifier that every production system leans on, usually without thinking about it: the pointer you don't control. A URL looks like a value. It behaves like a function call to a server you don't run.

What actually happened, in numbers

Ransomnews went and checked. They pulled 97 Bitly links from Donald Trump's tweets between 2009 and 2013, from a public archive, and compared each one against Bitly's own link information pages — the ones you reach by appending a + to a bit.ly address, which show the destination and the creation timestamp.

  • 40 links were still the originals.
  • 49 had been created again later but still led where the tweet suggested — 48 of them within a 17-minute run on 26 May 2023.
  • 7 pointed somewhere else entirely.
  • 1 was blocked by Bitly as malicious.

Four of those seven were registered on 15 November 2026, between 07:49 and 09:57 UTC. They opened a Roblox profile, a YouTube video (twice), and a Wikipedia article about Trump and Jeffrey Epstein. One 2011 tweet carried three links to videos of his children. All three had been replaced.

The same morning, a link in a McDonald's tweet from June 2011 was registered again at 05:14 UTC. Burger King's followed 18 minutes later, at 05:32. Both were dead by the evening, after Bitly confirmed the issue publicly and suspended the accounts involved. By then CNN had reported the same pattern in old posts from Bill Gates, Justin Trudeau, Mike Pence, the FBI, and the US Department of Defense.

Bitly's help pages say a short code can't be reused, even after the account behind it is deleted, and in February 2025 the company was reported to have fixed a bug that allowed exactly that. Which is the genuinely uncomfortable part: the promise was written down, it was implemented, it was patched — and it still broke at scale on a random Saturday.

A link is a name, not an address

Here is the mental model worth carrying away. A URL has two halves that feel like one thing:

  • The name — bit.ly/19BFiM. This is a string. It is only meaningful because some registry agreed to associate it with something.
  • The resolution — where that name currently points. This is a decision made by whoever holds the registry today.

When you publish a name whose resolution is controlled by someone else, you haven't created a permanent reference. You've created a lease. The lease renews itself every time the registry behaves, and the terms can change when it doesn't.

That distinction matters more the moment a link leaves your control — printed on packaging, baked into a QR code, embedded in a PDF, cited in a legal filing, pasted into a tweet that outlives everyone who wrote it. Burger King's tweet was a marketing post from 2011. It is now an artifact that people will screenshot for as long as the platform exists.

You are renting pointers in more places than you think

Short links are the loudest example because they're public and embarrassing. The same shape recurs all over a normal stack:

  • Container image tags. myapp:latest or :1.4 is a name someone else can repoint. The digest is the address. If your deploy manifest says tag, you've specified a habit, not a build.
  • Package registry names. npm, PyPI, crates.io — names change hands when maintainers abandon them or sell them. Your lockfile protects you until someone runs an install without one.
  • GitHub usernames and org names. Usernames are recycled. Every doc, CI badge, and archived issue that says github.com/someuser/repo keeps the old string and inherits a new owner.
  • Object storage paths. Bucket names are globally unique across all AWS accounts. A URL you hardcoded to mycompany-assets is a global claim you either hold or don't.
  • Your own domain, eventually. This is the uncomfortable one. DNS is the pointer your entire stack trusts, and domain expiry is the same failure mode one level up.

None of these are bugs in those services. Registries are finite namespaces, and finite namespaces get recycled. The bug is treating a leased name as if you held the deed.

A three-question audit you can run this week

You don't need to fix all of this. You need to know which identifiers deserve permanence and which ones are allowed to rot. Run every externally visible identifier through three questions:

  1. Who can change where this resolves? If the answer isn't "only us, via a change we would have to approve," it's a lease. Write down the landlord.
  2. If it changed silently, how would I find out? If the answer is "a customer tells us," the detection time is measured in weeks.
  3. What's the blast radius? A dead marketing link in a 2019 blog post costs nothing. A repointed link in a security advisory, a compliance document, or a firmware download page costs a lot. Sort accordingly.

The third question is the one people skip. Not everything needs to be permanent, and pretending otherwise produces a maintenance burden with no payoff. The failure isn't having short-lived links. The failure is having short-lived links you told people were permanent.

What to actually do

1. Own the domain, rent the tool

If a link has to last, the domain in front of it must be yours — and the redirect should be served by infrastructure you control, not by a vendor's code path. Put the shortener's UI in front of it if you like the analytics, but the resolution should be yourdomain.com/x → destination, with the vendor nowhere in the chain that matters. You keep the name; the vendor keeps the convenience. If they part ways, you change one row in a database you own.

2. Separate printed identifiers from disposable ones

Maintain a short list — genuinely, a file in the repo — of identifiers that have left your control in a non-revocable way: anything printed, engraved, QR-coded onto hardware, embedded in a PDF, or cited by a third party. Those get the domain you'll still own in 2036 and a monitoring check. Everything else gets to be a normal link and nobody loses sleep.

3. Pin what must not move, monitor what might

For artifacts, pin the digest, not the tag. For published links, a synthetic check that resolves each one daily and compares the final destination against an expected host is roughly ten lines and one cron entry. That's the difference between finding out at 05:14 UTC and finding out from a journalist.

And when you're auditing someone else's old link — including your own — remember the trick from this story: append + to a bit.ly address and Bitly will show you the creation date. A 2026 creation date under a 2011 tweet is the whole diagnosis in one screen.

The trade-offs, honestly

Self-hosting a redirector means you now operate a service that has to stay up for as long as the content lives, and it will page you at 3 a.m. for something that earns no revenue. Owning a domain costs $10–20 a year, forever, plus the renewal you will eventually forget — which is why every serious org should have registrar auto-renew and a calendar entry, not just a good intention.

Digest pinning blocks silent repointing, but it also blocks silent security patches, so you need a bot to bump pins or you've traded one risk for another. And there's a real cost to permanence itself: a link you can't change is a link you can't fix when the destination is wrong, outdated, or legally sensitive. Permanence is a commitment, not a default.

Key Takeaways

  • A URL is a name plus a resolution decision. If someone else makes that decision, you're leasing the pointer, not owning it.
  • Burger King's 2011 tweet wasn't hacked or edited — its Bitly code was re-registered by a stranger. Of 97 archived Trump links checked, 7 now point somewhere new.
  • Your stack has the same shape in container tags, package names, GitHub handles, and S3 bucket paths. All are recycled namespaces.
  • Audit each external identifier on three axes: who controls resolution, how fast you'd detect drift, and what breaks if it moves.
  • For anything printed or cited, put your own domain in front and serve the redirect yourself. For everything else, let it rot on purpose.
  • Pin digests for artifacts, and run a daily resolution check on the short list of links you promised would last.

[ Call to action ]

Ready to scale your engineering team?

Tell us the roles you need to fill and we'll get back within 24 hours.