The logbook
73 entries on homelab infrastructure, AI, monitoring, and more — recorded from a live cluster, not researched from other people's posts.
LAST ENTRY: JUL 31, 2026 · STATUS: RECORDING
New to homelabbing? Start here — hardware first, then build up the stack.
A homelab is your own private cloud running on hardware you control. Here's what a homelab actually is, why people build them, what you can run, and how to start — explained for complete beginners, no jargon.
A start-to-finish roadmap for building a Proxmox homelab: hardware, install, clustering, networking, storage, security, backups, and the self-hosted services worth running — each step linked to a full walkthrough.
A practical hardware guide for building a multi-node homelab — CPU, RAM, storage, and power requirements explained without the jargon, with specific recommendations at three budget levels.
What a network switch actually does, the real difference between 1GbE and 2.5GbE for homelab use, why managed switches matter for clustering, and how to wire up multiple Proxmox nodes correctly.
Stop reflashing your USB drive for every OS install. Ventoy lets you boot any ISO by dropping it onto a drive — perfect for homelabbers juggling Proxmox, Ubuntu, GParted, and more.
How to download Proxmox VE, write a bootable USB drive, install it on your hardware with the correct network settings, and complete the essential post-install configuration — including fixing the subscription nag and switching to the free package repository.
Essential security configuration for a new Proxmox cluster — SSH key-based authentication, disabling password login, configuring the built-in firewall, securing the web UI, and the audit steps to verify nothing is exposed that shouldn't be.
Create your first Proxmox LXC container from scratch — download a template, run the wizard the right way, choose privileged vs unprivileged, and do the first-boot setup. The homelab workhorse, explained.
Create a full virtual machine on Proxmox VE from scratch — upload an ISO, configure the VM wizard the right way, install the OS, and add the QEMU guest agent for clean shutdowns and live stats.
A true beginner's guide to Docker Compose. Learn what images, containers, ports, and volumes actually are by deploying your first real service — the foundation every self-hosted app is built on.
How to create a Proxmox VE cluster from multiple nodes — what Corosync and quorum actually mean, the exact commands to form and join the cluster, what to verify, and how to avoid the split-brain scenarios that corrupt data.
NAS explained in plain English — what network-attached storage does, commercial box vs DIY server vs a share on your Proxmox host, and how to choose the right one for your budget.
How to set up network file shares in a Proxmox homelab using Samba (for Windows/macOS) and NFS (for Linux). A beginner guide to a central file server your media, photos, and backups can all read from.
The correct way to run Home Assistant in a Proxmox homelab: Home Assistant OS in a dedicated VM, installed with the community helper script. Covers why a VM beats a container, and full onboarding.
Virtualisation, containers, storage, and cluster management.
A practical breakdown of Proxmox storage backends — what local-lvm actually is, when ZFS makes sense, how to add NAS storage over NFS, and the storage layout decisions that affect your cluster's performance and reliability.
A practical guide to choosing between a Proxmox VM and an LXC container — kernel sharing, isolation, density, performance, and a decision flowchart for every workload.
Turn an Ubuntu cloud image into a Proxmox template and clone ready-to-boot VMs in seconds — user, SSH key, and IP pre-configured by cloud-init, no installer wizard ever again.
The right way to run Docker on Proxmox — why a dedicated VM beats a privileged LXC, how to set both up, and Portainer for a web UI. Avoid the docker-in-LXC pitfalls that cost real downtime.
A practical reference for Proxmox LXC container networking — assigning static IPs, configuring the Linux bridge, setting up VLAN-aware bridges, and troubleshooting the common mistakes that cause connectivity failures.
Run Pi-hole in a Proxmox LXC container for network-wide ad blocking and local DNS — install it, point your router at it, add local hostnames, and avoid the one mistake that takes your whole network offline.
A practical guide to the Proxmox built-in firewall — cluster-level rules, node-level rules, container-level rules, IPSET groups for your trusted subnets, and the exact rule order that keeps your cluster safe without locking yourself out.
Deploy Proxmox Backup Server (PBS) in a dedicated LXC container, configure scheduled backups for all containers and VMs, and set retention policies — with verified restore procedures.
How to assemble a production-grade Proxmox VE 9 cluster from four HP EliteDesk 705 G4 mini PCs — hardware selection, quorum strategy, firewall, and the gotchas that cost a Saturday.
IaC guides assume an empty account. Here's the import-first approach for a Proxmox homelab already running things you cannot afford to lose.
Bring running Proxmox containers under OpenTofu without restarting one: import blocks, the generated-config cleanup, and a clean plan that becomes your drift detector.
Bring hand-configured Proxmox nodes under Ansible without changing them — capture live config into roles and make check mode your acceptance test.
Prove your homelab's infrastructure code with a scratch container — OpenTofu creates it, Ansible configures it, a destroy removes it, production untouched.
A Proxmox disaster-recovery walkthrough — what survives losing every node, the restore order that unblocks itself, and two commands that prove the rebuild.
Deploy Vaultwarden (the lightweight Bitwarden-compatible server) in an unprivileged Proxmox LXC container with HTTPS, automatic backups, and mobile client access via Tailscale.
Deploy Wiki.js in an unprivileged Proxmox LXC container with a PostgreSQL backend, HTTPS via a reverse proxy, and automatic backups — the exact setup powering this homelab's documentation.
Metrics, dashboards, and alerting with Prometheus and Grafana.
Use Network UPS Tools (NUT) so a single UPS can cleanly shut down every machine in your homelab when the power fails — one server, many network clients, step by step.
Uptime Kuma is the easiest way to monitor your homelab — know the moment a service goes down, with notifications to your phone. A beginner Docker guide to up/down monitoring and status pages.
My Uptime Kuma monitors logged 24 hours of red while every service was up. Inside a Docker container, localhost isn't your machine — here's why, and the fix.
Deploy a complete observability stack for a Proxmox cluster: node_exporter on all hosts, pve-exporter for cluster metrics, Prometheus scraping everything, and Grafana dashboards with email alerting.
Install node_exporter on every Proxmox node and pve-exporter for cluster-level metrics, wire both into Prometheus, and import production-ready Grafana dashboards — with alert rules for the metrics that actually matter.
I built a read-only simulator that answers whether a dead node's containers fit on the survivors — using the RAM they actually use, not the RAM you configured.
How this site captures real, publish-safe homelab screenshots — a throwaway demo lab plus headless Chrome, with no mockups and no leaked IPs.
Wire every Claude Code, Codex, and Ollama call into Prometheus and one Grafana dashboard — tokens, latency, cache hits, and real dollars vs quota burn.
Remote access, VLANs, switches, and secure tunnels.
Install Tailscale on one Proxmox node as a subnet router to make your entire homelab reachable from anywhere — no port forwarding, no VPN box, no dynamic DNS.
Configure a Proxmox LXC container as a Tailscale exit node so all your device traffic routes through your home network — including split tunneling, subnet routing, and the MagicDNS settings that make it seamless.
What a reverse proxy does, why every homelab needs one, and how Traefik gives your self-hosted services clean HTTPS URLs with automatic certificates instead of a mess of IP addresses and ports.
A hands-on walkthrough: deploy Traefik v3 with Docker, get automatic browser-trusted HTTPS from Let's Encrypt, redirect all HTTP to HTTPS, and route your first service to a clean domain using labels.
Local LLMs, agents, and self-hosted services.
Replace Google Photos with Immich on your Proxmox homelab. A beginner guide to installing Immich with Docker Compose, automatic phone backup, AI face and object search — all running on hardware you own.
Stop bookmarking IP addresses. Set up Homepage — a fast, self-hosted dashboard that puts every homelab service, live status, and system stats on one clean start page. Beginner Docker Compose guide.
Run local LLMs across three Proxmox LXC containers with Ollama, expose them via Open WebUI's built-in load balancer, and avoid the Docker-in-LXC pitfalls that cost me two sessions to fix.
Go beyond basic chat with Open WebUI — set up Retrieval-Augmented Generation with local documents, configure pipeline tools, create specialized assistants with custom system prompts, and use the API for programmatic access.
Deploy Hermes Agent on Proxmox LXC — a fully autonomous AI agent with tool use, Anthropic primary routing, and OpenRouter fallback chains. Includes the Kanban integration and CLI delegation setup.
You've solved the same homelab problem three times because you forgot how you fixed it. Here's the case for a single source of truth — and the payoff that compounds over years.
Build a homelab knowledge base on Git and Markdown — the substrate that gives you version history, plain-text durability, and one authoritative copy. Includes the SSHFS-over-bashrc mount pattern.
Never commit a password to your knowledge base — and if you already have, scrubbing it from the working tree isn't enough. Here's the store-pointers-not-values rule and the Git history purge.
When a project ends, don't move its notes to an archive folder — you break every link and bookmark pointing at them. Put lifecycle in frontmatter, not the file path.
Turn a flat pile of Markdown notes into a connected graph. Model topics as neurons and links as synapses, then generate the maps and region tags automatically from frontmatter.
Your laptop, your cluster, and your agents all need the vault — but only one copy can be authoritative. Use a direct mount for editing and a read-only forced-command SSH reader for everyone else.
Blanket auto-sync corrupts a canonical knowledge base. Replace it with a controlled write: lock, validate, commit, refresh projections, verify, unlock — so every change is atomic and every projection stays coherent.
Derive a published Wiki.js site from your Git vault as a read-only projection — one that reports the exact commit it was built from and cascades deletes so it never drifts from the source.
Give your knowledge vault semantic search with a local embeddings index — built on Ollama and nomic-embed-text, cached by content hash, and labeled with the commit it was built from so staleness is always visible.
Give your AI agents a revision-labeled cold start against your knowledge vault — verify the canonical commit, load only the pages the task needs, fail closed on mismatch, and persist outcomes through the controlled writer.
A knowledge base with many derived views is only trustworthy if every view proves it's current. The operations chapter: consumer parity, commit-matching health checks, a backup mirror, and correct failure behavior.
Already have split-brain repos, a secret in history, and pages moved on a whim? The recovery playbook: quarantine divergent copies, pick one authority, reconcile, and rebuild every projection clean.
What went wrong — and why — as I built a canonical Git vault, AI agent skills, write locks, and projection consumers: silent data loss, hanging CLIs, restore gaps, and the one mistake I made twice.
Media servers, streaming, and the *arr automation stack.
A practical 2026 comparison of Plex and Jellyfin — pricing, remote access, hardware transcoding, apps, and privacy — to help you pick the right self-hosted media server.
Set up Plex Media Server on a NAS or in a Proxmox LXC container, claim it to your account, and build your first movie and TV libraries the right way.
Set up the free, open-source Jellyfin media server on a NAS or in a Proxmox LXC container, run the first-time wizard, and build your first movie and TV libraries.
Why Plex stutters on low-power CPUs, how Direct Play avoids transcoding entirely, and how to tune Plex so 4K files play smoothly without a beefy processor.
Name movie and TV files so Plex matches them automatically, pick the right metadata agents, and fix wrong titles and broken sort order in an existing library.
A plain-English guide to the *arr stack — what Sonarr, Radarr, and Prowlarr each do, how they fit together, and how the automated media pipeline actually works.
Stand up the full *arr stack in Docker Compose — Prowlarr, Radarr, Sonarr, and a VPN-shielded download client — with the single-root folder layout that enables instant hardlink imports.
Make the *arr stack hands-off — import lists that add titles automatically, quality profiles that grab the best release, and a notification that refreshes Plex or Jellyfin on import.
Give your whole household a Netflix-style page to browse and request titles — Jellyseerr passes each approved request straight to Radarr and Sonarr, hands-free.
A real homelab incident — rotated API keys silently killed my Arr automation for days with zero errors. Here's the debugging story and the four patterns that make media automation immune to it: runtime keys, one consolidated script, an auto-detecting VPN-leak check, and a dead-man's-switch alert.
Full builds and fun experiments — gaming, apps, and tools.
Run a Fabric 1.20.1 Minecraft server in an unprivileged Proxmox LXC container with performance mods (Lithium, Starlight, Carpet), JVM garbage collection tuning, and systemd service management.
How I built MyOfficeLab (since renamed HomeLab) — a Flutter app with native Proxmox API integration, live CT metrics, Riverpod 3 state management, CEF webviews, and a dual-mode brass design system — targeting both Linux desktop and iOS from one codebase.