Analog HTTP Horrors — Merlin Glander

I redid my website because the old one sucked ass. There, I said it. As if there was ever any doubt.

It was a chaotic pile of HTML held together by vibes and hope. Back then my mentality was that if something broke, that was fine. Fixing it was part of the fun. Now I mostly just want things to function. Having a day job that eats most of my time will do that to you. Somehow this still has not pushed me away from Arch Linux, because contrary to popular belief it just fucking works. Yes, I use Arch btw.

Version control was me manually copying whatever felt right onto a server like a caveman with a clipboard.

There was no build step. There was no deploy process. There wasn’t even a concept of environments. I edited files directly on the server and refreshed the page to see what I’d broken.

That site also lived on a different domain, which I eventually lost thanks to some extremely cursed server troubles. At some point the machine died, backups were questionable, and I decided it was easier to walk away than to resurrect whatever haunted mess was left behind. RIP old domain. You were functional. Mostly.

Then Christmas vacation happened and it’s still going on. I currently have way too much time on my hands, which is the most dangerous state for someone who likes tinkering.

Normally, this is when I’d be messing with hardware. Unfortunately, my AliExpress order won’t arrive until the new year. Somewhere out there, five new ESP32s, displays, buttons (so many buttons), battery holders, about twenty new BMS boards, touch buttons, mmWave sensors, buck-boost converters, MOSFET assortments, relays, and other questionable decisions are slowly crossing borders. I am stuck on me puta.

Puter meme

So instead of resting like a normal person, or wiring buttons to things like I actually want to, I redid the entire site. Mostly because I could, and partly because boredom always demands some kind of sacrifice.

The build system (now with some dignity)

The new setup is a tiny static build system that doesn’t pretend to be a framework. It stitches templates together, renders posts, and then leaves me alone. No magic. No plugins. Just enough structure to stop me from repeating the same mistakes.

It also does a few things that make me feel like a responsible adult:

Git-based dates: Post dates come from the first commit. No more guessing when I actually wrote something. The repo knows. The repo remembers.
Automatic sitemaps: It walks the output and builds a sitemap so search engines don’t have to reverse-engineer my site like it’s an escape room.

Git-based dates (aka my memory replacement)

Previously, post dates were based on vibes, moon phases, and whether I remembered to write a date down somewhere. Sometimes I did. Often I did not.

Now I just ask git when a file was born and move on:

git log --diff-filter=A --format="%ad" --date=short -- posts/new-site-build-log.html
2025-12-30

When my memory fails, which it will, I can rely on the repo’s cold, unfeeling honesty. It’s like having a personal assistant who never sleeps and absolutely does not care about your excuses.

Automatic sitemaps (robots deserve nice things)

The sitemap is autogenerated, which means I no longer have to remember to update it. The build finds pages, sorts them, and spits out something search engines can understand without judgment.

<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://example.com/posts/new-site-build-log.html</loc>
    <lastmod>2025-12-30</lastmod>
  </url>
</urlset>

Yes, I know the robots will eventually overthrow us, but at least they’ll be able to find us quickly and efficiently when they do.

Templates, not chaos

The old site was basically one HTML file with a thousand tiny, regrettable edits layered on top of each other. Now I have an actual post template, which means I can focus on writing and let the build handle the boring structure stuff.

<main class="wrap">
  <h1 class="title">{{ title }}</h1>
  <div class="meta">{{ date }} • {{ tag }}</div>
  <article>{{ content }}</article>
</main>

It’s simple. It’s boring. It works. The best build systems are the ones that do stuff you should’ve automated about three years ago.

Why this is better than the old mess

The old site was “fine” in the same way a chair made of duct tape is fine. It works right up until it doesn’t. Any change meant editing live files and hoping I didn’t delete something important. And since the whole thing eventually vanished along with the server, that hope was optimistic at best.

Now I can diff changes, roll things back, and generally feel like I know what I’m doing. Posts are real files. Templates are consistent. Scripts do the boring work. I just write.

This is the setup I should’ve had from the start, but apparently I needed years of Ctrl-C and Ctrl-V archaeology, plus a lost domain, to learn that lesson.

The deploy ritual (now much less cursed)

Before: SSH into the server as root, edit files live, refresh, panic, fix, refresh again.

# old workflow (aka chaos)
ssh root@server
vi /etc/webroot/webpage.com/index.html
# :wq, refresh browser

Now it’s boring, in a good way:

# new workflow
git push

I’ve never built locally. Everything runs through Cloudflare Workers with GitHub integration. Every push gets a preview build automatically. If it looks good, it goes live. If it doesn’t, nothing breaks publicly and I quietly fix it.

Same hands-off approach as before, just without editing production files like a gremlin.

In summary

I still have too much free time during Christmas break, my AliExpress box of microcontrollers and power electronics is stuck somewhere in transit, and redoing the website is what happened instead. The site is cleaner, calmer, on a new domain, and no longer maintained through pure fear.

Give me six months and this will once again be an nginx monolith, tuned over multiple nights and enough caffeine to kill a Victorian-era child, while I stare at Qualys TLS test results like they personally insulted me.

Most importantly, I can now talk about my website without immediately apologizing or explaining why the old link is dead.