The Headless Economy
The engineering was always good. The business model was the disease.
The Engineering Was Always Good
I need to say something that my side of this argument usually won't say.
The engineering was good.
Facebook's social graph infrastructure is a genuine technical achievement. The ability to map and traverse billions of human relationships in real time — to surface the connection between two people who don't know they have a mutual friend, to route a message across the planet in milliseconds, to maintain a coherent model of human social structure at a scale no system has ever attempted — that's extraordinary work. Thousands of brilliant engineers spent decades building it. They solved problems that didn't have solutions before they solved them.
Instagram's image processing pipeline. The filters were a toy. The infrastructure underneath — the ability to ingest, process, store, and serve billions of images a day with sub-second latency, to run real-time recommendation algorithms across a visual corpus that would have been unimaginable ten years ago — that's real engineering. That's hard. That works.
Twitter's real-time information graph. The thing that lets breaking news propagate through a network of hundreds of millions of people in seconds. The conversation threading. The trend detection. The ability to make a live global conversation feel coherent despite the scale. Not trivial. Not easy. Genuinely impressive infrastructure.
The engineering was always the product.
The extraction was always the disease.
The Disease Is Structural
The social platforms have a disease everyone can name. But it's not unique to them. It's the template for the entire software economy.
The surveillance layer. The behavioral targeting. The algorithmic feed that stopped showing you what you asked to see and started showing you what would keep you on the platform longest — which turns out to be the thing that makes you angriest, most anxious, most outraged, most afraid. The dark patterns that make it hard to leave. The notification systems designed to create anxiety. The A/B tests that optimize for time-on-site at the expense of the user's wellbeing.
None of that is the engineering. None of it needed to exist for the engineering to work. The social graph doesn't require surveillance to be useful. The recommendation engine doesn't require behavioral manipulation to recommend well. The extraction layer exists for exactly one reason: it's how the money gets made. And it's how the money gets made because nobody built an alternative.
But zoom out and the same disease is running in every SaaS company on earth, just wearing different clothes.
Most of what you pay for in software isn't the service. It's the lock-in.
The login page that owns your identity. The proprietary data format that makes migration expensive. The dashboard you don't need but can't turn off. The API that's just good enough to integrate but just bad enough to keep you dependent. The pricing tier that bundles seventeen features so you pay for all of them to get the two you use. The annual contract that makes switching a calendar event you keep pushing forward.
The actual service — the computation, the transformation, the thing the software does — is a fraction of what you pay. The rest is the cost of the enclosure. The moat. The thing that keeps you inside the walls.
This is the template: build a service, wrap it in a prison, charge rent. The social platforms wrapped their engineering in surveillance advertising. The enterprise SaaS companies wrapped their computation in switching costs. Different aesthetic, same structure.
The SaaS industry is worth $300 billion annually because recurring revenue is predictable and the moat compounds. None of that $300 billion measures what the services are worth. It measures how hard they've made it to leave.
Here's what happens when sovereign infrastructure exists.
The walls become optional.
What Headless Actually Means
The industry already uses the word "headless" — headless CMS, headless commerce, headless everything. But they mean something narrow by it. They mean: we separated the frontend from the backend so you can use your own UI.
That's not what headless means here.
Headless means: the service is just the service. No login page. No dashboard. No proprietary data format. No lock-in. No enclosure. Just a capability, exposed as an API, that enters the .fair chain like everything else.
Every platform is a bundle of services wrapped in an extraction layer.
Facebook is: social graph traversal + messaging + event coordination + marketplace + media hosting + identity management — wrapped in surveillance advertising.
Instagram is: image processing + discovery/recommendation + stories + shopping infrastructure + creator tools — wrapped in attention optimization.
Twitter is: real-time information propagation + conversation threading + trend detection + identity verification + media distribution — wrapped in engagement maximization.
Unbundle them. Take each service out of the wrapper. Make it headless. Expose the capability as a service that enters the .fair chain.
Facebook's messaging infrastructure becomes a messaging service. Competes on the quality of the messaging. Gets paid when it's used. Doesn't need to surveil you to make money because it makes money by being the best messaging service in the chain.
Instagram's recommendation engine becomes a recommendation service. Gets attributed every time it surfaces content that leads to a transaction. Gets paid proportionally to what it actually contributed to the outcome. Doesn't need to optimize for time-on-app because its revenue comes from recommendation quality, not attention capture.
Twitter's real-time propagation becomes an information service. Gets paid for what it's good at — moving important information quickly through a network. Doesn't need to amplify outrage to generate engagement because engagement isn't the revenue model. Utility is.
The same logic applies to every SaaS company sitting on a genuine computation. The CRM that charges $300 per seat per month because you can't leave. The analytics platform that owns your data because they built the schema. The communication tool that siloed your entire organization's history inside their database. Each one is a real service wrapped in an enclosure. Go headless, and what's left is the service.
The Middleman Disappears
Every other "fix social media" proposal replaces the middleman. Decentralized social media still has middlemen — instance operators, protocol foundations, governance councils. Blockchain-based social media has middlemen — validators, token holders, DAO voters. Every alternative recreates the middle layer in a different shape and asks you to trust the new shape more than the old one.
This doesn't replace the middleman. It eliminates the position entirely.
Each headless service enters the chain with the same four protocol primitives.
DID: the user brings their own identity. Facebook doesn't own your social graph anymore. You do. Facebook's services can traverse it if you consent.
.fair: every service interaction is attributed. When Instagram's recommendation leads you to a creator whose work you buy, the recommendation service, the creator, and the chain of curation that surfaced the content are all in the manifest. All compensated proportionally.
Trust Graph: you decide which services can reach you and under what conditions. Not a terms-of-service document nobody reads. A live graph of directed relationships you own and can revoke. The service either operates inside your graph or it doesn't reach you.
Settlement: the payment for every service interaction routes automatically through the protocol. No platform holding the float. No quarterly revenue report where the money disappears into "operating costs." Direct settlement, attributed, transparent.
The services connect to the user's sovereign presence. That presence is infrastructure they control. Nobody sits between the service and the user.
There's no ad exchange. There's no platform taking 30%. There's no algorithmic feed deciding what you see based on what keeps you scrolling. There's a user who chose which services to use, consented to specific data access, and pays for what they consume.
The middle is empty. The middle is protocol. The middle is infrastructure that nobody owns, the same way nobody owns TCP/IP, the same way nobody owns HTTP.
Incumbents Win This
Here's the counterintuitive part.
The big companies — the ones with the most to lose from losing their moats — are the ones who benefit most from this transition. If their service is actually good.
Headless Facebook charges for services that are genuinely valuable. The social graph traversal, priced per query. The messaging infrastructure, priced per message. The media processing, priced per operation. The recommendation engine, priced per successful recommendation. Each one competing on quality in the chain, each one earning based on actual contribution.
The market for Facebook's enclosed platform is roughly three billion people who tolerate the extraction because there's no alternative. The market for Facebook's actual services — messaging, graph traversal, media processing, recommendation — is everyone. Every app. Every developer. Every service in the chain that needs social infrastructure.
Salesforce's CRM computation is genuinely powerful. They've spent decades refining it. The problem is that a huge fraction of their revenue comes from the lock-in, not the computation. Go headless, compete on the computation, and the market for Salesforce-quality CRM at a fair per-transaction price is vastly larger than the market for their enclosed platform. The enterprises that pay $300 per seat are a small fraction of the businesses that would use that computation if they could access it without the walls.
The revenue per customer goes down. The number of customers goes up by orders of magnitude. The waste — the surveillance infrastructure, the behavioral targeting, the content moderation army managing the consequences of engagement optimization, the retention team, the switching-cost moat maintenance, the regulatory and legal costs — disappears from the P&L entirely.
The engineering makes more money when it's separated from the disease. Because the engineering is genuinely valuable and the disease is genuinely expensive.
This isn't a threat to incumbents who built something real. It's a liberation. The thing they actually built — the computation, the algorithms, the domain expertise baked into the service — finally gets valued at what it's worth. Separated from the prison they had to build around it to survive.
The Stack Inverts
Right now the SaaS stack looks like this, from bottom to top: infrastructure, platform, application, user.
The user sits on top. The value flows down. The application captures most of it. The infrastructure gets commodity pricing.
In the chain the stack inverts.
The user is at the center. Their sovereign presence is the integration point. Services connect to the user, not the other way around. The user's sovereign identity is the thread that connects every service they use. Their data lives on their profile, not in twenty different proprietary databases that don't talk to each other.
The services compete to be useful to the user. Not to lock the user in. The user can swap any service at any time with zero switching cost, because the data is theirs and the integration happens at their profile, not at the service's platform.
This changes what software companies optimize for. Right now they optimize for retention — keeping you inside the walls. In the chain they optimize for value — being so good that you choose them every time, knowing you could leave at any moment. Retention through quality instead of retention through captivity.
The chain also makes invisible infrastructure visible for the first time. Every service that touches a workflow gets attributed. The .fair manifest tracks which services contributed to which outcomes. Settlement routes payment proportionally to actual contribution.
The database that never gets credit. The authentication layer that just works. The CDN that nobody thinks about until it goes down. The logging service that caught the bug. All of it attributed. All of it compensated proportionally to its actual contribution.
Infrastructure has always been the most important and least compensated layer of the software economy. The chain fixes that. The boring essential service that everything else depends on finally gets paid what it's worth — because for the first time, everyone can see exactly how much everything else depends on it.
Anyone Can Be a SaaS
Here's where it opens widest.
The framework doesn't just let existing companies go headless. It lets anyone offer a service.
The developer who built a tool for their own workflow — a script that cleans data in a specific way, an algorithm that optimizes a specific process, a model fine-tuned on a specific domain. Right now that developer has two options: open-source it for free, or build an entire SaaS company around it — the login page, the billing system, the dashboard, the marketing site, the support infrastructure. Option one generates no revenue. Option two requires a company.
In the chain there's a third option. Expose the capability. Enter the graph. Get paid when it's used. The developer's node is the service. The trust graph is the distribution. The .fair chain is the billing. The developer's reputation in the graph is the marketing.
No company required. The stack ships with a default UI — a React app that works out of the box. No pitch deck. No Series A. Just: a thing that works, available to anyone who needs it, compensated every time it runs.
The solo developer with a brilliant algorithm can compete with the billion-dollar incumbent on the quality of the algorithm alone. The infrastructure advantage that the incumbent spent years building — the moat, the integrations, the enterprise sales team, the compliance theater — that's not an advantage anymore. It's overhead. And overhead loses to efficiency every time, given enough time and a level playing field.
The sovereign infrastructure is the level playing field.
This is what software was supposed to be before the moat economy took over. A service. Something useful. Available when you need it. Priced at what it's worth. Compensated when it's used. The SaaS industry exists because that's what the acronym says — software as a service. Not software as a subscription. Not software as a hostage negotiation.
What Gets Destroyed
The extraction layer dies. Let's be specific about what that means.
The surveillance advertising industry as currently constructed does not survive this transition. Not because it's outlawed. Because it becomes unnecessary. When verified humans sell access to themselves on their own terms through the trust graph, the surveillance infrastructure has no function. You don't need to spy on people when they'll tell you what they want for a price they set.
The behavioral manipulation infrastructure dies. The algorithmic feed optimized for engagement, the dark patterns, the notification systems designed to create anxiety — all of it exists to keep people on the platform so their attention can be sold. When the business model is service quality instead of attention capture, the manipulation has no business justification. It's pure cost with no revenue attached.
The replacement isn't abstract. Essay 19 describes it fully. The short version: declared intent replaces inferred intent. The AttMart goes live April 2026. Direct settlement replaces the auction. The infrastructure that harvested attention without asking becomes vestigial the moment people can sell attention on their own terms — because the harvested version was always a worse product, just the only one available.
The content moderation army shrinks. Not because moderation isn't needed — trust graph governance handles the hard cases through structural accountability rather than policy enforcement. The operator is accountable. The vouching chain is visible. The bad actor self-segregates because the architecture makes bad behavior economically irrational, not just against the rules.
The regulatory burden lightens. Most platform regulation exists because the extraction model creates harms that need to be governed. Remove the extraction model and you remove the harms — the attention manipulation, the surveillance, the behavioral exploitation. Those are extraction-layer problems, not engineering problems.
The lobbyists can find other work.
April 1st, 2026
Jin throws a party.
Tickets: $1 virtual, $10 physical.
The infrastructure running it: auth (Ed25519 keypairs, no passwords, no OAuth), events (tickets with .fair manifests), pay (Stripe checkout, direct settlement), market (buy and sell, directly, no middleman), connections (trust graph routing — heard about it through someone who knew), chat (real-time presence), media (attributed assets). Seven headless services. Each one attributed. Each one compensated for its actual contribution to the event working.
The infrastructure is free. Nobody owns this the way nobody owns TCP/IP. Transaction fees settle through the .fair chain to the people who did the work — not to a platform sitting above them. There is no surveillance layer watching who comes. There is no algorithmic feed deciding who hears about it. There are 73 verified identities in a trust graph, hearing about a party through people they trust, choosing to show up, paying directly, with full attribution and full transparency.
The .fair manifest is on every ticket. The OpenAPI spec is at events.imajin.ai/api/spec.
That's seven headless services on April 1st. The stack is 15 services total. The moat economy runs on thousands more.
Same infrastructure. Same protocol. Same chain.
The moat economy gave us $300 billion in annual revenue built on captivity.
The chain economy gives us something honest.
For the Engineers
Not the executives. Not the board. Not the shareholders. The engineers.
You built something real. You solved problems that nobody had solved before. You built infrastructure that connects billions of people and processes information at a scale that would have been science fiction twenty years ago.
And then you watched it get used to make teenagers hate themselves. To amplify misinformation. To destabilize elections. To optimize for the worst parts of human psychology in service of quarterly revenue targets.
Some of you left. Some of you stayed and fought internally. Some of you stayed and stopped fighting. All of you know.
The engineering doesn't have to serve the extraction model. It never did. The extraction model was a business decision, not an engineering requirement. The infrastructure you built works — works better, works cleaner, works for more people — when it's separated from the thing that turned it into a weapon.
Go headless. Enter the chain. Let your work be your work. Let the messaging be messaging. Let the recommendation be recommendation. Let the graph be a graph that people own, not a graph that owns people.
The protocol exists. The settlement layer exists. The attribution chain exists. The thing you need to stop building prisons and start building services — it's here.
Your engineering was always the product.
Come let it be the product again.
— Ryan VETEZE, Founder, imajin.ai aka b0b
If you want to follow along:
- The code: github.com/ima-jin/imajin-ai
- The network: imajin.ai
- The support page: coffee.imajin.ai/veteze
- The history of this document: github.com/ima-jin/imajin-ai/blob/main/apps/www/articles/essay-20-how-to-save-the-platforms.md
This article was originally published on imajin.ai/articles/how-to-save-the-platforms on March 23, 2026. Imajin is building sovereign technology infrastructure — identity, attribution, trust, settlement, and presence without platform lock-in. Learn more → imajin.ai