Why platforms get worse, and what actually stops it

Cory Doctorow didn't just complain that platforms get worse. He described a specific, repeatable sequence, and gave it a name that stuck because it matched what people were already feeling.

First, a platform is genuinely good to its users, often better than it needs to be, to build a user base and earn trust. Then, once people are locked in, it shifts value toward its business customers instead, advertisers, sellers, publishers, at the users' expense, while staying just bearable enough that people don't leave. Finally, once those business customers are locked in too, the platform claws value back from them as well, funneling everything toward itself. By the end, almost nobody involved is getting a good deal except the platform's owners.

For most of the internet's history, this kind of decline was self-correcting. If a service got worse, people had somewhere else to go, and getting there wasn't especially hard. That combination, real alternatives plus low switching costs, is what Doctorow points to as the thing that actually kept platforms honest, not goodwill.

Two things made switching cheap. One was competition: enough independent services existed that a bad actor could lose users to a better one. The other was interoperability: the technical and legal freedom to build tools that worked with a platform on your own terms, a third-party app, a data export, a browser extension, even without the platform's blessing. If a company degraded its product, someone could usually build a workaround faster than the company could close it off.

Both of those constraints have weakened, and Doctorow argues it's the combination that matters, not either one alone.

Markets consolidated. A small number of companies now own search, social media, app distribution, and cloud infrastructure at a scale that makes credible alternatives rare, and when one does appear, the incumbent can often simply acquire it rather than compete with it.

Interoperability got walled off, deliberately. Doctorow's own go-to example is Twitter cutting off the third-party apps and API access that used to let people use the platform on their own terms, no ads, no algorithmic feed, their choice. Closing that door didn't improve the product. It removed the escape route, which was the point. The same pattern shows up elsewhere as broken API access, blocked data exports, and laws that make it illegal to build tools that work around a platform's restrictions, even for entirely legitimate reasons.

Take away the ability to leave, and a platform can degrade the experience with very little risk. The two constraints that used to make that behavior costly have quietly stopped applying, and that alone explains most of the shift.

The specifics vary, but the shape repeats. A feed that used to show you what you asked for starts showing you what keeps you scrolling instead, closer to advertising than to the people you actually followed. A search engine that once got out of your way starts asking you to scroll past more of itself before you reach an actual answer. A service that was cheap or free while it grew starts raising prices once switching away feels like more trouble than it's worth.

None of this means every platform is secretly plotting its own decline, or that convenience is inherently a trap. It means the ordinary pressure that used to keep a service accountable to the people using it has gotten a lot weaker, and it's worth noticing when you're the one absorbing that.

Self-hosting addresses this by restoring the two things that went missing, at least for the slice of your digital life you choose to move.

There's no lock-in to escape, because there's no company deciding when to change the deal. And most self-hosted, open-source tools are built on open formats and standard protocols, calendars that speak CalDAV, files that stay files, on purpose, because the communities that build them tend to actually value the ability to move your data elsewhere. If a project stops serving you, you can migrate, or in the case of open-source software, someone can fork it and keep the version you liked alive.

It would be dishonest to call this a perfect fix. Open-source projects have their own failure modes: maintainers burn out, small projects go stale, and some "open core" companies build a following on a free tool and later paywall the parts people actually relied on. Self-hosting doesn't make software immune to bad incentives.

What it changes is who's holding the exit. On a platform, the company decides when you've lost too much to be worth staying for. On your own server, that decision, and your data, stays yours the entire time. That's the actual thing enshittification takes away, and it's the thing this approach gives back.