Many machines, one fleet
I design, build, and run a small self-hosted infrastructure: a handful of machines, each with a defined role, meshed together and reachable from anywhere. This is the map of it: how the pieces connect, how it stays up when one of them doesn't, and what actually runs on it.
Solid line: the Tailscale mesh, every node reaches every other node directly. Dashed line at the top: the control plane’s outbound Cloudflare Tunnel, the only path in from the internet. Dashed arc: the standby Pi is interchangeable with the control plane, so that role — and the tunnel with it — can move there if the machine goes down.
- Control plane (Raspberry Pi): coordinates jobs across the fleet.
- Standby Pi: interchangeable with the control plane, so either role can move if a machine dies. It has done exactly that once, for real.
- GPU compute (a dedicated GPU box): runs the machine learning pipeline.
- Deploy host (a Mac mini): holds the fleet's database backups and vault archives, hosts the sync hub the laptop reaches the vault through, and is where site and demo deploys get pushed from.
- NAS storage (network-attached storage): holds the data everything else reads and writes.
Every machine sits on the same private Tailscale mesh, so any of them can reach any other directly without exposing anything to the open internet. Storage sits on its own subnet, reachable from the machines that mount it rather than from everything. The only door in from outside is a Cloudflare Tunnel on the control-plane Pi: it publishes a handful of self-hosted services without opening a single inbound port, and every one of them sits behind Cloudflare Access, so an unauthenticated request never reaches the app. The standby Pi carries its own connector so that door can move with the role.
The fleet is the ground under everything else here, and almost all of it runs on the two Linux machines rather than in a cloud account.
- Control plane (Pi) — carries the most. Tower, the MCP server that hands work to whichever machine should run it: how that works. Nexus, the dashboard and knowledge base watching node health, running jobs and my own notes. Prospect. Waypoint, with its separate study-library backend and a serial book-conversion worker beside it. The history service behind Breadcrumbs. The Cloudflare tunnel. Plus a few private services and the nightly maintenance timers that merge, lint, snapshot and publish.
- GPU compute — Loupe and its machine-learning pipeline, every model on my own hardware: the writeup. It also hosts a local open-weight model, so jobs that do not need a frontier model cost nothing to run, and it rebuilds the semantic index the dashboard searches.
- Deploy host — the fleet's database backups, the vault archives, the sync hub, and the machine deploys are pushed from.
- Storage — the bytes the rest of it reads and writes, on its own subnet.
- Standby Pi — idle until it is not.