I was one of the first who got excited about static site generators. When Jekyll appeared, then Hugo, then Gatsby, then Eleventy, then dozens more – it felt like liberation. No more WordPress. No more PHP. No more databases serving every page view. Just build the HTML once and serve it forever. The thesis was beautiful.

The execution was not.

The Friction Nobody Removed

The promise of static site generators was simplicity. The reality was a different kind of complexity.

You wanted to write a blog post. Here is what you actually did:

You opened a terminal. You navigated to a project directory. You created a new file in a specific subdirectory with a specific naming convention. You wrote frontmatter that the generator required in its specific dialect. You wrote your post in an editor you may not have chosen if the SSG did not require it. You ran a build command. You watched the build output for errors. You ran a local preview server. You checked the output in a browser. You committed to git. You pushed. You waited for CI to build. You waited for the deploy to propagate. You checked the live site.

Thirteen steps between thought and published post. The SSG removed the database. It did not remove the friction. It replaced one kind of friction with another and called it progress.

The Commands Nobody Wanted to Learn

Hugo requires you to learn hugo new posts/my-post.md. Jekyll requires bundle exec jekyll serve. Gatsby requires gatsby develop and gatsby build. Eleventy requires npx @11ty/eleventy. Each generator invented its own CLI with its own flags, its own configuration files, its own directory conventions.

The user who just wanted to publish a thought now had to memorize commands for a tool they never wanted to learn. They learned these commands not because the commands were useful but because the architecture demanded them. The architecture was designed for the developer, not the writer. The writer was an afterthought in a system built by developers for developers.

And the commands were never at hand. You could not publish from your phone. You could not publish from a library computer. You could not publish from a friend’s laptop. You needed your project directory, your local install, your specific Node or Ruby or Go version, your build toolchain. The “simple” static site generator required more local infrastructure than the WordPress it replaced.

And the dependencies rotted. Jekyll was written in Ruby. Almost every other Ruby release broke something – a gem version conflict, a native extension that would not compile, a Bundler incompatibility that produced error messages longer than the blog post you were trying to publish.

You did not sign up for this. You did not know what a runtime was. You did not know Ruby. You did not want to know Ruby. You wanted to write a blog post about your weekend, and instead you were reading a stack trace about nokogiri failing to build native extensions on your operating system. You were on StackOverflow at midnight learning about rbenv and rvm and chruby – three competing tools for managing versions of a language you never chose to install. You were on forums asking bearded strangers how to rollback to the last Ruby version that did not break everything. You were debugging someone else’s infrastructure instead of writing your own words.

Why was a programming language runtime on your machine at all? Why did your blog’s ability to exist depend on your ability to maintain a software development environment? Why was a chaotically versioned interpreted language the load-bearing wall of your personal publishing? These questions were never asked because the SSG ecosystem was built by developers who already had Ruby installed, who already understood gems, who already had opinions about version managers. The writer who wandered in hoping to publish a blog post without WordPress was collateral damage.

Hugo solved this by shipping a single Go binary. No runtime, no dependencies, no gems. It was the right answer to the wrong question. The question was not “how do we fix Ruby dependency hell.” The question was “why does publishing a blog post require a programming language runtime on my machine at all.” Hugo answered the first question brilliantly. Nobody asked the second one until note2cms eliminated the local runtime entirely.

The Themes Nobody Could Make

Every static site generator had a theme system. None of them made it easy.

Hugo themes required understanding Go templates. Jekyll themes required Liquid. Gatsby themes required React with GraphQL queries. Eleventy themes required Nunjucks or Handlebars or any of six supported template languages.

A designer who wanted to create a beautiful blog theme needed to learn a programming language’s template syntax, understand the generator’s data model, navigate its directory conventions, and test against its build system. This is not a theme. This is a software project.

