In Part 1, I described how the web page became hollow: data extracted, meaning deferred, structure reduced to shell. In Part 2, I looked at the cost: infrastructure overhead, cognitive burden, an economic floor that prices out small projects. In Part 3 I traced the path from frustration to insight: the realisation that HTML already is structured data, that CSS selectors already are a query language, that the web shipped with everything it needed.

Now I want to explain what we’ve built at Pagelove.

The core idea

At the heart of the Pagelove platform is a database whose internal structure is HTML and whose query language is CSS selectors, accessed entirely over HTTP.

That framing matters. Pagelove is not a web server that happens to understand selectors. It is a database that happens to speak HTTP. The document is not a view onto data stored elsewhere. The document *is* the data, and the protocols we use to interact with it are the native protocols of the web.

There is no separate storage layer, no ORM, no query service. Structure, data, permissions, and behaviour all live together in the document, addressable and manipulable through standard HTTP methods.

It’s a big idea. Let it percolate.

How it works

In Part 3, I described the insight that the HTTP Range header could specify something other than byte offsets. Pagelove builds on this: a range can be a CSS selector, and that selector becomes a query into the document’s structure.

When you make a request to a Pagelove document, you can target any element within it. A GET with a selector returns that fragment. A PUT replaces it. A DELETE removes it. A POST appends to it. These are not conveniences layered on top of file operations. They are database operations, executed against a document whose structure the server understands as deeply as any relational engine understands its tables.

Concurrency is handled through ETags and conditional requests. Validation is enforced at write time. Access control is evaluated per-element. The server does not treat the document as text to be overwritten. It treats the document as a data structure to be queried and mutated.

This is what it means to take documents seriously: not as files to be served, but as data structures to be understood, queried, and scaled like the web itself.

Three building blocks

Pagelove rests on three interlocking concepts, each deliberately minimal in specification but powerful in combination.

The first is HTTP extensions. Standard HTTP methods, applied to document fragments via selectors. No new verbs. No new protocols. Just a careful reading of what HTTP already permits, and a willingness to use it as a database interface.

The second is HTML microdata for schema. Validation constraints, authorisation rules, group memberships, and structural hints are declared inline, using attributes the browser already ignores but the server understands. A document describes not only its content but the rules that govern it. These rules can be as sophisticated as the application demands: role-based access control, field-level validation, complex authorisation policies.

The third is server-side processing instructions. Declarative directives embedded in the document that tell the server how to behave: how to include other documents, how to bind data to templates, how to create new resources. These instructions compose. A document can assemble itself from fragments, transform data, and orchestrate complex workflows, all without imperative code.

Each element has a small surface area. Together, they can express the full range of application behaviour.

What disappears

When documents become the unit of truth, a remarkable amount of machinery becomes unnecessary.

No database migrations. The document schema evolves with the document. No API versioning. The document is the contract. No client-server state synchronisation. There is only one source of truth, and you are looking at it.

Caching becomes a property of HTTP again, not a discipline requiring careful invalidation logic. Real-time updates flow naturally from the fact that the server knows the document structure and can push changes to the relevant selectors.

This does not mean applications become primitive. It means the complexity lives where it should: in the domain logic, not the plumbing. A sophisticated application built on Pagelove can have rich data models, nuanced permissions, and intricate workflows. What it does not need is a separate system for each of those concerns.

There is another consequence, one I did not fully appreciate the size and impact of when this project began.

A document-centric web is legible. Not just to browsers, but to anything that can read HTML. When meaning lives in the document, inspection becomes possible again. Crawlers can understand. Assistive technologies can navigate. And AI systems can read, reason about, and interact with web applications without needing to execute JavaScript or reverse-engineer API contracts.

The current generation of AI systems can read and write text, but they struggle with the modern web. A typical single-page application presents them with an opaque bundle of JavaScript, data fetched asynchronously from undocumented endpoints, and state scattered across client and server. To interact meaningfully, an AI must either simulate a browser or be given explicit API access. Neither scales. Neither is how the web was supposed to work.

