Published on 1 January 2026

Ten years ago or so, I self-hosted everything: file storage, calendars, DNS, analytics, version control. I was in complete control. Or maybe I wasn’t. I didn’t understand half of what I was running. When something broke, I couldn’t diagnose it. I was blindly hosting software.

Eventually I gave up and moved to commercial services (free or paid): Cloudflare, Google Drive, etc. I was happy until I gradually preferred the idea of keeping more of my stuff at home and began to value control over convenience.

So, it’s now 2026 and I’m back to self-hosting.

My previous experience with self-hosting

I self-hosted at home and on a dedicated server: ownCloud for files (later Seafile), a git server with a WebUI, Radicale for CalDAV/CardDAV, OpenVPN, an authoritative DNS server with BIND 9, Matomo for analytics (back then Piwik), and a PHP gallery viewer (don’t remember the name). It was fun and rewarding at first. Then it became a maintenance job (not a pleasant one).

Standard UNIX software like BIND 9 was manageable, but for self-hosted Web-based SaaS it was another story. Each piece of software had its own language, deployment model, and constraints. Some needed Python-style deployment, others were PHP-CGI behind Apache or NGINX. Docker helped a bit, but one required MySQL while another required PostgreSQL, so I had to run both. Documentation had gaps. When something broke, where to even look?

Turns out I wasn’t just hosting software: I was operating a ball of mud I couldn’t fully understand. This was paradoxical: self-hosting is supposed to be about control, and I controlled nothing.

The real problem

In retrospect, the issue was never "self-hosting is hard." The issue was "hosting other people’s complex software is hard." I was running software that couldn’t reasonably work for a solo hobbyist:

• Built for broad audiences, not my specific needs
• "Open source" editions that felt hobbled, with self-hosting guidance scattered across GitHub discussions rather than official docs. Or even worse: vendors closing the door abruptly like MinIO just did last month.
• Complex configuration because the software itself was complex
• No guarantee of painless updates that won’t break things I’ll need to take care of

My new approach

These days, I host software I wrote myself. I understand exactly how it works because I designed it for my specific needs, with these constraints:

• Must run on my Raspberry Pi 4 (forces frugality)
• Most of the time, written in Go or TypeScript with Deno (easy static binary deployment, no complex toolchains)
• Very minimal dependencies (fewer things to break)
• No database, or SQLite if needed

So far, I self-host two tools on my Pi.

Hatame: Downtime detection. Built in two afternoons. Simpler than Uptime Kuma because it does exactly what I need and nothing else. Hopa: Web analytics without PII. Built in one afternoon. Simpler than Matomo because I’m not trying to replace Google Analytics for everyone.

I admit these are simple services. Building a full-fledged Google Drive replacement wouldn’t be as easy. But here’s the real question: do I really need a full-fledged replacement? Is there something much simpler that fulfills my specific needs?

The beauty of self-tailored software is speed: it only needs to serve one person. And it’s simple to host because that’s its only mission: make my life easier.

Or I’ll just use simple software

You don’t have to write everything yourself. The alternative to complex self-hosted software isn’t only custom code. It’s simpler software that already exists.

I access my Pi over SSH. I sync files with rsync. I host git repos as bare repositories over SSH, no web UI needed. These tools have been around for decades. They’re boring, well-documented, and they just work. They do one thing, store data in readable formats, and don’t require a dedicated sysadmin (it’s me) to operate.

This also means accepting that not everything needs self-hosting. My blog runs on Cloudflare Pages. It’s public by nature, so I don’t care where it lives. What matters is keeping private data under my control. That’s the actual goal. Not self-hosting purity.

If I build it, I can host it. And if the software is simple and boring enough, I can host it too.

Either way: I have control over my stuff.