The homelab that finds its own faults.

One small computer, running your own software instead of renting it.

A "homelab" is a computer at home that runs the services most people pay a subscription for elsewhere — a streaming server instead of a cut of five streaming apps, your own file storage instead of a cloud drive, your own DNS and smart-home brain instead of letting a vendor hold them. Everything below runs on one machine, not a rack or a cloud account.

Each service runs in its own container or VM. A crash in one does not affect the others, and each gets its own share of processing power and memory rather than sharing a pool with everything else. Proxmox is what lets one small box behave like several separate machines.

Five things, and it can prove each one.

Every number below is read from the system's own registries when this page is built — the action vocabulary from the code that enforces it, the services from the file that decides how loudly each one pages, the guests from a capture taken off the hypervisor six-hourly. None of it is typed in by hand, since a feature list written by hand tends to drift out of sync with the system it describes.

A rack's worth of services — on a single small box.

Media, home automation, networking, and the platform to run them — around a dozen self-hosted services, each sized to a tight CPU and memory allowance and checked regularly by a resource watchdog that flags anything running short.

Three paths, picked from one corner of the map.

The service map above has five groups — media, home, access and edge, data and safety, observability. These three diagrams zoom into two of them: the media stack and the network edge. Home Assistant, the backups, and the observability stack each work differently and aren't pictured here — that's the next section.

Home Assistant, and what a decision actually cost to get right.

The rest of the house doesn't route through Seerr or Prowlarr at all. This is the other half: what a household member notices day to day, what Home Assistant automates on its own, and a few decisions that looked fine until they were measured.

The evidence behind the decisions.

Memory against each guest's ceiling, and the temperatures the hardware itself calls dangerous — sampled six-hourly from the hypervisor's own records, the last 14 days. Nothing here is a live reading: it is published on a deliberate delay, because a real-time load graph tells a stranger when the machine is busy and when nobody is watching it. The dashed line on each chart is the actual number a watcher would flag at — not the top of the box, the real threshold — and colour follows the same rule the changelog's state chips use below.

Every fix, the same eight questions answered each time.

What caught it, what the check's own threshold is, how that check gets triggered, what the agent was allowed to do about it, how it arrived at a recommendation, what stops the fix from breaking something else, how it was actually implemented, and what proves it worked. Pulled directly from the system's own issues and pull requests — a step with nothing recorded says so, rather than being smoothed over. Internal specifics (hosts, addresses, paths) are removed; the reasoning behind each fix is not.

One job each.

Each watcher checks one kind of state on a schedule and files what it finds as an issue. None of them applies a change.

Autonomous where it’s safe. Gated where it isn’t.

Six rules decide what an agent may change on its own, and what has to wait for a person.

A researched fix reaches your phone, and one tap records the decision.

The hard part is the last step: getting a problem that needs a person's judgement in front of a person, with enough context to decide in seconds, and making sure silence means the system is healthy rather than that nobody is listening. The tap records a decision; the change itself still goes through the same review as anything else.