The result was predictable. A handful of developers made themes. Most of them looked the same. The themes that existed were functional and forgettable. Nobody made themes with personality because the friction of making a theme was so high that by the time you got it working, you had no energy left for beauty.

Hugo has hundreds of themes. How many can you name? How many made you feel something? How many had a hidden visual trick that rewarded interaction? How many had a personality beyond “clean and minimal”?

The Blogs That Got Bloated

The irony of static site generators is that they produced bloated output. The HTML was static, yes. But Gatsby shipped a JavaScript runtime to the browser. Next.js shipped React hydration. Even Hugo and Jekyll themes accumulated CSS frameworks, web fonts loaded from CDNs, analytics scripts, comment system embeds, and social sharing widgets.

The static HTML that was supposed to be light became heavier than the dynamic WordPress pages it replaced. The build step that was supposed to be simple became a pipeline with Node dependencies, Ruby gems, Go modules, and build caches measured in gigabytes.

The simplicity was cosmetic. Underneath, the static site generator ecosystem accumulated the same complexity that WordPress accumulated – just distributed across different tools instead of concentrated in one.

The Thousand Post Problem

Here is the fact that killed static site generators for anyone who actually blogged consistently.

You wrote your thousand-and-first post. You ran the build command. The generator rebuilt every page. All one thousand index entries re-sorted. All one thousand HTML files re-rendered. All tag pages, archive pages, RSS feeds – everything regenerated from scratch because the generator had no concept of incremental builds.

Hugo was fast. Hugo rebuilt a thousand posts in seconds. But Gatsby took minutes. Jekyll took minutes. Eleventy took minutes. And “minutes” is a generous description for a Jekyll blog with a thousand posts, custom plugins, and Sass compilation. Half an hour was not unusual. Half an hour to add one post to a blog that already had a thousand.

The architecture guaranteed this. A static site generator treats the entire site as one unit. Change one post and the entire site rebuilds. The build time scales with your archive, not with your publishing frequency. The more you wrote, the more you were punished for writing.

This is the fundamental architectural flaw that nobody in the SSG world addressed honestly. They optimized build times. They added caching. They parallelized template rendering. But they never questioned the premise that adding one post should touch every other post. The premise was wrong. The optimizations were bandages on a broken architecture.

note2cms publishes one post by rendering one post. The five hundred posts already in your archive are untouched. Their HTML does not change. Their directories are not rewritten. The index page rebuilds because the post list changed, but the individual posts are frozen. The build time is O(1). Post number one thousand and one takes the same time as post number one.

One second. Not half an hour. One second regardless of archive size. Because the architecture was honest about what actually needs to happen when you publish a new post: render one file, update one index, deploy. Everything else is waste.

The One Thing They Got Right

But here is what the static site generator movement understood better than anyone: the source Markdown files are the system of record. Everything else is derived.

Jekyll got this right from the beginning. Your blog was a folder of Markdown files. Delete the output, run the build again, and everything comes back. The database was not the king. The files were the king. The generated HTML was disposable because the source that produced it was permanent.

Hugo got this right. Eleventy got this right. Even Gatsby, underneath all the React and GraphQL, understood that the content lived in files, not in a database.

This was the SSG movement’s most important contribution to web publishing. Not the performance. Not the security. Not the simplicity that turned out to be complex. The idea that your words belong in files you can see, copy, move, version, and back up with the tools you already have. Files that survive any tool, any framework, any platform. Files that will be readable in fifty years by any text editor on any operating system.

note2cms follows this canon – accidentally. The Markdown you publish is stored in your GitHub repo as a source file alongside the rendered HTML. Delete every HTML file, hit rebuild, and the pipeline re-renders everything from the source Markdown. The system of record is the file. The rendered output is disposable. The taxonomy is a JSON file in the same repo, also disposable, also rebuildable.

But note2cms goes one step further than any SSG dared. In a static site generator, your Markdown files lived in a project directory on your local machine. If your laptop died, your blog died – unless you had pushed to git. The files were the system of record, but the files were local.

