Home/Grown Part III – Making it Mine

I can’t remember exactly when a Raspberry Pi first appeared on my radar, though I do remember thinking it was a wonderfully ridiculous idea. Here was a complete computer, roughly the size of a packet of cigarettes, costing very little money and apparently capable of doing almost anything provided you were prepared to spend long enough persuading it. Naturally, I bought one.

It was a Raspberry Pi 3B and my ambitions were initially fairly modest. Having started down the privacy rabbit hole, I wanted to try Pi-hole. The idea fascinated me: rather than blocking adverts on individual devices, why not stop the requests at network level before they ever got that far? There was something enormously satisfying about pointing the network at this tiny green circuit board and watching it quietly get on with the job. It felt like magic and, more importantly, it worked. Mostly. That qualification would become something of a recurring theme.

There was another moment around then which I think is probably familiar to anyone who has ever started self-hosting: the first time you type an address into a browser and a web interface appears from a machine sitting somewhere in your own house. It almost doesn’t matter what it is. Pi-hole, Portainer, a media server, whatever. The important thing is that you have pointed a browser at something you own and it has answered back. No external website, no cloud service, just your little machine quietly presenting you with a dashboard because you made it do that. That first login feels disproportionately exciting.

Until then, computers had largely been things I used. This was different. I had given one a job and it was now part of the fabric of the house. It wasn’t really a PC anymore; it was infrastructure. Once that idea gets into your head, things can get out of hand surprisingly quickly.

Around the same time I had started dabbling with smart home devices. I was already heavily invested in the Apple ecosystem and had no desire to sign my house over to a random collection of manufacturers, each with their own app, cloud platform and exciting new opportunity to gather information about me. Homebridge offered a way of pulling otherwise incompatible devices into HomeKit, so the little Pi gained another job.

This was still fairly innocent tinkering. There was no grand plan and I certainly wasn’t sitting there drawing architectural diagrams. I would find something interesting, read about it, then disappear down a rabbit hole trying to make it work. ChatGPT gradually became part of that process too. I would paste commands into a terminal, receive a screen full of angry-looking text, copy that into ChatGPT and ask what the hell I had done wrong. It would suggest something, I would try it, something else would break and back into ChatGPT it went. Round and round we would go.

Looking back, this was probably my first experience of what people would later call vibe coding, except I wasn’t really coding. I was vibe building an entire network. There were evenings where I understood exactly what I was doing and others where I had little more than a vague sense that the command I’d just pasted looked plausible and didn’t appear to contain the words rm -rf.

I loved it. Part of the appeal was technical curiosity, though there was something else happening as well. I found the whole process oddly therapeutic. Life could be noisy and complicated and the homelab gave me somewhere else to go. For a few hours there was only the problem in front of me: why couldn’t one container see another, why had DNS stopped resolving and why had something that worked perfectly well at eleven o’clock suddenly decided at quarter past midnight that it had never heard of me? These were solvable problems. Sometimes.

The Raspberry Pi 3B was eventually joined by a Pi 4. I tried Home Assistant because, according to the internet, everybody who owned more than three smart bulbs appeared legally obliged to install it. I could immediately see why people loved it. Home Assistant could seemingly automate anything and, given sufficient time, sensors and YAML, could probably detect that I had entered the kitchen in a slightly melancholic mood and adjust the lighting accordingly.

I didn’t get on with it. For what I wanted, it felt like far too much machinery. I didn’t want my house to become a software development project. I wanted the lights to come on. AdGuard Home fared much better and gradually replaced Pi-hole. DNS filtering was becoming less of an interesting trick and more of a fundamental part of how I wanted the network to operate.

Somewhere around this time I discovered Docker and Portainer, which was arguably the moment the brakes came off completely. Docker was dangerous knowledge, not dangerous in any real sense, obviously, but dangerous in the sense that suddenly almost every interesting self-hosted application on the internet appeared to be about five lines of copied text away from existing on my network. Portainer made it even worse because it gave me a nice graphical interface where I could see all the things I had installed, all the things I’d forgotten I’d installed and all the things currently restarting every thirty seconds for reasons known only to themselves.

