There are two webs. They share the same wires, the same protocols, the same browser. But they are fundamentally different organisms, and one of them is eating the other alive.
The first web is parametric. A URL is a coordinate. You request it, the server looks up the corresponding resource, and returns it. The resource exists before you ask for it. The server’s job is addressing — mapping a name to a thing. This is the web Tim Berners-Lee built. A document requests another document by name. The name is the thing. The thing was always there.
The second web is computational. A URL is a function call. You request it, the server executes code, queries databases, runs business logic, assembles a response on the fly, and returns something that did not exist until you asked for it. The resource is manufactured at request time. The server’s job is not addressing — it is computing. This is the web we accidentally built on top of the first one, and it has been metastasizing ever since.
The Parasite
Every major web framework — Django, Rails, Express, Laravel, Spring, Next.js — is a computational framework. It assumes that the response to a request must be generated, not retrieved. It provides routing engines, template compilers, ORM layers, middleware chains, authentication pipelines, session managers, caching hierarchies — all to support the fundamental assumption that the server must think before it speaks.
For applications — banking, e-commerce, social networks — this assumption is correct. The response genuinely depends on who is asking, what they asked for, and the current state of a dozen databases. Computation is necessary.
For publishing — blogs, articles, documentation, essays, portfolios — this assumption is catastrophically wrong. The content does not depend on who is asking. The blog post is the same for every reader. The essay does not change based on the session cookie. The documentation does not need to query a user table before rendering.
And yet. WordPress runs PHP on every single page load. Ghost runs Node.js to serve every article. Substack runs its entire application stack to deliver what is, fundamentally, a static document. They are using the computational web to serve parametric content. They are using a factory to deliver a thing that could be sitting on a shelf.
This is not a performance complaint. CDNs and caches paper over the latency. The complaint is architectural — these systems maintain entire computational runtimes, with their associated memory consumption, security surfaces, dependency chains, and operational complexity, to serve content that was known at write time. The computation produces the same output every time. It is pure overhead disguised as architecture.
The Shelf
A static file on a CDN is the purest expression of the parametric web. A URL maps to a file. The file was there before you asked. The server does not think. It retrieves.
The performance characteristics are obvious: no database queries, no template rendering, no middleware execution, no session lookups. Time to first byte is limited only by network latency and disk I/O — both of which are measured in single-digit milliseconds on modern infrastructure.
The security characteristics are less obvious but more important. A static file server has no application layer to exploit. There is no SQL injection because there is no SQL. There is no XSS because there is no dynamic rendering. There is no authentication bypass because there is no authentication. The attack surface is the web server itself — nginx, Apache, a CDN edge — and nothing else. WordPress has published over 40,000 CVEs in its lifetime. A static file has published zero.
The operational characteristics are the most important of all. A static file server requires no application monitoring, no error tracking, no log aggregation, no dependency updates, no framework migrations, no plugin compatibility matrices. It serves files. When the files are correct, the server is correct. There is no state to corrupt, no cache to invalidate, no race condition to debug.
The Inversion
note2cms inverts the web publishing model by doing the computation once, at write time, and serving the result parametrically forever after.
When you push Markdown, the server computes: it parses frontmatter, converts Markdown to HTML, injects content into a template, updates the taxonomy index. This is real computation — the same kind that WordPress does on every page load. The difference is that note2cms does it once and throws away the computational infrastructure. The build pipeline is ephemeral. It exists for the moment of transformation and then it is gone.
What remains is a static file. A parametric resource. A document at a URL. The reader’s browser requests it and receives it without the server thinking at all. The CDN serves it from cache without knowing what a CMS is.
The computation was necessary. The persistence of the computational infrastructure was not.
The Cost Accounting
A WordPress installation serving a personal blog with modest traffic requires: a PHP runtime, a MySQL database, a web server, a TLS certificate manager, a file upload system, a plugin update mechanism, a theme engine, a cron system for scheduled tasks, a session store, and the operational knowledge to maintain all of these. The minimum viable WordPress deployment is approximately 512 MB of RAM, a multi-gigabyte disk footprint, and the ongoing attention of someone who knows what wp-cron.php does.
A note2cms blog serving the same content requires: static HTML files on a CDN. The API endpoint that produced those files runs on a free-tier serverless runtime that spins down to zero between publishes. The database that indexes those files is a single PostgreSQL instance with a handful of rows. The total operational footprint while the blog is being read — which is most of the time — is zero running processes, zero memory consumed, zero compute cycles.
The content is identical. The reader experience is identical — arguably better, since static files are faster than dynamically rendered pages. The cost is not identical. One model runs a factory twenty-four hours a day to produce goods that could be manufactured once and stored on a shelf. The other manufactures once, stores on a shelf, and turns off the factory.
The Heresy
The web development industry has a financial incentive to maintain the computational model for publishing. Hosting companies charge for compute. Platform companies charge for managed runtimes. Framework companies build ecosystems around the assumption that your blog needs a server. The entire economy of web publishing is predicated on the idea that serving a document requires an application.
It does not. It requires a file and a URL. Everything else is overhead that the industry has normalized because the overhead is where the money is.
I am not suggesting that the computational web should not exist. Applications need computation. What I am suggesting is that publishing is not an application. It is a document retrieval problem that we have been solving with application infrastructure for twenty years because nobody stopped to ask whether the computation was necessary.
The computation was necessary once — when the author wrote the post. It is not necessary every time a reader opens it. That distinction is the entire thesis of note2cms, and it is the distinction that the web publishing industry has refused to make because making it would eliminate most of their billable services.
The server should not think when the answer was known at write time.