In note2cms, the Markdown source lives in your GitHub repo from the moment of publish. There is no local-only state. There is no “I forgot to push.” The act of publishing IS the act of backing up. The source Markdown, the rendered HTML, and the taxonomy index are all committed to your repo in the same atomic operation. Your blog is version-controlled, backed up, and publicly auditable from the first post.

The SSG movement said: your files are the truth. note2cms says: your files are the truth, and they live somewhere safe from the moment they exist.

What note2cms Is Not

note2cms was never envisioned as a static site generator. It does not generate a site. It does not have a build command. It does not have a project directory. It does not have a CLI you need to install. It does not have a local development server. It does not require git on your machine.

note2cms is a pipeline. Markdown goes in one end. A permalink comes out the other. The thing in the middle – the parsing, the rendering, the deploying – is not your problem. It wakes, it works, it dies. You never see it.

The distinction matters. A static site generator is a tool you operate. note2cms is a service you use. You do not operate a postal service. You hand it a letter and it delivers it. You do not need to know how the trucks work.

What note2cms Solved by Accident

By refusing to be a static site generator, note2cms inadvertently solved every problem that static site generators created.

The friction between thought and post. You write in whatever notes app you already use. You publish with one HTTP request. There is no terminal, no build command, no project directory, no git push. The distance between thinking and publishing is one POST request.

The commands nobody wanted. There are no commands. There is one endpoint. POST your Markdown to it. You can do this from curl, from an Obsidian plugin, from an iOS Shortcut, from any app that speaks HTTP. You do not need to learn anything except the address of the endpoint.

The tools that were never at hand. Your phone is at hand. The Shortcut that publishes to note2cms is on your phone. Your laptop is at hand. Curl is on your laptop. Any device with an internet connection and the ability to make an HTTP request is a publishing tool.

The thousand post problem. One post published, one post rendered. O(1). One second. Always.

The themes nobody could make. A note2cms theme is two HTML files. A post template and an index template. They receive variables. They return HTML. If you can write HTML and CSS, you can make a theme. No template language to learn beyond basic Jinja2 variable substitution. No data model to understand. No build system to fight. Two files.

And the themes have personality because the barrier to making them is so low that the creator has energy left for beauty. The Brutalist theme has a binary hover inversion. The Ink theme has a brushstroke animation. The Darkroom theme has photographs that develop on scroll. These tricks exist because the theme system is simple enough that the designer could focus on design instead of infrastructure.

The bloated output. note2cms produces static HTML with zero JavaScript. No framework. No hydration. No runtime. The reader’s browser receives HTML and CSS and nothing else. The page loads instantly, renders completely, and works forever. It is archivable by the Wayback Machine and printable on paper.

The source of truth. Your Markdown lives in your GitHub repo from the moment you publish. Delete the HTML, rebuild, everything returns. The SSG canon preserved, the SSG friction eliminated.

The Accidental Thesis

I did not set out to fix static site generators. I set out to publish a blog post without opening a browser. The solution happened to be a pipeline that accepts Markdown via HTTP and produces static HTML on a CDN.

That this pipeline solves the problems of the SSG ecosystem is an accident of architecture. When you strip publishing down to its absolute minimum – Markdown in, permalink out – the problems that static site generators created do not arise because the complexity that caused them was never introduced.

The commands do not exist because there is no CLI. The local toolchain does not exist because there is no local build. The themes are simple because the template system is simple. The output is light because nothing unnecessary was added. The build is O(1) because only the new post is rendered. The source is safe because publishing IS backing up.

Static site generators started from the developer’s perspective and tried to accommodate writers. note2cms started from the writer’s perspective and never needed to accommodate developers. The writer just writes. The pipeline just works.

That is not a static site generator. It is something else. Something that did not have a name until now.


The distance between thinking and publishing is one POST request. Everything else was a detour.