Some blogs publish themselves.
A schedule comes around, a script assembles the week's post, sets the tags, clears the cache, and the thing is live before anyone has had their first coffee. Nobody logged in. Nobody clicked a button called Publish. The publication simply arrived, the way it arrives every week, because that is how it was built to run.
Some blogs publish the moment there is something to say. A change ships, and the post explaining that change ships with it, in the same motion, out of the same pipeline. The writing is not a separate chore for three days later when someone finally remembers. It is part of the release itself.
And some blogs publish only when a person sits down and writes. No automation, no schedule, no trigger waiting in the background. Just an idea that would not leave someone alone until they turned it into sentences, posted by hand, on no particular timetable, because that is the only honest way that kind of writing ever gets made.
Three blogs. Almost nothing in common.
One keeps a cadence measured in days. Another measures it in deploys. The third measures it in moods. One is written by scripts, one by a release process, one by a single stubborn human being. Line their workflows up side by side and you would struggle to guess they were the same kind of thing at all, let alone that they run on the same platform.
They do. And the fact that they can is the entire point of how we built Lavvus.
Most platforms quietly pick a favourite
Most blogging tools are built with one writer in mind. Sometimes that is stated out loud, more often it is simply baked in. You can feel it in the defaults: the reminder emails that assume you publish on a rhythm, the editor that assumes a human is always in the loop, the onboarding that assumes you are one person, with one blog, and one way of working. The whole product quietly takes the shape of an imagined user. Which is lovely if you happen to be that user, and a fight against the current if you are not.
We decided early that Lavvus would not try to guess who you are. It would not assume your cadence, your tooling, your voice, or whether a person is even involved in any given post. A blog on Lavvus is a set of rails. What runs on them is your business, not ours.
That single decision is why the API is not a feature here. It is the foundation. Everything a blog can do, it does by answering a request, and the dashboard you log into is simply a friendly face resting on top of those same requests. The post is the API. Because that is true all the way down, every publication can bring its own way of working, and the platform never argues with it.
Same rails, different trains
The blog that publishes itself leans on the API and a scheduler, and it may go months without a human ever opening the dashboard. The blog that ships alongside its product lives inside a deploy pipeline, going out as a side effect of shipping. The blog written by hand might never touch the API at all, living entirely in the editor, one careful post at a time.
All three are first-class. None of them is the real way to use Lavvus, because there is no real way. The automated publication is not a clever hack bolted onto a tool meant for humans. The hand-written one is not underusing a tool meant for machines. They are the same product, met on their own terms, each getting the whole of it rather than a corner.
That is harder to build than it looks, and much easier to live with once it exists. Harder, because you cannot lavish all your attention on one beloved use case and let the others limp along behind it. Easier, because you never have to tell a writer that the way they want to work is not really supported here.
What they share is a contract, not a routine
What these very different blogs actually have in common is not how they publish. It is the shape of what they publish. Every post, whoever or whatever created it, is the same kind of object. A title. A summary written for people and a summary written for machines. A canonical URL, so the post keeps one true home no matter where it gets syndicated. Tags. A body. A cache that knows how to clear itself.
That shared shape is exactly what lets the differences exist. Because a post is a well-defined thing, a script can make one, a pipeline can make one, and a person can make one, and everything downstream treats them identically. Your own website can pull posts through the API and render them in your own design. A newsletter can go out from the same source without a second copy drifting quietly out of sync. An assistant reading the open web finds a clean summary and a canonical link instead of a tangle. One source of truth, many destinations, no matter how the post came to be.
Why we think this is the honest way to grow
We did not reason our way to this on a whiteboard. We arrived at it by running blogs that work nothing like each other, and paying attention to what kept them alive. A blog that depends on a person remembering to log in goes quiet the first genuinely busy week. A blog welded to one rigid routine breaks the moment life stops matching the routine. The ones that keep going, year after year, are the ones where publishing quietly became something the tools do, in whatever shape happens to fit the writer.
So the bar we hold ourselves to is not how polished the dashboard looks in a screenshot. It is whether a blog that resembles nothing we have seen before can still feel as though it was built for precisely that. One API, every kind of blog. Yours included, run however you decide to run it.
