It has been a busy stretch since I last wrote about turning the blog into a real part of this site. The visible work and the behind-the-scenes work ended up following the same theme: take something I care about, give it a clearer shape, and make it easier to operate with confidence.
The biggest addition visitors can see is a complete Cribbage game. It supports room-code games between two people, several computer-opponent difficulties, automatic scoring, discard and pegging hints, configurable score limits, and a few board styles. Most of the game state lives on the server, so the browser is presenting a shared game instead of trying to be the authority for one.
Cribbage was a much larger project than it first appeared. The basic loop is familiar, but there are a lot of small rules hiding inside dealing, the crib, pegging, go, counting hands, ending a round, and deciding exactly when a game is over. Building it meant separating those rules from the room lifecycle, making reconnects and concurrent actions safe, and then fitting all of that into an interface that still works on a phone. The computer player and hints added another layer: they needed to make useful choices while also being able to explain the scoring behind them.
The larger summer project was rebuilding my homelab. I moved from an older all-in-one setup to a small Proxmox cluster with dedicated Docker runtimes and a Git repository that describes the intended state. Applications, storage mounts, networking, secrets, health checks, and deployment rules now have reviewed definitions instead of living mainly as remembered commands. The transition included this portfolio, Git hosting, databases, monitoring, and the media services I use at home.
That rebuild also changed how this site reaches production. A push to the Portfolio repository runs the test suite, but it does not deploy by itself. Publishing a release builds an immutable container image for the exact commit and hands its digest to the infrastructure workflow. The infrastructure side validates that handoff, records the new image, and performs the deployment. It is more ceremony than a personal site strictly needs, but it gives me a real release path that I can inspect, repeat, and improve.
I put the same effort into seeing what the system is doing. Prometheus, Loki, Grafana, and Alloy now cover service health, capacity, logs, and the automation jobs that move work around the homelab. Actionable alerts go to a private ntfy instance, while application exceptions have their own private error tracker. The goal is not to build a miniature enterprise operations centre. It is to have enough signal that a failure leaves evidence and the useful next question is easier to ask.
Some of the most enjoyable work has been the media automation. I built a "Cartoon TV" system that can assemble and play a living channel from my own library, remember viewing history, and provide a small import queue for filling gaps. The torrent lifecycle around it became more deliberate too: downloads can be routed according to available storage, copies report progress, completed files are verified against their piece hashes, and cleanup waits for the seeding policy instead of guessing that a transfer succeeded. It is a wonderfully over-engineered way to put cartoons on a television, which is exactly why it was fun.
The less visible milestone is recovery. Databases are exported into encrypted backup sets, the Docker virtual machines have scheduled backups, and restore checks run against isolated temporary targets rather than production. I completed restore drills across the application-managed state and fixed several problems that only appeared when the backups were actually consumed. That work reinforced an old lesson: creating a backup is only the first half of the feature; proving that it can restore is what makes it useful.
More recently I added a private location-history service and turned stack upgrades into a release-aware workflow that checks compatibility and rollback assumptions before changing a running application. Those are small examples of where the homelab has ended up. It is still a place to experiment, but the experiments now have clearer boundaries, better records, and a much more reliable path from idea to running service.
There are plenty of rough edges left, and I expect there always will be. What feels different now is that the site and the infrastructure underneath it are no longer separate hobbies. The Portfolio gives me somewhere to build and explain projects; the homelab gives those projects a disciplined place to run; and each round of work makes the next one a little easier to understand.