Some things survived, some disappeared the same evening and others sat there broken for weeks or months waiting for me to get around to fixing them. That became part of the character of the lab. It was never finished. There was always some container sulking in the background, some project ninety percent complete or some configuration I knew wasn’t quite right but wasn’t annoying enough to deal with yet. Occasionally I would find something I’d completely forgotten about and think, oh yes, I was going to fix that. In other words, much like most engineering projects.

Then came the Raspberry Pi 5. Mine had a 1TB NVMe drive and, for the first time, I started thinking less about little background utilities and more about running something genuinely useful. I wanted my own cloud.

Dropbox had been useful for years, particularly for sharing material with the band, though I was increasingly reluctant to keep paying someone else to store my files. Nextcloud seemed like an obvious answer. Installing it was one of those projects where I began with the belief that I would probably have it working before tea, then emerged several days later knowing far more about databases, permissions and web servers than I had intended.

Eventually, there it was: my own cloud, sitting on my own hardware and accessible through a browser. That felt significant because I wasn’t just adding another interesting service; I was replacing something commercial with something I controlled myself. The Pi 5 did a decent job, though once other people were using it the cracks began to show. Nextcloud needed more headroom than I was comfortable asking a Raspberry Pi to provide, so eventually the Pi settled into a better role as an internal media server running Jellyfin. The experiment hadn’t failed. It had simply shown me what the next step needed to be.

Then the GL.iNet routers arrived and the network itself became part of the project. AdGuard Home, encrypted DNS, VPN routing and Tailscale all began to fit together. I could decide where traffic went, reach machines remotely and start thinking about the network as something I was deliberately shaping rather than just something provided by a router. Tailscale in particular felt faintly magical the first time I used it. Machines in different places suddenly behaved as though they were sitting next to each other.

That eventually led to the purchase of a small x86 mini PC and a proper home for Nextcloud. The difference was immediate. Suddenly there was enough memory and processing power that I could stop worrying whether one more service might tip the whole thing over. Nextcloud became something other people could actually depend on, and that changes your relationship with a server remarkably quickly. Breaking something at two in the morning because you fancied trying a new configuration is considerably less funny when somebody else needs it at nine.

Cloudflare Tunnels solved the next problem, giving me a safer way to expose selected services externally without simply opening ports through the router. Once you can publish things easily, of course, you start thinking of things to publish.

For quite some time I had been meaning to return properly to blogging. I had written online for years through Northern Stories, which had begun in 2009 and documented a lot of my life around music, gigs, bands, venues and whatever else happened to be going on at the time. I’m glad that history exists, though by the end Northern Stories had become a bit of an albatross.

The problem wasn’t really the site itself. I had changed. Some of the writing belonged very obviously to another period of my life. There was more drama, more oversharing and rather too much of that slightly self-important “look what I’ve done” tone which can creep into personal websites. For a while I simply stopped.

The idea of having my own site never really went away, though, and by then self-hosting had changed the way I thought about the whole thing. If I was going to return to blogging, why not host that myself too? That was the beginning of Outpost 10.

At first it was simply another WordPress installation running on the homelab, though it quickly became something more. Northern Stories had often been about documenting what was happening. Outpost 10 became much more about what those things had meant to me. It felt less like rebuilding the old site and more like finally letting it go.

The fact that Outpost 10 lived on my own hardware mattered too. I had already reclaimed bits of DNS, storage, media and remote access. Now I had somewhere of my own to publish as well. The machine serving these words was sitting in my own home and that still gave me a little thrill.

Outpost 10 grew slowly. I experimented with layouts, rewrote old material and gradually worked out what I wanted it to be. Eventually it grew arms and legs, becoming somewhere for music history, recording, technology, old projects, new projects and, eventually, the homelab itself.

Around the same broad period another Raspberry Pi 5 appeared. This one became Publius. By then I had begun thinking more deliberately about separating roles and had designs on owning more of my social presence too. Publius was intended to become a public-facing node and one of its first serious jobs was a self-hosted Bluesky PDS.

