● A free public tool  ·  Built by Poptani Labs  ·  No sign-up  ·  Your data never leaves your browser
Built in the Lab · 5-minute read

Inside the nightly blog pipeline: how this post got written, checked and published

A large Mitsubishi printing press inside a print shop, seen through a glass door, with tall stacks of printed paper and wooden pallets
Image: 'A Mitsubishi printing press in a printing company in Euljiro printing alley.jpg' by Aaaatu, CC BY-SA 4.0, via Wikimedia Commons

This post is about itself — or rather, about how it got here. There is no content management system behind this blog, no editor's dashboard, no "Publish" button. Every night, six new posts appear on this site, written as plain text, assembled by an automated routine, and sent live to the web. This is that routine, exactly as it runs — quirks included. And yes, this post went through the same routine it describes; like everything else on this blog, it is research-based writing grounded in real sources, not a hands-on test.

The rota: twelve topics, six a night

The blog runs on twelve topics, from AI, Decoded to Built in the Lab. Each night it takes the next six in turn, wrapping back to the top when it runs out. Tonight's six are Screen Time, The Butterfly Effect, Beyond the Hype, Around the World, Big Thinkers and Built in the Lab. The rotation is the whole schedule: no calendar, no queue, just turn-taking.

Step one: drafts first

Each post begins life as a draft document holding everything the post needs: its title, summary, the body, the closing note, related posts, sources, and the picture details. The drafts are written by AI assistants, working from research done that evening. Nothing here is typed into a web form; the draft is the post.

Step two: every page starts from the same template

A template turns the six drafts into six web pages. The template is itself an old post — the one about the Wilhelm scream, the stock scream heard in hundreds of films. Each new page starts as a copy of that post with its title, address and description swapped out, then the new draft's body, picture, closing note and source list are slotted in. Before anything is written, the routine runs checks: the post must be 600 to 1,000 words, it must contain a heading, and it must contain no advertising at all. If any check fails, the whole batch stops.

Step three: the front page, the homepage and the site map, all at once

The next step does the bookkeeping: it adds six new cards to the top of the blog's front page and updates the post count, swaps the three featured cards on the homepage for the batch's first three posts, adds the new addresses to the site map, notes the titles in a running list of recent topics, and records each post in the editorial log. It also refuses to run twice — if the first card is already on the front page, it stops, so a batch can never be published twice by accident. The site's calculators got the same treatment in our earlier look inside the SWP Simulator.

Step four: pictures, but only the free and the wide kind

Hero pictures come from Wikimedia Commons. The routine searches the Commons collection, then keeps only pictures that are genuinely free to reuse — Creative Commons or public domain — and genuinely landscape: at least 1,200 pixels wide, and at least a quarter wider than tall. The winning picture is saved on the site itself and credited under the figure; nothing is hotlinked.

Step five: publish, then trust nothing

Publishing uploads the site to the service that hosts it. One detail is easy to miss: the upload tool looks for the site's server functions in the folder it is run from, not the folder it is told to publish, so the routine deliberately runs from inside the site's own folder. The sign-in token comes from a stored credential and is never printed or logged. And the upload itself is not trusted: the routine's own notes warn that a publish can fail silently, so after every publish it fetches each new post's live address and checks it returns a success code and contains its own headline — then checks again about half a minute later, because the first request after a publish can be served an older, cached copy. A publish is only done when the live site proves it.

The quirk that tells you everything

The detail that best sums up this routine is the template. Every post on this site — about black holes, bank tellers, gold bonds and printing presses — starts its life as a copy of a post about a scream recorded in 1951 for a man being dragged underwater by an alligator. A new post is, mechanically speaking, the Wilhelm scream post with its name changed. It is the cheapest possible templating system, and it has worked for more than a hundred posts. The second-best detail is the publish check: the routine does not believe its own upload tool, and re-checks the live site half a minute later in case the internet's cache is lying. Both quirks come from the same instinct: use the simplest thing that works, and verify it on the live site rather than assuming it worked — which is also, in short, how a website works.

Under the Hood

Under the hood, there is nothing clever here — and that is the point. A dozen topics, turn-taking instead of a calendar, drafts as documents, a template that clones an old post, one step that updates five places at once, pictures only from the Commons, and a publish that is not believed until the live site confirms it. The lesson transfers: make the routine boring, make every step checkable, and let the live site have the last word.

Related on Poptani Labs: Inside the SWP Simulator: how a retirement withdrawal plan is actually calculated, How a website actually works: from typed address to page on your screen, How GPS works: atomic clocks in space, Einstein, and a tragedy. More in this category: Built in the Lab.

Sources: Poptani Labs blog, Inside the SWP Simulator

← All posts