Stop Losing Track of Your Homelab! Use Home Lab Hub Instead

You just spent three hours debugging a failed service. Was it running on the Proxmox box in the garage? The Raspberry Pi under your desk? Or that old Dell you scored from eBay and forgot to label? If you're nodding right now, you're not alone. Thousands of homelab enthusiasts are drowning in undocumented infrastructure — scattered spreadsheets, forgotten SSH notes, and the dreaded "I'll remember this later" mental model that never survives a weekend project.

Here's the brutal truth: your brain is not a configuration management database. Every undocumented VM is a ticking time bomb. Every unmapped network share is a security blind spot waiting to bite you at 2 AM. The difference between a toy collection and a professional-grade lab isn't the hardware budget — it's visibility.

Enter Home Lab Hub — the open-source infrastructure mapping tool that top homelabbers are quietly adopting to transform chaos into clarity. Built by RaidOwl, this isn't another bloated enterprise CMDB shoehorned into your basement. It's purpose-built for the homelab reality: fast, lightweight, and obsessively focused on the problems that actually keep you up at night. In the next few minutes, I'll show you exactly why this tool might be the single most important addition to your stack this year.

What is Home Lab Hub?

Home Lab Hub is a self-hosted web application designed specifically for mapping, managing, and visualizing home lab infrastructure. Created by RaidOwl, it's rapidly gaining traction in the self-hosting community as the antidote to "homelab amnesia" — that chronic condition where you accumulate servers, VMs, and services faster than you can document them.

Unlike generic inventory tools or over-engineered ITSM platforms, Home Lab Hub speaks fluent homelab. It understands that your "production environment" might be a Frankenstein cluster of refurbished enterprise gear, ARM SBCs, and cloud VPS instances you're testing against. It doesn't force ITIL workflows or demand enterprise licensing. Instead, it gives you immediate, visual control over hardware, virtual machines, applications, storage devices, network configurations, and even miscellaneous gear that defies categorization.

The project is trending now because it arrives at a perfect inflection point: homelabs have exploded in complexity. Kubernetes clusters, TrueNAS SCALE migrations, Proxmox VE deployments, and software-defined networking have turned hobbyist setups into miniature data centers. Yet the documentation tools haven't kept pace. Spreadsheets break at scale. Wiki pages rot. Diagrams become obsolete the moment they're exported. Home Lab Hub solves this with living, interactive infrastructure maps that update as your lab evolves — not after you've already forgotten what changed.

Built on a modern, future-proof stack (Python 3.14, Svelte 4, Cytoscape.js for graph visualization), it's designed to run anywhere: your power-sipping Raspberry Pi, that x86 NAS you've been meaning to repurpose, or even Windows with WSL2. The Docker deployment takes literally 60 seconds. And with one-click JSON export/import, your data is never trapped.

Key Features That Set It Apart

Home Lab Hub isn't a feature-dumped side project — every capability solves a specific homelab pain point. Here's what makes it genuinely powerful:

Full CRUD Inventory Management — Create, read, update, and delete records across seven entity types: hardware (physical servers, SBCs, networking gear), VMs (your virtualized workloads), apps/services (containers, bare-metal applications), storage (pools, arrays, individual drives), networks (VLANs, subnets, WiFi configurations), shares (NFS, SMB, iSCSI, FTP, SFTP, WebDAV), and a catch-all miscellaneous category for the weird stuff. Each entity type has tailored fields, not generic key-value dumping.

Intelligent Shares Management — This is where Home Lab Hub shows it truly understands storage administration. When you create a share under a storage device, the system auto-populates connection details based on the parent storage and share type. No more hunting for the correct NFS export path or wondering which SMB version your TrueNAS box is serving. The relationship is explicit and navigable.

Interactive Network Visualization — Powered by Cytoscape.js, the graph map renders your infrastructure as a depth-first layout graph showing explicit relationships between components. Click a server, see its VMs. Click a VM, see its applications. Click storage, trace every share. This isn't a static diagram — it's a living topology that reflects your actual configuration.

Hierarchical Tree View — Prefer structure over graphs? The collapsible tree view gives you nested, expandable navigation through your entire infrastructure. Drill from datacenter → rack → server → VM → application in seconds.

Markdown Documentation with Live Preview — Built-in hierarchical docs using ByteMD editor with live preview and auto-save. Document runbooks, network diagrams, recovery procedures — all versioned with your infrastructure data, not siloed in a separate wiki.