It didn’t really work out. I got far enough to prove the idea was possible, then ran into the familiar combination of configuration, integration and lack of time. The PDS joined that category of things which were neither working nor completely abandoned. It sat there waiting for me to come back to it, and the idea itself never really went away.

By this stage the lab was also mature enough that I had started doing things simply because they were interesting. At one point I self-hosted the entirety of Wikipedia using Kiwix. This was undeniably cool. Having a vast chunk of human knowledge sitting locally on my own network, completely independent of the internet, appealed enormously to the same part of my brain that had started this whole thing.

It was also perhaps a touch too far into Tom Good territory. I had used a substantial amount of storage to solve the urgent problem of being able to read Wikipedia during an apocalypse. Kiwix is a brilliant project, though in my case there were probably better uses for the space. Just because you can do something doesn’t necessarily mean you should.

The lab was also beginning to move beyond hosting services. I wanted to understand what was happening around them. That curiosity eventually became Watchtower, a Raspberry Pi running Kali Linux with Kismet and wireless hardware attached. Suddenly Wi-Fi networks, clients and radio activity that had previously been invisible became something I could actually see.

Oracle followed and gradually became a more general network node, collecting monitoring, discovery, AdGuard Home and the various tools I used to see what was alive and what was talking. By then machines had started acquiring names because “the Raspberry Pi in the other room” was no longer a sufficiently useful description. There was also something pleasingly absurd about giving grand science-fiction names to tiny computers performing mundane household duties.

As the setup grew, one weakness became increasingly obvious: almost everything important was still in the same building. Publius eventually found a better role. The public-server experiment had largely run its course, so the machine was repurposed, moved off-site and renamed Borg. Connected back through Tailscale, it became somewhere physically separate to keep important backups. That was fairly typical of the homelab by then. Hardware rarely became obsolete. It simply found another job.

Meanwhile Outpost 10 continued to grow and the older ideas around a more independent social presence started making sense again. The PDS eventually came back into view and GoToSocial joined the picture. I had been thinking about self-hosted music and video for a long time too, with Funkwhale and PeerTube sitting in the mental queue waiting for their turn.

Some ideas arrived long before I had the time, hardware or patience to make them work properly. By then I had learned that the homelab didn’t need to be finished.

Looking back, the thing which strikes me most is how far it all travelled from that first Raspberry Pi 3B. There had never been a moment when I consciously decided to build a homelab; I just kept solving problems, following curiosities and occasionally creating entirely new problems for myself along the way. Somewhere in the process the pile of Raspberry Pis, mini PCs and half-working Docker containers turned into infrastructure.

More importantly, the way I thought about it changed. I had started by installing applications. Eventually I was thinking about systems: where something should live, what depended on it, how it reached the outside world, what happened if it disappeared and where its data was backed up. I didn’t learn that from a course. I learned it by breaking things, repeatedly.

ChatGPT became an enormous part of that journey, though in those days it was still outside the lab. I would ask what to do, copy the commands across, open the terminal, make the changes and report back what happened. Hour after hour and night after night, there was something almost meditative about it. The rest of the world disappeared for a while and there was only me, a terminal window and whatever completely unnecessary technical challenge I had decided needed solving that evening.

It felt creative. I wasn’t just maintaining computers; I was making something. Some of it worked, some of it sat broken for months and some of it turned out to have been a terrible idea, though a surprising amount of it eventually worked. I had, without really intending to, vibe built myself a homelab.

Outpost 10 had already shown me that the lab could become more than plumbing. The PDS and GoToSocial experiments showed that I wanted those things to connect together too, while Funkwhale and PeerTube were still waiting in the wings. Until then, though, the intelligence had always remained outside. ChatGPT suggested, I copied and the machines obeyed.

Then local AI started becoming genuinely interesting. At first it looked like just another thing to install, another service and another rabbit hole. I had no idea that this one was going to change the relationship between me and the entire homelab.

The machines had spent years waiting for me to tell them what to do. Very soon, one of them was going to start answering back.