Assembly manual

The Build Order

Every guide on this site, arranged as the 73 steps you'd actually take building a homelab from nothing. Start at step 1 and work down, or jump to the phase you're on — the page remembers what you've finished.

0 / 73 steps complete
Jump to a phase
  1. 1Understand what you're building
  2. 2Plan & prep
  3. 3Install the base
  4. 4Create your first workloads
  5. 5Set up networking
  6. 6Reach it from anywhere
  7. 7Protect it
  8. 8Serve apps the right way
  9. 9See what it is doing
  10. 10Set up shared storage
  11. 11Run real services
  12. 12Build a media server
  13. 13Automate your media
  14. 14Remember what you built
  15. 15Go further
Phase 9

See what it is doing

Start with dead-simple up/down alerts, then add deep metrics and dashboards for the whole cluster — then use that history to answer what happens when a node dies.

  1. Uptime Kuma: Dead-Simple Homelab Monitoring Before You Touch GrafanaUptime 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.
  2. The Docker localhost Trap: 24 Hours of Red, Zero Real DowntimeMy 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.
  3. Proxmox Monitoring with Prometheus and Grafana: Full Stack SetupDeploy 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.
  1. Node Exporter + pve-exporter: Complete Proxmox Metrics in GrafanaInstall 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.
  2. Homelab Capacity Planning: What If a Node Dies Tonight?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.
  3. Real Screenshots, Zero Leaks: My Disposable Demo LabHow this site captures real, publish-safe homelab screenshots — a throwaway demo lab plus headless Chrome, with no mockups and no leaked IPs.
Phase 11

Run real services

The payoff — a smart-home hub, private photo backup, a knowledge base, password manager, local AI, and an autonomous agent. Then put it all on one dashboard.

  1. Run Home Assistant on Proxmox the Right Way (HAOS in a VM)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.
  2. Self-Host Your Photos with Immich: A Private Google Photos AlternativeReplace 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.
  3. Wiki.js on Proxmox LXC: Self-Hosted Knowledge Base in 30 MinutesDeploy 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.
  1. Vaultwarden on Proxmox LXC: Self-Hosted Bitwarden-Compatible Password ManagerDeploy Vaultwarden (the lightweight Bitwarden-compatible server) in an unprivileged Proxmox LXC container with HTTPS, automatic backups, and mobile client access via Tailscale.
  2. CPU-Only Ollama Cluster on Proxmox LXC: 3-Node Setup with Load BalancingRun 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.
  3. Open WebUI Advanced: RAG, Pipelines, and Custom System PromptsGo 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.
  1. Hermes Agent: Self-Hosted AI Agent with Fallback Model ChainsDeploy 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.
  2. Track AI Token Spend in Grafana: Claude, Codex, and OllamaWire every Claude Code, Codex, and Ollama call into Prometheus and one Grafana dashboard — tokens, latency, cache hits, and real dollars vs quota burn.
  3. One Dashboard for Your Whole Homelab: Set Up HomepageStop 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.
Phase 13

Automate your media

The *arr stack, then a request page for the whole house: someone taps Request and it downloads, files itself, and appears in your library — and keeps healing itself when it breaks.

  1. What Is the Arr Stack? Sonarr, Radarr, and Prowlarr ExplainedA 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.
  2. Deploy the Arr Stack with Docker Compose (Prowlarr, Radarr, Sonarr)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.
  3. Automating the Arr Stack: Import Lists, Quality Profiles, Media ServerMake 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.
  1. Jellyseerr: Let Your Family Request Movies ThemselvesGive your whole household a Netflix-style page to browse and request titles — Jellyseerr passes each approved request straight to Radarr and Sonarr, hands-free.
  2. The Self-Healing Arr Stack: Why My Watchlist Silently Stopped DownloadingA 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.
Phase 14

Remember what you built

Document your homelab in a Git-backed knowledge base so you never solve the same problem twice — and so your AI tools can read it too.

  1. Your Homelab Needs a Second Brain — Here's WhyYou'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.
  2. Never Lose a Homelab Note Again: A Git + Markdown VaultBuild 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.
  3. Never Commit a Secret to Your Knowledge BaseNever 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.
  1. Never Move a Note When a Project EndsWhen 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.
  2. Turn a Pile of Notes Into a Connected BrainTurn 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.
  3. Share Your Vault Across Machines Without Split-BrainYour 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.
  1. Why Auto-Syncing Your Notes Repo Will Corrupt ItBlanket 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.
  2. Turn Your Git Vault Into a Searchable Wiki.js SiteDerive 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.
  3. Semantic Search for Your Notes, Running LocallyGive 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.
  1. Make Your AI Agents Read the Docs First, Every TimeGive 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.
  2. Prove Your Homelab Docs Are Actually Up to DateA 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.
  3. Already Made a Mess of Your Notes? Here's the FixAlready 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.
  1. 10 Mistakes I Made Building a Homelab Second Brain (And How Each Got Fixed)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.
  2. RAG for Your Homelab Wiki: Answers That Cite Their SourceTurn your homelab wiki into a cited Q&A endpoint with dependency-free Node: retrieve-then-generate, every answer naming its source page, stale ones labelled.
Phase 15

Go further

Scale to a multi-node cluster, put it into code, run a game server, or build a native control app.

  1. Forming a Proxmox Cluster: Quorum, Corosync, and Joining Multiple NodesHow 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.
  2. Building a 4-Node Proxmox Cluster on HP EliteDesk Mini PCsHow 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.
  3. Turn a Hand-Built Proxmox Cluster Into Code Without Breaking ItIaC guides assume an empty account. Here's the import-first approach for a Proxmox homelab already running things you cannot afford to lose.
  1. Import a Live Proxmox Cluster Into OpenTofu With Zero ChangesBring running Proxmox containers under OpenTofu without restarting one: import blocks, the generated-config cleanup, and a clean plan that becomes your drift detector.
  2. Ansible for a Cluster You Built by Hand: Capture, Then AssertBring hand-configured Proxmox nodes under Ansible without changing them — capture live config into roles and make check mode your acceptance test.
  3. A Proxmox Container Born, Configured, and Destroyed From CodeProve your homelab's infrastructure code with a scratch container — OpenTofu creates it, Ansible configures it, a destroy removes it, production untouched.
  1. Rebuild Your Homelab From Zero: What Survives a Total LossA Proxmox disaster-recovery walkthrough — what survives losing every node, the restore order that unblocks itself, and two commands that prove the rebuild.
  2. Fabric Minecraft Server in a Proxmox LXC Container: Mods + JVM TuningRun 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.
  3. Building a Native Proxmox Dashboard in Flutter: Linux Desktop + iOSHow 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.

END OF MANUAL

Rack's full. Now it evolves.

New field notes ship as the lab grows — and the copy-paste scripts for everything above live in the playbooks.

Get new notes by emailBrowse the playbooks