The industry’s answer so far has been to build new protocols. MCP and its equivalents attempt to give AI systems a structured way to interact with services: defined tools, typed parameters, explicit capabilities. This solves the immediate problem, but it solves it by adding another layer. Now every service needs two interfaces: one for humans, one for machines. The bifurcation that hollowed out the web in the first place is repeated, and the cost of building and maintaining software increases again.

Pagelove applications are different. The document is the interface and the data, for humans and machines. An AI can read a page and understand its structure. It can see what data exists, what actions are possible, what constraints apply. It can make changes through the same HTTP methods a browser would use, targeting elements with the same selectors a stylesheet would use. No special integration required. No API keys. No separate machine interface to maintain.

This is not a feature we added. It is a property that emerges from taking documents seriously. When the document is the source of truth, anything that can parse HTML can participate.

By building something for humans, we have also built something AI-native. As these systems become more capable, a web built on legible, meaningful documents will be a web they can work with directly. Pagelove applications will not need to be adapted for AI interaction. They already speak a language AI understands.

There is a version of the present moment where AI remains trapped in its own bubble: powerful but isolated, able to converse but not to act, useful only when someone builds an explicit bridge to each service it needs to reach. If that continues, the promise of AI as a general-purpose assistant will quietly deflate. Pagelove offers another path. A web where documents contain their own meaning is a web AI can navigate without bridges. The integration happens automatically, because there is nothing to integrate. The interface humans use is the interface machines use.

AI is currently a bubble and Pagelove is a way out of it.

This changes everthing

The modern web has an economic floor. Before you write a line of business logic, you need a database, an API, an application server, a frontend framework, deployment infrastructure. This is true whether you’re building for ten users or ten million.

That floor prices out entire categories of software. Personal tools. Community projects. The long tail of applications that would be useful but can’t justify the infrastructure to exist.

Pagelove removes the floor.

The web was supposed to democratise publishing. It did, for a while. Then software ate the web, and publishing became building, and building required infrastructure, and infrastructure required scale to justify. The individual creator was priced out. The default became platforms.

Pagelove reverses that. Software that was never worth building starts getting built. The internal tool someone always wanted but couldn’t justify. The community project that died in the planning stage. The experiment that never left localhost. The client project that wasn’t worth the infrastructure overhead.

And the same architecture scales up. The document model that runs a small team’s tracker can power an enterprise platform serving millions.

The ceiling stays high. The floor disappears.

And when floors disappear, everything changes.

A return to revolution

I want to be clear about what Pagelove is.

Pagelove is not a departure from the web of 2026. It is a re-emphasising of principles that were always present in the web’s design. Roy Fielding’s REST. Tim Berners-Lee’s vision of linked, meaningful documents. The original promise that anyone could be a publisher, not just a consumer.

The foundations of the web did not need to be rebuilt. But they did need to be extended. HTTP, HTML, the document as a unit of meaning: what was missing was the machinery to treat documents as true data structures — to query them, mutate them, enforce constraints on them, scale them. That machinery did not exist, so we built it.

Pagelove is what it looks to take the web seriously again.

What comes next

This series has traced a path from frustration to philosophy to product. The hollow web. The cost of the shell. The insight that documents could be taken seriously. And now, the shape of what that insight became.

We’ve been researching, experimenting & building Pagelove for over a year. The documentation is available. We’re building demos. The platform is now open behind a waitlist, and we’re adding more people every day.

We are trying to change how software gets built. Not incrementally — fundamentally. A web that is legible again. A web where small tools can exist without subsidising infrastructure they don’t need. A web that AI can navigate without special accommodation. If that sounds worth doing, we would like your help.

Join the waitlist. Build something on Pagelove. Tell us what breaks. Tell us what’s missing. Tell others if you think they should hear about it.

The web was designed to give individuals agency. Help us give it back.