Cross-Entity Search & Sortable Tables — One search box filters across all inventory types simultaneously. Tables support ascending/descending sort on any column. Find that mystery container named something-redis-thing in milliseconds.

Relationship Tracking — Both automatic relationships (shares linked to storage devices) and manual relationship mapping (custom dependencies, power hierarchies, network dependencies) give you complete dependency awareness.

Accessible Modal Dialogs — Clean, keyboard-navigable forms for creating and editing entities. No page reloads, no context loss.

Real-World Use Cases Where Home Lab Hub Shines

The "What Was I Thinking?" Recovery Scenario

You built a Plex server six months ago. It works perfectly. Now you need to migrate it to new hardware. Problem: you don't remember which LXC container it's in, which ZFS dataset holds the media, or why there's a mysterious cron job running at 3 AM. With Home Lab Hub, you'd have documented the VM, linked it to storage, noted the cron in docs, and mapped the network shares — turning a weekend of archaeology into a 30-minute migration.

The Multi-Site Homelab Operator

You maintain labs at home, your parents' house (offsite backup target), and a cheap VPS for public-facing services. Home Lab Hub's export/import and portable Docker deployment let you run identical management interfaces across all three sites, with JSON backups you can version-control in Git. No more SSHing into three different boxes to remember what's where.

The Certification Studier Building Complex Topologies

Studying for RHCSA, CKA, or CCNA? You're spinning up and tearing down complex environments weekly. Home Lab Hub's rapid inventory creation and visualization lets you document each study topology as you build it, reinforcing learning through explicit relationship mapping. When you revisit a topic three months later, your infrastructure graph becomes a visual study guide.

The Small Business Side Hustle

That "homelab" is actually hosting client WordPress sites, a Nextcloud instance for your freelance work, and a VPN for remote access. You need professional-grade visibility without enterprise tool costs or complexity. Home Lab Hub gives you client-separable inventory tracking, documented backup targets, and network share monitoring — all self-hosted with zero subscription fees.

The Hardware Hoarder Finally Getting Organized

Twenty SBCs, eight hard drives of unknown provenance, three switches you forgot to configure, and a drawer of power supplies. Home Lab Hub's miscellaneous category and hardware tracking finally give you a single source of truth. Serial numbers, purchase dates, warranty status, current deployment status — all searchable and sortable.

Step-by-Step Installation & Setup Guide

Docker Deployment (Recommended — 60 Seconds)

The fastest path to running Home Lab Hub. Works on x86_64, ARM64 (including Raspberry Pi 4+, Orange Pi), macOS, and Windows.

Single container with docker run:

# Pull and run the latest image with persistent data
docker run -d \
  --name homelab-hub \
  -p 8000:8000 \
  -v ./data:/data \
  --restart unless-stopped \
  raidowl/homelab-hub:latest

Or use Docker Compose for easier management:

Create docker-compose.yml:

services:
  homelab-hub:
    image: raidowl/homelab-hub:latest
    container_name: homelab-hub
    ports:
      - "8000:8000"
    volumes:
      - ./data:/data
    restart: unless-stopped

Then deploy:

docker compose up -d

Access at http://localhost:8000. Data persists in ./data/.

Upgrading with zero downtime:

# Always backup first
cp -r ./data ./data-backup-$(date +%Y%m%d)

# Pull latest and restart
docker pull raidowl/homelab-hub:latest
docker compose down
docker compose up -d

Migrations run automatically on container startup.

Non-Docker Deployment (Full Control)

For those who prefer direct installation or need custom Python/Node environments.

Prerequisites: Python 3.14+, Node.js 24+, pip, npm

Step 1: Clone repository

git clone https://github.com/raidowl/homelab-hub.git
cd homelab-hub

Step 2: Backend setup

cd backend

# Create isolated Python environment
python3 -m venv .venv

# Activate (Linux/macOS)
source .venv/bin/activate
# Or Windows: .venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

Step 3: Frontend build

cd ../frontend
npm install
npm run build

Output goes to frontend/dist/.

Step 4: Database initialization

cd ../backend
alembic upgrade head

SQLite database auto-creates at data/homelab-hub.db on first run.

Step 5: Run the application

Development mode (single process):

python wsgi.py

Production with Gunicorn:

gunicorn -w 4 -b 127.0.0.1:5001 wsgi:app

Configure Nginx reverse proxy (see README for full config), or use systemd auto-start for boot-time availability.

REAL Code Examples from the Repository

Example 1: Docker Compose Production Deployment

The repository provides this production-ready Docker Compose configuration. Let me break down why each element matters:

services:
  homelab-hub:
    image: raidowl/homelab-hub:latest
    container_name: homelab-hub
    ports:
      - "8000:8000"    # Expose web UI on host port 8000
    volumes:
      - ./data:/data    # CRITICAL: Persist database across container recreations
    restart: unless-stopped  # Auto-recover from crashes, not manual stops

The unless-stopped restart policy is deliberately chosen over always — it respects intentional shutdowns during maintenance but recovers from unexpected failures. The volume mount ./data:/data is non-negotiable for production; without it, every docker compose down wipes your inventory. The image tag latest keeps you current, though pinning to specific versions (:v1.2.3) is safer for stability-critical deployments.

Example 2: Complete Backup and Restore Workflow

Home Lab Hub's JSON export/import is its secret weapon for data portability. Here's the complete API-based workflow:

Export your entire inventory:

# Export with timestamped filename for versioning
curl -X GET http://localhost:8000/api/inventory/export \
  -o homelab-export-$(date +%Y%m%d).json

This single command captures all seven entity types plus documents and relationships — hardware, VMs, apps, storage, networks, shares, misc items, and markdown docs. The JSON structure preserves foreign key relationships, so restores maintain integrity.

Import to a fresh instance:

curl -X POST http://localhost:5001/inventory/import \
     -H "Content-Type: application/json" \
     -d @export.json

Critical warning from the documentation: Importing clears all existing data before restoring. This design prevents merge conflicts but demands pre-import backups. For Docker users, the workflow adapts:

# Export from running container
docker exec -it homelab-hub \
  curl -X GET http://localhost:5001/inventory/export \
  -o /tmp/export.json

# Copy to host
docker cp homelab-hub:/tmp/export.json ./backup.json

# Later: import to new container
docker cp backup.json new-homelab-hub:/tmp/backup.json
docker exec -it new-homelab-hub \
  curl -X POST http://localhost:5001/inventory/import \
  -H "Content-Type: application/json" \
  -d @/tmp/backup.json

This pattern enables site-to-site migrations, disaster recovery, and version-controlled infrastructure state when you commit exports to Git.

Example 3: Production Nginx Reverse Proxy Configuration

For non-Docker production deployments, the repository includes this battle-tested Nginx configuration:

server {
    listen 8000;
    server_name localhost;  # Replace with your domain for external access
    client_max_body_size 10M;  # Allow large export/import files

    # Serve static frontend files (built Svelte app)
    location / {
        alias /path/to/homelab-hub/frontend/dist/;
        try_files $uri /index.html;  # Enable client-side routing
    }

    # Proxy API requests to Gunicorn backend
    location /api/ {
        proxy_pass http://127.0.0.1:5001;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

The try_files $uri /index.html directive is essential for Svelte's client-side routing — without it, direct links to /hardware/42 would 404. The proxy_set_header directives preserve client IP information for logging and rate limiting. The 10MB body size accommodates large JSON exports.

Example 4: Systemd Auto-Start Service

For Linux production deployments, this systemd unit ensures your lab manager survives reboots:

[Unit]
Description=Home Lab Hub
After=network.target  # Ensure network is up before starting

[Service]
Type=simple
User=homelab  # Dedicated unprivileged user (security best practice)
WorkingDirectory=/path/to/homelab-hub/backend
Environment="FLASK_ENV=production"
Environment="DATABASE_URL=sqlite:////path/to/homelab-hub/data/homelab-hub.db"
ExecStart=/path/to/homelab-hub/backend/.venv/bin/gunicorn \
  -w 4 -b 127.0.0.1:5001 wsgi:app
Restart=on-failure
RestartSec=10  # Prevent rapid restart loops

[Install]
WantedBy=multi-user.target  # Start at boot

Key security decisions: dedicated homelab user limits blast radius, absolute paths to virtualenv Python avoid PATH issues, and RestartSec=10 prevents resource exhaustion during startup failures. The DATABASE_URL environment variable enables SQLite location customization — critical for backup scripting.

Advanced Usage & Best Practices

Version Your Exports in Git — Treat homelab-export-*.json as infrastructure-as-code. Commit weekly exports to a private repo for audit trails and rollback capability. The JSON format diffs reasonably well for spotting unintended changes.

Leverage Relationship Mapping for Impact Analysis — Before rebooting that TrueNAS box, check the graph view. Which VMs depend on its iSCSI shares? Which apps reference its SMB paths? Manual relationship links turn guesswork into informed maintenance windows.

Document in Hierarchical Markdown — Use the built-in docs for runbooks, not just descriptions. "How to recover Plex from backup" belongs adjacent to the Plex app record, not in a separate wiki that becomes stale. The live preview and auto-save remove friction from documentation maintenance.

Configure Environment Variables for Multi-Instance — Running separate instances for lab and production? Use DATABASE_URL and FLASK_ENV to isolate contexts without code changes.

Monitor with the Health Endpoint — GET /api/health returns status for uptime monitoring (Uptime Kuma, Healthchecks.io). Add it to your existing observability stack.

Scale Gunicorn Workers to CPU Cores — The default -w 4 assumes a quad-core system. For Raspberry Pi or shared hosts, reduce to -w 2. For dedicated x86 servers, match worker count to CPU threads.

Comparison with Alternatives

Why Home Lab Hub wins for homelabbers: NetBox is phenomenal for enterprise datacenters but demands infrastructure overkill for a 5-node Proxmox cluster. Spreadsheets die at relationship complexity. Wikis separate documentation from live inventory. Home Lab Hub occupies the sweet spot of capability without complexity — genuinely useful from minute one, not after a week of configuration.

FAQ

Is Home Lab Hub free to use?

Yes, completely. Released under MIT license. No paid tiers, no feature gates, no telemetry. Self-host on your own hardware with full data ownership.

Can I run this on a Raspberry Pi 4?

Absolutely. ARM64 support is first-class. The Docker image auto-selects the correct architecture. With SQLite and efficient Svelte frontend, resource usage stays well within Pi 4 capabilities.

Does it support multiple users or authentication?

Currently single-user focused. The README doesn't document multi-user auth, suggesting this is on the roadmap or intentionally simple for personal use. For shared family labs, consider reverse proxy authentication (Authelia, Authentik) as a workaround.

How do I migrate from my existing spreadsheet inventory?

Use the JSON import format as a template. Structure your spreadsheet data to match the export schema, convert to JSON, and import. The API endpoints also enable scripted migrations for larger datasets.

What happens if the project stops being maintained?

Your data remains portable JSON — no vendor lock-in. The MIT license permits community forks. The tech stack (Flask, Svelte, SQLite) is stable and widely understood, ensuring long-term viability.

Can I monitor resource usage (CPU, RAM, disk) in real-time?

Not natively — Home Lab Hub is an inventory and documentation system, not a monitoring platform. Integrate with Prometheus/Grafana, Netdata, or your existing monitoring stack. Use relationship links to document which monitoring covers which systems.

Is there a cloud-hosted option?

No, and that's intentional. Self-hosting ensures your infrastructure data never leaves your network — critical for labs containing internal services, VPN configurations, or sensitive network topology.

Conclusion

Your homelab represents hundreds of hours of learning, troubleshooting, and incremental improvement. But undocumented infrastructure is technical debt compounding silently — until the 2 AM outage when you can't remember which VLAN that critical service lives on, or which ZFS pool holds your irreplacable data.

Home Lab Hub transforms this liability into an asset. In under a minute, you can deploy a living map of your entire infrastructure — one that grows with your lab, documents itself through relationship tracking, and exports to portable JSON you'll never lose. The interactive graph visualization alone justifies adoption: seeing your lab as a connected system, not a scattered collection of IP addresses, changes how you think about architecture.

I've evaluated dozens of inventory tools over years of homelab operation. Most were too enterprise-heavy, too fragile, or too disconnected from the homelab reality. Home Lab Hub is the first that feels designed by someone who actually maintains a lab — because RaidOwl does.

Stop losing track of your infrastructure. Start mapping it.

👉 Deploy Home Lab Hub from GitHub now — star the repository, try the Docker deployment, and join the growing community of homelabbers who've chosen clarity over chaos. Your future self — the one debugging at 2 AM — will thank you.

Have you deployed Home Lab Hub? Share your setup in the comments — I'd love to see how you're mapping your infrastructure!