The UX of Infrastructure: What Homelabbing Taught Me
Phase 4 · Autonomous Agents and UX
What changes in the way a designer draws the next screen once they have learned the plumbing: latency, friction, documentation, and the quiet dividend of seeing what is underneath.
I stood in front of the rack one evening in August and noticed, with some surprise, that it was quiet. Not literally quiet (the fans were audible, the GPUs were breathing) but quiet in the sense that everything on it was working, monitored, backed up, and understood. The monolith I had bought on a whim eighteen months earlier had become a network. The network had become an AI. The AI had become an agent. And none of it looked, at that moment, like the thing I thought I was going to build when I started wiping drives in February.
What I had built was not really a homelab. It was a curriculum. Infrastructure taught me, over eighteen months and twenty entries, how to see interfaces I had been ignoring my whole career.
The analogy
Most UX designers spend their careers drawing bathrooms. They choose the tile, they specify the mirror, they argue about the tap finish. The bathrooms they draw are beautiful. The bathrooms they draw also routinely fail to arrive at the construction site, because nobody on the design team knows where the water is actually going to come from.
The architect is the designer who has walked through the basement. They still draw bathrooms. They draw them differently, because now they know where the risers fit between the walls.
Learning the plumbing did not make me a less-visual designer. It made me a designer who stopped designing things that engineers had to quietly disappoint.
The tech translated
Enterprise operations has a term called single pane of glass: the idea that one dashboard should show one administrator the complete state of a complex system at a single look. It is usually introduced in a tone that implies it is a hard, technical, server-side problem: integrating metrics, reconciling log formats, streaming alerts.
It is not a technical problem. It is a design problem wearing a technical hat.
A person cannot act on information they cannot see. Forty virtual machines, three segmented networks, six autonomous agents, and a software factory do not fit in any human’s head. If the operator cannot see them, they cannot secure them, update them, or reason about them. Complexity is the enemy of security, and bad design is the enabler of complexity. The principles for arranging a single pane of glass are the same principles for arranging anything else a human has to parse: hierarchy, clarity, consistency, progressive disclosure. The dashboard is a piece of interaction design. It just happens to be the interaction design that decides whether a network gets breached.
The action
Documentation as the interface
The last server I built in this lab was not made of silicon. It was made of Markdown.
Running in parallel to the hardware, I kept an Obsidian vault with one file per thing: every physical node, every VLAN, every firewall rule, every model checkpoint, every automation script. The files link to each other. A link from a host file takes me to the rack location, the ZFS pool, the backup schedule, the services it runs, and the last firmware update. Mermaid diagrams sit inline where the flows demand them.
---
node: ai-behemoth
location: Rack · Slot 2
role: Bare-metal LLM + image generation
gpus: [gpu-0, gpu-1]
pool: tank
vlan: lab-40
services:
- ollama
- open-webui
- comfyui
backup: proxmox-backup · nightly · 02:00
---
```mermaid
flowchart LR
laptop --> vlan-trusted --> vlan-lab --> ai-behemoth
ai-behemoth -.snapshots.-> proxmox-backup
ai-behemoth --data--> tank
```
## Last firmware update
2025-07-02 · `nvidia-driver-570` · no regressions · [see run log](runs/2025-07-02.md)
This is the real single pane of glass. It is not a dashboard; it is a vault. When a service breaks at two in the morning, I do not remember what router port it uses. I open the file and the file remembers for me. The documentation is the user interface of the infrastructure, and it is the part of the lab that most consistently rewards the effort.
What the lab taught me about design
Six things I did not know at the start of February 2024, and cannot unknow now:
- Data has weight. A 12-gigabyte AI model is a logistical fact before it is a file. Latency is not a spinner; it is a user cost measured in real seconds. The next wireframe I draw will have the transit cost annotated.
- Processing is not free. Progress indicators stopped looking ornamental the day I watched a GPU spend thirty seconds loading a model into VRAM. The user deserves to know what the machine is doing, not because it is polite, but because they are paying for it in attention.
- Security is friction, and friction is a budget line. Zero-Trust works because every door has a bouncer. Every bouncer is a user cost. The designer’s job is to place those doors where the cost is tolerable, and to name them in a way that does not feel punitive.
- Engineers are users too. The API I wrote for Project Symposium had a terrible error message for about a week, until I had to debug it myself at midnight. Error copy is UX copy.
- Systems drift. The prettiest dashboard goes stale inside a quarter if nobody is tending the data behind it. Designing for maintenance is a different skill than designing for launch, and the lab is mostly maintenance.
- The invisible layer sets the ceiling. A designer cannot build a latency-forgiving interface on top of a latency-multiplying stack. Infrastructure is the cap on experience, and a designer who cannot read it is working blind to their own ceiling.
The thread
The 20-entry arc started with wiping a Windows installation off a rescued desktop. It ends with the realisation that the two disciplines I thought I was bridging (systems architecture and user experience) are not two disciplines. They are the same discipline at two scales: the arrangement of parts into something a human can act on. The rack is a composition. The dashboard is a composition. The wireframe is a composition. The machine is built, the network is secure, the AI is awake, the documentation is alive, and the lab is open.
I did not become a different designer. I became the same designer, with the basement lights on.
Footnotes
-
“Single pane of glass” entered operations vocabulary in the early 2000s alongside the first enterprise monitoring suites. The current usage is traced to telecom network operations centres, where a single display consolidated alarms from dozens of specialised subsystems; the phrase has since migrated into security operations and observability tooling, carrying the same promise and the same unsolved design problem. ↩