Your First Homelab: Complete Beginner's Guide

Introduction

You’ve heard the term “homelab” thrown around in tech circles. Maybe you’ve seen impressive setups on r/homelab with blinking server racks and complex network diagrams. Perhaps you’re wondering: Is this for me? Do I need thousands of dollars? Do I need a computer science degree?

Here’s the truth: Anyone can start a homelab, and you don’t need much to begin. A homelab is simply a learning environment where you experiment with technology at home. It can be as simple as a $150 mini PC running a few Docker containers, or as complex as a multi-node server cluster with enterprise networking.

The benefits extend far beyond just “having cool tech”:

Learn valuable skills that transfer directly to IT and DevOps careers
Self-host services and regain control of your data (no more subscription fees!)
Experiment safely without consequences (break things, learn, rebuild)
Build automation that makes your digital life easier
Join a community of passionate learners and tinkerers

In 2025, homelabbing has never been more accessible. Modern hardware is affordable and efficient. Software is containerized and easy to deploy. AI assistants can help you troubleshoot and configure complex systems. The barriers to entry have collapsed.

By the end of this guide, you’ll:

Understand what a homelab is and why people build them
Know exactly what hardware and software you need to start
Have a clear path from “nothing” to “running services”
Understand your first projects and learning goals
Feel confident taking the first steps

Let’s transform curiosity into capability. Your homelab journey starts now.

What is a Homelab?

The Simple Definition

A homelab is a personal learning environment where you experiment with technology, typically involving:

Servers (physical or virtual) running various operating systems
Networking equipment (routers, switches, VLANs)
Storage solutions (NAS, DAS, distributed storage)
Services and applications (self-hosted software, automation, monitoring)

Think of it as a personal IT playground where you can try things without the risk or constraints of a production environment.

Why People Build Homelabs

Reason 1: Learning and Career Development

The #1 reason people build homelabs: hands-on learning beats theory every time.

Reading about Docker is helpful. Deploying 20 containers teaches you Docker.
Watching Kubernetes tutorials is nice. Breaking and fixing a K3s cluster makes you proficient.
Understanding networking concepts is important. Configuring VLANs and routing makes it stick.

Real-world skills learned in homelabs:

Linux administration (CLI, file systems, permissions, services)
Virtualization (Proxmox, VMware, VirtualBox)
Containerization (Docker, Kubernetes)
Networking (TCP/IP, DNS, DHCP, VLANs, VPNs)
Storage (RAID, ZFS, Ceph, NFS, SMB)
Automation (Ansible, Terraform, scripts)
Monitoring (Grafana, Prometheus, logs)

These aren’t just hobbyist skills - they’re in-demand professional skills that pay $70k-150k+ in IT/DevOps roles.

Reason 2: Self-Hosting and Privacy

Take back control from Big Tech:

No more subscriptions: Why pay $10/month for cloud storage when you can self-host Nextcloud?
Data privacy: Your photos, documents, and passwords stay on your hardware
No artificial limits: Cloud services restrict features - you have full control
Learning opportunity: Every service you self-host teaches you something new

Popular self-hosted replacements:

Google Drive → Nextcloud (file sync and collaboration)
Google Photos → Immich (photo management with AI)
LastPass → Vaultwarden (password manager)
Spotify → Navidrome or Plex (music streaming)
Netflix → Jellyfin or Plex (media server)
Gmail → Mailcow or Mail-in-a-Box (email server)

Reason 3: Home Automation and Smart Home

Centralize control of your smart home:

Home Assistant: Control all IoT devices from one interface
Zigbee/Z-Wave hubs: Local control (no cloud dependency)
Custom automation: If sunrise AND motion detected AND workday, then turn on coffee maker
Privacy: Your smart home data stays local

Reason 4: Media Management

Build your personal streaming empire:

Rip your DVD/Blu-ray collection and stream anywhere
Organize 20,000+ music files with proper metadata
Automatically download and organize TV shows
Share with family without complicated setups

Reason 5: It’s Fun!

For many, homelabbing is simply enjoyable:

The satisfaction of solving complex problems
The joy of building something from scratch
The thrill of seeing services come online
The community of fellow enthusiasts

What a Homelab is NOT

Let’s clear up misconceptions:

✗ You don’t need a full server rack

A single mini PC or old laptop works fine to start

✗ You don’t need enterprise equipment

Consumer hardware is often better (quieter, more efficient, cheaper)

✗ You don’t need to spend thousands

$150-300 gets you a capable first setup

✗ You don’t need advanced knowledge

Everyone starts as a beginner; learning is the whole point

✗ It doesn’t need to be production-ready

Homelabs are for experimentation; breaking things is expected and valuable

✗ You don’t need 24/7 uptime

It’s okay to power things off, reboot, wipe and rebuild

Should You Start a Homelab?

You Should Start a Homelab If…

✓ You’re curious about how technology works behind the scenes ✓ You want to learn IT skills for career advancement or personal growth ✓ You’re interested in self-hosting services and reducing reliance on cloud providers ✓ You enjoy problem-solving and figuring out complex systems ✓ You want hands-on experience to complement online courses or certifications ✓ You’re building a smart home and want local control ✓ You have a media collection and want a personal Netflix/Spotify ✓ You want to experiment safely without affecting production systems at work ✓ You find tinkering with tech genuinely enjoyable

You Might Want to Reconsider If…

⚠ You have zero interest in learning tech (it’s just not your thing - and that’s okay!) ⚠ You’re looking for appliance-style simplicity (consider Synology NAS instead) ⚠ You have no time to dedicate to learning and troubleshooting ⚠ You get frustrated easily when things don’t work immediately ⚠ Your primary goal is professional hosting for others (use proper hosting providers)

That said, even if you’re on the fence, starting small (a few hours on a weekend, $150 investment) is low-risk and often hooks people once they see services come to life.

Time and Money Investment

Realistic Expectations:

Time Investment:

Initial setup: 5-10 hours (spread over a weekend or two)
Learning curve: Ongoing - 2-5 hours/week if actively learning
Maintenance: 1-2 hours/month once stable (updates, monitoring)
Optional deep dives: Unlimited - as much as you want to invest

Money Investment:

Bare minimum: $0 (repurpose old laptop/desktop you already have)
Budget start: $150-250 (mini PC + accessories)
Comfortable start: $300-500 (better hardware + networking + storage)
Enthusiast start: $500-1500 (multiple nodes, proper networking, UPS, NAS)

Ongoing Costs:

Electricity: $10-50/year (depending on hardware efficiency and usage)
Storage expansion: $50-200/year (as needed for capacity growth)
Upgrades: $100-300/year (optional - RAM, drives, new devices)

ROI (Return on Investment):

Career value: Skills learned can lead to $20k-40k salary increases in tech
Subscription savings: Self-hosting can save $100-500/year in cloud services
Intangible value: Knowledge, confidence, and community connections

Hardware Options for Your First Homelab

Option 1: Repurpose What You Have (Free!)

Old Laptop:

Pros: Free, has screen/keyboard for troubleshooting, portable, low power
Cons: Limited RAM (usually 8GB max), aging hardware, overheating risk
Good for: Learning Docker basics, lightweight services, temporary experimentation
Not good for: 24/7 operation (heat/wear), heavy workloads, many VMs

Old Desktop:

Pros: Free, usually more RAM (16-32GB), can add drives, better cooling
Cons: Large, power-hungry (50-100W idle), noisy
Good for: Learning VMs, running multiple services, experimentation
Not good for: 24/7 in living space (noise/heat), efficiency

When to repurpose:

You’re not sure if homelabbing is for you (test before investing)
Budget is extremely tight
You have hardware collecting dust
Short-term learning project (a few months)

When to buy new:

You plan to run 24/7 (power costs add up fast on old hardware)
You don’t have spare hardware
You want a quieter, more reliable setup
You’re committed to homelabbing long-term

Option 2: Mini PC ($150-500)

This is the recommended starting point for most people.

Mini PCs offer the best balance of cost, performance, power efficiency, and noise for homelab use.

Budget Tier: Intel N100 ($120-180)

Examples: Beelink S12 Pro, GMKtec NucBox K1
Specs: 4-core Intel N100, 8-16GB RAM, 256-512GB NVMe, 2.5Gbe ethernet
Power: 6-8W idle (costs ~$10-15/year to run 24/7)
Capable of: 10-15 Docker containers, lightweight VMs (2-3), NAS, pfSense, media server (1-2 streams)
Perfect for: First homelab, learning, single-purpose servers

Performance Tier: AMD Ryzen ($280-500)

Examples: Beelink SER5 Max, Minisforum UM690
Specs: 6-8 core Ryzen, 16-32GB RAM, 512GB-1TB NVMe, 2.5Gbe ethernet
Power: 12-20W idle (costs ~$20-35/year to run 24/7)
Capable of: 30+ Docker containers, multiple VMs (5-10), Proxmox clusters, heavy transcoding
Perfect for: Power users, Proxmox virtualization, multi-service homelab

See our “Mini PC Guide 2025” for detailed recommendations!

Option 3: Raspberry Pi ($60-150)

Raspberry Pi 5 (Latest, 2023):

Specs: 4-core ARM CPU, 4GB or 8GB RAM, microSD or NVMe (with HAT)
Power: 3-5W idle (costs ~$5/year to run 24/7)
Pros: Ultra-low power, silent, tiny, great community, tons of tutorials
Cons: ARM architecture (some software incompatibility), limited RAM, slower than x86

Good for:

Learning Linux basics
Pi-hole (ad blocking)
Home Assistant (smart home)
Lightweight Docker containers (5-10 max)
VPN server (WireGuard, Tailscale exit node)

Not good for:

Heavy Docker workloads
Running VMs (too limited)
x86-only software (some apps don’t have ARM versions)
Media transcoding (CPU too weak)

Verdict: Great as a supplementary device (dedicated Pi-hole or Home Assistant), but not recommended as primary homelab server due to limitations.

Option 4: Used Enterprise Server ($100-400)

Examples:

Dell OptiPlex Micro (mini PC form factor)
Dell PowerEdge R720 (rack server)
HP ProLiant DL380 G9 (rack server)

Pros:

Powerful (many cores, tons of RAM)
“Enterprise features” (remote management, redundant power, ECC RAM)
Cheap on eBay (businesses dump old hardware)
Learn enterprise tech (iDRAC, iLO)

Cons:

Loud (rack servers sound like jet engines - 60-80 dB)
Power-hungry (100-300W idle on rack servers = $130-390/year electricity)
Large (rack servers need rack or shelf - 2U = 3.5” tall, full-depth)
Heat (generate significant heat - not for living spaces)
Old technology (often 5-10 years old)

When it makes sense:

You have a basement/garage where noise doesn’t matter
You get one for free or extremely cheap (under $100)
You want to learn enterprise hardware management
Power costs are negligible for you
You’re running a large Proxmox cluster or lab for certifications

When to avoid:

You live in an apartment or small home (noise/heat)
You pay for electricity (5-year cost can exceed hardware value)
You want something you can run 24/7 without annoyance
You’re just starting out (overkill and unnecessary complexity)

Option 5: Build a Custom PC ($400-1000)

When it makes sense:

You need very specific hardware (e.g., many SATA ports for NAS)
You want maximum upgradeability
You already have some parts (case, PSU, drives)
You enjoy building PCs

When it doesn’t:

Mini PCs offer better value for most homelab use cases
Custom builds use more power than mini PCs
Larger footprint (ATX case vs. 4”x4” mini PC)

Example Budget Build ($500):

CPU: Intel i3-12100 ($110)
Motherboard: B660M ($100)
RAM: 32GB DDR4 ($70)
Storage: 500GB NVMe ($40)
Case: Mini-ITX ($50)
PSU: 450W 80+ Bronze ($50)
Total: ~$420

Compare to: Ryzen mini PC for $460 (similar performance, smaller, quieter, more efficient).

Our Recommendation for First Homelab

For 90% of beginners:

Intel N100 Mini PC ($150-180 for 16GB model)

Why:

Affordable (low barrier to entry)
Efficient (won’t cost much to run 24/7)
Powerful enough for learning (Docker, VMs, services)
Silent (can sit on desk without annoyance)
Small (fits anywhere)
Modern connectivity (2.5Gbe ethernet, USB 3.2)

Specific model: Beelink S12 Pro (16GB RAM, 512GB NVMe) - ~$160 on Amazon

This is enough to:

Learn Linux, Docker, and basic networking
Run 10-15 essential services (Pi-hole, Nextcloud, Vaultwarden, Jellyfin, etc.)
Experiment with 2-3 lightweight VMs
Use 24/7 for under $15/year in electricity
Grow your skills for 1-2 years before outgrowing it

For those with bigger budget/ambitions:

AMD Ryzen Mini PC ($300-500)

More power, more capacity, more headroom to grow. See our Mini PC guide for specific recommendations.

Software Stack: What to Run

Operating System Options

Choice 1: Linux (Ubuntu Server) - RECOMMENDED FOR BEGINNERS

Why Ubuntu Server:

Most tutorials assume Ubuntu (easiest to find help)
Stable, well-supported, enterprise-grade
LTS (Long Term Support) releases get 5 years of updates
Huge community, tons of documentation
Docker works flawlessly

Version to install: Ubuntu Server 24.04 LTS (latest LTS as of late 2024)

What you get:

Lightweight (no GUI by default, just command line)
Remote access via SSH
Can install Docker and run containers
Can run VMs with KVM if needed (though Proxmox is better for this)

Alternatives:

Debian 12: More stable, slightly less user-friendly, great choice
Rocky Linux / AlmaLinux: RHEL-based (if learning for enterprise Linux)
Fedora Server: Cutting-edge, less stable, faster updates

Choice 2: Proxmox VE - RECOMMENDED FOR INTERMEDIATE

Why Proxmox:

Full-featured hypervisor (run multiple VMs easily)
Container support (LXC containers, lighter than VMs)
Web GUI (manage everything from browser)
Clustering (can expand to multiple nodes later)
Open-source and free

When to choose Proxmox:

You want to run multiple VMs (e.g., separate VMs for Docker, pfSense, Windows)
You want a “production-like” virtualization environment
You’re comfortable with slightly more complexity
You want room to expand (clustering later)

Typical setup:

Proxmox as base OS
VM 1: Ubuntu Server for Docker containers
VM 2: pfSense for routing/firewall
VM 3: Windows Server (if learning Windows)
LXC containers for lightweight services

Choice 3: TrueNAS SCALE - FOR NAS-FOCUSED LABS

Why TrueNAS SCALE:

Purpose-built for network storage
ZFS filesystem (advanced features, data integrity)
Built-in Docker support (apps via TrueNAS catalog)
Easy sharing (SMB, NFS, iSCSI)
Excellent web interface

When to choose:

Your primary goal is a NAS (network-attached storage)
You have multiple drives to configure in RAID/ZFS
You want maximum data protection features

Not ideal if:

You want general-purpose computing (Docker is secondary in TrueNAS)
You only have 1-2 drives (ZFS benefits need multiple drives)

Containerization: Docker (Essential)

Docker is the most important technology you’ll learn in your homelab.

Why Docker:

Simplicity: Deploy complex apps with a single command
Isolation: Containers don’t interfere with each other
Portability: Compose files work on any Docker host
Efficiency: Run 20+ services on 8GB RAM
Reproducibility: Infrastructure as code (version control your setup)

What you’ll run in Docker:

Web apps (Nextcloud, Vaultwarden)
Media servers (Jellyfin, Plex)
Automation (Home Assistant)
Monitoring (Uptime Kuma, Grafana)
Development tools (GitLab, code-server)
Databases (PostgreSQL, MySQL, Redis)
Networking (Pi-hole, AdGuard Home)
Management (Portainer, Dozzle)

See our “Docker Basics” guide for full tutorial!

Essential First Services

Once you have your OS and Docker installed, what should you deploy first?

Tier 1: Infrastructure & Management (Deploy First)

1. Portainer (Docker Management)

Web UI for Docker (beginner-friendly)
See all containers, images, volumes, networks
Deploy stacks with click of button
Why essential: Makes Docker less intimidating

2. Nginx Proxy Manager (Reverse Proxy)

Access services via domain names (e.g., nextcloud.home.local instead of 192.168.1.50:8080)
Automatic SSL certificates (Let’s Encrypt)
Easy configuration via web UI
Why essential: Professional setup, access services cleanly

3. Pi-hole or AdGuard Home (DNS/Ad Blocking)

Network-wide ad blocking
Custom DNS entries for local services
Insights into network traffic
Why essential: Cleaner internet, learn DNS

4. Uptime Kuma (Monitoring)

Monitor all your services (are they up?)
Alerts if something goes down
Status page you can share
Why essential: Know when things break

Tier 2: Useful Self-Hosted Services (Deploy Next)

5. Vaultwarden (Password Manager)

Self-hosted Bitwarden server
Sync passwords across all devices
Why useful: Regain control of critical passwords

6. Nextcloud (File Sync & Collaboration)

Self-hosted Google Drive alternative
File sync, calendar, contacts, notes
Why useful: Own your data, no storage limits

7. Jellyfin or Plex (Media Server)

Stream your movie/TV collection anywhere
Organize media with nice interface
Why useful: Personal Netflix

8. Home Assistant (Home Automation)

Control all smart home devices
Powerful automation engine
Why useful: Smart home hub

Tier 3: Advanced Services (Deploy When Ready)

9. Immich (Photo Management)

Self-hosted Google Photos alternative
AI-powered facial recognition and search
Why useful: Private photo library

10. Grafana + Prometheus (Monitoring Stack)

Beautiful dashboards
Metrics from all services
Why useful: Professional-grade monitoring

Your First Weekend: Step-by-Step Setup

Saturday Morning: Hardware Setup (1-2 hours)

Step 1: Unbox and Inspect

Remove mini PC from packaging
Verify all included accessories (power adapter, cables)
Check for physical damage

Step 2: Upgrade RAM/Storage (Optional)

If you bought barebones or want to upgrade
Most mini PCs: remove bottom screws, lift panel
Add RAM (match speed to existing if adding second stick)
Add second NVMe drive if slot available

Step 3: Physical Connections

Connect ethernet cable to mini PC and router/switch
Connect HDMI cable to monitor (for initial setup)
Connect USB keyboard
Connect power adapter
Power on

Step 4: BIOS Configuration

Press DEL or F2 during boot to enter BIOS
Enable virtualization (Intel VT-x / AMD-V) if not already enabled
Set boot order (USB first for OS installation)
Optionally: Disable WiFi/Bluetooth if not using (save power)
Save and exit

Saturday Afternoon: OS Installation (2-3 hours)

Step 1: Download OS

For Ubuntu Server:

Go to https://ubuntu.com/download/server
Download Ubuntu Server 24.04 LTS (latest LTS)
File: ubuntu-24.04-live-server-amd64.iso (~2GB)

For Proxmox:

Go to https://www.proxmox.com/en/downloads
Download Proxmox VE ISO Installer
File: proxmox-ve_X.X-X.iso (~1GB)

Step 2: Create Bootable USB

On Windows:

Download Rufus (https://rufus.ie/)
Insert USB drive (8GB+, will be erased!)
Select ISO file
Click “Start”

On Mac/Linux:

Use balenaEtcher (https://www.balena.io/etcher/)
Select ISO, select USB drive, flash

Step 3: Boot from USB

Insert USB into mini PC
Restart, press F11/F12 for boot menu (or it should auto-boot from USB)
Select USB drive

Step 4: Install Ubuntu Server

Follow on-screen prompts:

Language: English
Keyboard: Your layout
Network: Should auto-configure via DHCP (note the IP address shown!)
Proxy: Leave blank (unless you need one)
Mirror: Default is fine
Storage: “Use entire disk” (default)
Confirm disk selection (data will be erased!)
Profile setup:
- Your name: yourname
- Server name: homelab (or whatever you want)
- Username: yourname
- Password: Choose a strong password (you’ll type this a lot!)
SSH Setup: Enable OpenSSH server (important!)
Featured Server Snaps: Don’t select any (we’ll install Docker manually)
Installation begins (5-10 minutes)
Reboot when prompted

Step 5: First Login

Remove USB drive
System reboots
Login with username/password you created
You’re now at a command prompt!

Step 6: Update System

# Update package lists
sudo apt update

# Upgrade installed packages
sudo apt upgrade -y

# Reboot (if kernel was updated)
sudo reboot

Step 7: Note Your IP Address

# Find your IP address
ip addr show

# Look for something like:
# inet 192.168.1.100/24
# This is your server's IP address

Step 8: SSH from Your Main Computer

Now you can disconnect the monitor/keyboard and access your server remotely!

On Windows:

Use PuTTY or Windows Terminal
ssh [email protected] (replace with your IP)

On Mac/Linux:

Open Terminal
ssh [email protected] (replace with your IP)

Enter your password when prompted. You’re now remotely controlling your homelab server!

Saturday Evening: Docker Setup (2 hours)

Step 1: Install Docker

# Download Docker installation script
curl -fsSL https://get.docker.com -o get-docker.sh

# Run installation script
sudo sh get-docker.sh

# Add your user to docker group (so you don't need sudo)
sudo usermod -aG docker $USER

# Activate group changes
newgrp docker

# Test Docker
docker run hello-world

# Should see "Hello from Docker!" message

Step 2: Install Docker Compose

Modern Docker includes Compose as a plugin (already installed), verify:

docker compose version
# Should show: Docker Compose version v2.x.x

Step 3: Create Directory Structure

# Create main Docker directory
sudo mkdir -p /opt/docker

# Create subdirectories
sudo mkdir -p /opt/docker/{apps,backups,data,configs}

# Give your user ownership
sudo chown -R $USER:$USER /opt/docker

# Navigate to Docker workspace
cd /opt/docker

Step 4: Deploy Portainer (Your First Container!)

# Create Portainer volume
docker volume create portainer_data

# Run Portainer
docker run -d   --name=portainer   --restart=always   -p 9443:9443   -v /var/run/docker.sock:/var/run/docker.sock   -v portainer_data:/data   portainer/portainer-ce:latest

# Check if running
docker ps

Step 5: Access Portainer

Open browser on your main computer
Go to: https://192.168.1.100:9443 (replace with your server IP)
Accept security warning (self-signed certificate)
Create admin account
- Username: admin
- Password: Choose a strong password
Select “Docker” environment
Click “Connect”

Congratulations! You now have a web interface for managing Docker!

Sunday Morning: Deploy Essential Services (3-4 hours)

Deploy Nginx Proxy Manager

Create /opt/docker/apps/nginx-proxy-manager/docker-compose.yml:

version: '3.8'

services:
  nginx-proxy-manager:
    image: jc21/nginx-proxy-manager:latest
    container_name: nginx-proxy-manager
    restart: unless-stopped
    ports:
      - "80:80"      # HTTP
      - "443:443"    # HTTPS
      - "81:81"      # Admin interface
    volumes:
      - npm_data:/data
      - npm_letsencrypt:/etc/letsencrypt
    networks:
      - proxy-network

volumes:
  npm_data:
  npm_letsencrypt:

networks:
  proxy-network:
    driver: bridge

Deploy:

cd /opt/docker/apps/nginx-proxy-manager
docker compose up -d

Access at http://192.168.1.100:81:

Default login: [email protected] / changeme
Change password immediately!

Deploy Pi-hole

Create /opt/docker/apps/pihole/docker-compose.yml:

version: '3.8'

services:
  pihole:
    container_name: pihole
    image: pihole/pihole:latest
    restart: unless-stopped
    ports:
      - "53:53/tcp"
      - "53:53/udp"
      - "8053:80/tcp"  # Web interface on port 8053
    environment:
      TZ: 'America/New_York'  # Change to your timezone
      WEBPASSWORD: 'your_secure_password_here'  # Change this!
    volumes:
      - pihole_data:/etc/pihole
      - pihole_dnsmasq:/etc/dnsmasq.d
    networks:
      - pihole-network

volumes:
  pihole_data:
  pihole_dnsmasq:

networks:
  pihole-network:
    driver: bridge

Deploy:

cd /opt/docker/apps/pihole
docker compose up -d

Access at http://192.168.1.100:8053/admin

Deploy Vaultwarden (Password Manager)

Create /opt/docker/apps/vaultwarden/docker-compose.yml:

version: '3.8'

services:
  vaultwarden:
    image: vaultwarden/server:latest
    container_name: vaultwarden
    restart: unless-stopped
    ports:
      - "8054:80"
    volumes:
      - vaultwarden_data:/data
    environment:
      WEBSOCKET_ENABLED: 'true'
      SIGNUPS_ALLOWED: 'true'  # Disable after creating your account
    networks:
      - vaultwarden-network

volumes:
  vaultwarden_data:

networks:
  vaultwarden-network:
    driver: bridge

Deploy:

cd /opt/docker/apps/vaultwarden
docker compose up -d

Access at http://192.168.1.100:8054

Create your account, then edit compose file to set SIGNUPS_ALLOWED: 'false' and redeploy.

Deploy Uptime Kuma (Monitoring)

mkdir -p /opt/docker/apps/uptime-kuma
cd /opt/docker/apps/uptime-kuma

docker run -d   --name=uptime-kuma   --restart=always   -p 3001:3001   -v uptime-kuma:/app/data   louislam/uptime-kuma:1

Access at http://192.168.1.100:3001

Sunday Afternoon: Configuration & Testing (2 hours)

Configure DNS (Point Devices to Pi-hole)

Option 1: Router-wide (affects all devices):

Log into your router admin panel
Find DHCP settings
Change DNS server to your server IP (e.g., 192.168.1.100)
Save and reboot router

Option 2: Per-device (for testing):

On Windows: Network Settings → Adapter Settings → Properties → IPv4 → DNS
On Mac: System Preferences → Network → Advanced → DNS
On iOS/Android: WiFi settings → Configure DNS → Manual
Set DNS to 192.168.1.100

Add Local DNS Entries in Pi-hole

Go to Pi-hole admin: Local DNS → DNS Records
Add entries for your services:
- portainer.home.local → 192.168.1.100
- pihole.home.local → 192.168.1.100
- vault.home.local → 192.168.1.100

Now you can access services via names instead of IP:port!

Configure Nginx Proxy Manager (Proxy Hosts)

Go to Nginx Proxy Manager → Hosts → Proxy Hosts → Add Proxy Host
For Portainer:
- Domain Names: portainer.home.local
- Scheme: https
- Forward Hostname/IP: 192.168.1.100
- Forward Port: 9443
- Enable: Websockets Support, Block Common Exploits
- Save

Repeat for other services.

Now access Portainer at: http://portainer.home.local (proxy handles HTTPS internally)

Set Up Monitoring in Uptime Kuma

Add monitors for each service:
- Portainer: https://192.168.1.100:9443
- Pi-hole: http://192.168.1.100:8053
- Nginx Proxy Manager: http://192.168.1.100:81

Get alerts if any service goes down!

Learning Path: Your First 90 Days

Week 1-2: Foundations

Goals:

Get comfortable with Linux command line
Understand Docker basics
Deploy 3-5 essential services

Daily Tasks (1 hour/day):

Day 1-3: Linux basics tutorial (files, directories, permissions)
Day 4-7: Docker tutorial (images, containers, volumes, networks)
Day 8-10: Deploy services (Portainer, Pi-hole, Nginx Proxy Manager)
Day 11-14: Configure and test services

Resources:

Linux Journey (linuxjourney.com) - interactive Linux tutorial
Docker official docs - getting started guide
homelabbing.io Docker Basics guide

Milestone: You can SSH into your server, run Docker commands confidently, and have 5 services running.

Week 3-4: Expand Services

Goals:

Add user-facing services
Learn Docker Compose
Implement backups

Projects:

Deploy Nextcloud (file sync)
Deploy Jellyfin or Plex (media server)
Deploy Vaultwarden and migrate passwords
Set up automated backups (cron + scripts)

Learning Focus:

Docker Compose syntax and best practices
Volume management and persistence
Basic bash scripting for automation

Milestone: You’re self-hosting services you use daily, and you have a backup strategy.

Month 2: Deeper Knowledge

Goals:

Understand networking better
Learn basic security hardening
Experiment with VMs (if using Proxmox)

Projects:

Set up VLANs (if you have managed switch)
Configure VPN (WireGuard or Tailscale for remote access)
Deploy Home Assistant (if interested in smart home)
Set up Grafana + Prometheus for monitoring

Learning Focus:

TCP/IP, DNS, DHCP, VLANs
Firewall rules and security best practices
Virtualization concepts (if using Proxmox)

Milestone: You understand how your homelab network works and can access services remotely and securely.

Month 3: Advanced Topics

Goals:

Explore advanced services
Learn infrastructure as code
Consider career-relevant technologies

Projects:

Deploy Kubernetes (K3s) cluster
Try Ansible for configuration management
Set up CI/CD pipeline (GitLab or Jenkins)
Contribute to open-source homelab projects

Learning Focus:

Container orchestration (Kubernetes)
Infrastructure as code (Terraform, Ansible)
DevOps practices and workflows

Milestone: You have skills transferable to professional IT/DevOps roles.

Common Beginner Questions

“Do I need a static IP address?”

For your homelab server: Yes, but from your router (local static IP), not your ISP.

How to set static IP:

Option 1 (Recommended): DHCP Reservation in router
- Log into router admin
- Find DHCP settings or “Address Reservation”
- Assign your server’s MAC address a specific IP (e.g., 192.168.1.100)
- Reboot server to get new reservation
Option 2: Static IP on server itself
- Edit netplan config on Ubuntu
- More complex, less flexible

For external access:

Your home public IP (from ISP) changes periodically (unless you pay for static)
Solution: Dynamic DNS (DuckDNS, No-IP, Cloudflare DDNS)
Your homelab updates a DNS record whenever your public IP changes

“How do I access my homelab remotely (from outside home)?”

Option 1: VPN (Recommended for Security)

Set up WireGuard or Tailscale:

Tailscale is easiest (5 minutes to set up, free for personal use)
Creates encrypted “virtual LAN” over internet
Access homelab services as if you’re home
No port forwarding needed (works behind NAT)

Option 2: Reverse Proxy + Domain + SSL

Buy a domain name ($10/year)
Point domain to your home IP (using Dynamic DNS)
Forward ports 80/443 on router to Nginx Proxy Manager
Configure Nginx Proxy Manager to proxy to internal services
Use Cloudflare Tunnel (more secure, no port forwarding)

Security Warning: Exposing services to internet has risks. Use strong passwords, 2FA, keep everything updated, and understand what you’re doing.

“What domain should I use for local services?”

For internal-only (not exposed to internet):

.local (e.g., nextcloud.home.local, jellyfin.home.local)
.lan (e.g., services.homelab.lan)
.internal

Configure these in Pi-hole Local DNS.

For external access:

Buy a real domain: yourdomain.com
Use subdomains: cloud.yourdomain.com, media.yourdomain.com

“How much storage do I need?”

For OS and Docker: 256GB NVMe is fine, 512GB is comfortable.

For data (media, files, backups):

Start small: 1-2TB external drive
Grow as needed: Add drives when you run out of space
Media hoarders: 10-40TB (4x 4TB or 8TB drives in RAID)

Recommendation: Start with what you have, expand when needed. Storage is easy to add later.

“Should I learn Linux first, or jump straight into homelab?”

Jump straight in. You’ll learn Linux by doing.

Start with Ubuntu Server (most beginner-friendly)
Use tutorials specific to what you’re trying to accomplish
Google error messages when stuck
Read man pages (man command shows documentation)

Every command you run, every error you troubleshoot, teaches you Linux.

“What if I break something?”

Breaking things is how you learn! This is your homelab, not production infrastructure.

Best practices to minimize risk:

Snapshot VMs before major changes (if using Proxmox)
Keep compose files in Git (easy to redeploy)
Document what you did (so you can undo it)
Backup important data (3-2-1 rule: 3 copies, 2 different media, 1 offsite)

When you break something:

Don’t panic
Check logs: docker logs container_name
Google the error message
Ask for help: r/homelab, r/selfhosted, Discord servers
Worst case: Wipe and reinstall (you’ll be faster the second time!)

“How do I know what services to run?”

Start with pain points in your digital life:

Annoyed by ads? → Pi-hole
Worried about password security? → Vaultwarden
Paying for cloud storage? → Nextcloud
Want to organize photos? → Immich
Have a media collection? → Jellyfin/Plex
Building smart home? → Home Assistant

Then explore for learning:

Browse Awesome-Selfhosted (github.com/awesome-selfhosted/awesome-selfhosted)
Check r/selfhosted sidebar
Deploy things that sound interesting
Remove what you don’t use

Community and Resources

Online Communities

Reddit:

r/homelab (382k members) - General homelab discussion, hardware, show-offs
r/selfhosted (423k members) - Self-hosting specific, software focus
r/docker (120k members) - Docker help and discussion
r/proxmox (45k members) - Proxmox-specific
r/HomeNetworking (520k members) - Networking help

Discord Servers:

Self-Hosted Discord - Large community, active help channels
Homelab Discord - Hardware focus
Docker Community Discord

Forums:

ServeTheHome Forums - In-depth hardware reviews and discussion
Proxmox Forum - Official Proxmox support
TrueNAS Community Forum

Learning Resources

Websites:

homelabbing.io - You’re here! AI-assisted guides
Linux Journey (linuxjourney.com) - Interactive Linux learning
Docker Docs (docs.docker.com) - Official Docker documentation
DigitalOcean Tutorials - Excellent how-to guides

YouTube Channels:

TechnoTim - Homelab tutorials, Docker, Kubernetes
NetworkChuck - Beginner-friendly networking and Linux
Craft Computing - Hardware reviews, homelab builds
Jeff Geerling - Raspberry Pi, Ansible, infrastructure

Courses (Optional):

Linux Academy / A Cloud Guru - Structured Linux learning
Udemy - Docker and Kubernetes courses (wait for sales, $10-15)

Documentation Culture

Document your homelab!

Why:

Future you will forget why you did something
Troubleshooting is easier with notes
Others can learn from your experience
It’s satisfying to see your progress

What to document:

Hardware specs and purchase dates
IP address assignments (which device has which IP)
Service configurations (which ports, which domains)
Docker compose files (keep in Git repository!)
Troubleshooting notes (what failed, how you fixed it)

Tools:

Obsidian or Notion - Personal knowledge base
Git repository - For config files and compose files
Network diagram - Draw.io or Lucidchart (visualize your setup)

Example simple documentation:

# Homelab Setup

## Hardware
- Beelink S12 Pro (N100, 16GB RAM, 512GB NVMe)
- IP: 192.168.1.100 (DHCP reservation)
- Power: 8W idle, $12/year

## Services
- Portainer: https://portainer.home.local (port 9443)
- Pi-hole: http://pihole.home.local (port 8053)
- Vaultwarden: https://vault.home.local (port 8054)

## Backups
- Weekly backup script runs Sundays at 2 AM
- Backs up to external USB drive (4TB)
- Retention: 4 weeks

## Notes
- 2024-12-16: Initial setup, deployed first services
- 2024-12-18: Added Nextcloud, migrated files from Google Drive

Your Homelab Roadmap

Phase 1: Foundation (Weeks 1-4)

Mindset: Learning, experimenting, understanding basics

Hardware:

Single mini PC or repurposed computer
Basic networking (home router)
Small external drive for backups

Software:

Ubuntu Server or Proxmox
Docker with 5-10 containers
Essential services (Portainer, Pi-hole, proxy, monitoring)

Skills Gained:

Linux command line confidence
Docker basics (images, containers, volumes, networks)
Basic networking (IP addresses, DNS, ports)
SSH remote access

Outcome: Working homelab running useful services you access daily.

Phase 2: Expansion (Months 2-3)

Mindset: Adding capabilities, deeper learning, self-hosting more

Hardware:

Same hardware (no need to upgrade yet)
Optional: Better network switch (managed, 2.5Gbe)
Optional: UPS for power protection

Software:

15-20 Docker containers
More advanced services (media, automation, development tools)
VPN for remote access (Tailscale or WireGuard)
Monitoring stack (Grafana, Prometheus)

Skills Gained:

Docker Compose mastery
VLANs and network segmentation (if applicable)
VPN setup and remote access
Backup and restore procedures
Basic security hardening

Outcome: Comprehensive self-hosted environment, remote access working, backups automated.

Phase 3: Advanced (Months 4-6)

Mindset: Exploring enterprise technologies, career skills, clustering

Hardware:

Consider second node for clustering/HA
10Gbe networking (if doing clusters)
Proper rack or shelf (if expanding)

Software:

Kubernetes (K3s) cluster
Infrastructure as code (Ansible, Terraform)
CI/CD pipelines (GitLab, Jenkins)
Advanced monitoring and logging (ELK stack)

Skills Gained:

Container orchestration (Kubernetes)
Automation and IaC (Ansible playbooks)
High availability concepts
DevOps workflows
Advanced networking

Outcome: Enterprise-like homelab, skills directly applicable to DevOps/SRE careers.

Phase 4: Mastery (6+ months)

Mindset: Teaching others, contributing to community, specialization

Activities:

Write tutorials or blog posts about your learnings
Contribute to open-source homelab projects
Help others in r/homelab and Discord
Specialize in areas of interest (networking, storage, orchestration, security)
Build impressive demos for portfolio/resume

Career Impact:

Resume: List homelab projects and technologies learned
Interviews: Speak confidently about hands-on experience
Job roles: DevOps Engineer, SRE, Cloud Architect, Systems Administrator
Salary impact: $20k-50k+ higher with demonstrable skills

Conclusion

Your homelab journey is unique to you. There’s no “right way” to do it - the best homelab is the one that matches your interests, budget, and learning goals.

Key Takeaways:

Start small: A single mini PC and a few Docker containers is enough to learn tremendously
Focus on learning: Breaking things and fixing them teaches more than perfect setups
Document everything: Future you will thank present you
Join the community: r/homelab, r/selfhosted, Discord servers - people love helping beginners
Be patient: Skills compound over time - you’ll be amazed at your progress in 6 months
Have fun: If it’s not enjoyable, adjust your approach or take a break

Your First Steps:

This week: Decide on hardware (buy mini PC or repurpose existing)
Next weekend: Follow the “First Weekend Setup” section of this guide
Week 2: Deploy 3-5 essential services (Portainer, Pi-hole, Vaultwarden)
Month 1: Add user-facing services you’ll actually use (Nextcloud, Jellyfin)
Month 2: Explore areas of interest (networking, automation, monitoring)

The Mindset That Matters:

Every expert was once a beginner who didn’t give up
Failure is data (learn from errors, iterate, improve)
Small progress daily beats occasional heroic efforts
Your homelab reflects your curiosity - let it evolve naturally

Welcome to the homelab community. You’re about to embark on one of the most rewarding learning journeys in technology. The skills you gain, the services you build, and the confidence you develop will stay with you for life.

The hardest step is the first one. You’ve finished reading this guide - now go take that step.

Your homelab awaits. Let’s build something amazing.

Quick Start Checklist

Hardware Checklist

Mini PC or repurposed computer chosen
Ethernet cable
Monitor and keyboard (for initial setup)
Optional: USB drive (8GB+) for OS installation
Optional: UPS for power protection
Optional: External drive for backups

Software Checklist

Ubuntu Server 24.04 LTS downloaded (or Proxmox)
Bootable USB created (Rufus or balenaEtcher)
SSH client ready (PuTTY on Windows, Terminal on Mac/Linux)

Initial Setup Checklist

OS installed
System updated (sudo apt update && sudo apt upgrade)
Static IP configured (DHCP reservation in router)
SSH access working
Docker installed
Docker Compose verified

First Services Checklist

Portainer deployed (container management)
Nginx Proxy Manager deployed (reverse proxy)
Pi-hole deployed (ad blocking / DNS)
Vaultwarden deployed (password manager)
Uptime Kuma deployed (monitoring)

Configuration Checklist

Local DNS entries configured in Pi-hole
Proxy hosts configured in Nginx Proxy Manager
Services monitored in Uptime Kuma
Devices pointed to Pi-hole for DNS
Backup strategy implemented

Learning Checklist

Comfortable with basic Linux commands
Understand Docker concepts (images, containers, volumes, networks)
Can deploy containers using Docker Compose
Know how to check logs and troubleshoot issues
Joined homelab communities (Reddit, Discord)

Additional Resources

“Docker Basics for Homelabs” - Deep dive into containerization
“Best Mini PCs for Homelabs 2025” - Hardware buying guide
“Nginx Proxy Manager Complete Setup” - Reverse proxy tutorial
“Proxmox for Beginners” - Virtualization platform guide

Recommended First Services

Explore these after your initial setup:

Nextcloud (file sync)
Jellyfin/Plex (media server)
Immich (photo management)
Home Assistant (smart home)
Grafana + Prometheus (monitoring)
Uptime Kuma (status monitoring)
Dashy or Homepage (dashboard)

Essential Reading

Awesome Self-Hosted (GitHub) - Massive list of self-hosted software
Docker Compose Examples (GitHub) - Ready-to-use compose files
r/homelab Wiki - Community knowledge base

Last updated: December 16, 2025 Author: homelabbing.io Difficulty: Beginner Time to complete: 60 minutes

Ready to start your homelab journey? You’ve got this!

Introduction

What is a Homelab?

The Simple Definition

Why People Build Homelabs

What a Homelab is NOT

Should You Start a Homelab?

You Should Start a Homelab If…

You Might Want to Reconsider If…

Time and Money Investment

Hardware Options for Your First Homelab

Option 1: Repurpose What You Have (Free!)

Option 2: Mini PC ($150-500)

Option 3: Raspberry Pi ($60-150)

Option 4: Used Enterprise Server ($100-400)

Option 5: Build a Custom PC ($400-1000)

Our Recommendation for First Homelab

Software Stack: What to Run

Operating System Options

Containerization: Docker (Essential)

Essential First Services

Your First Weekend: Step-by-Step Setup

Saturday Morning: Hardware Setup (1-2 hours)

Saturday Afternoon: OS Installation (2-3 hours)

Saturday Evening: Docker Setup (2 hours)

Sunday Morning: Deploy Essential Services (3-4 hours)

Sunday Afternoon: Configuration & Testing (2 hours)

Learning Path: Your First 90 Days

Week 1-2: Foundations

Week 3-4: Expand Services

Month 2: Deeper Knowledge

Month 3: Advanced Topics

Common Beginner Questions

“Do I need a static IP address?”

“How do I access my homelab remotely (from outside home)?”

“What domain should I use for local services?”

“How much storage do I need?”

“Should I learn Linux first, or jump straight into homelab?”

“What if I break something?”

“How do I know what services to run?”

Community and Resources

Online Communities

Learning Resources

Documentation Culture

Your Homelab Roadmap

Phase 1: Foundation (Weeks 1-4)

Phase 2: Expansion (Months 2-3)

Phase 3: Advanced (Months 4-6)

Phase 4: Mastery (6+ months)

Conclusion

Quick Start Checklist

Hardware Checklist

Software Checklist

Initial Setup Checklist

First Services Checklist

Configuration Checklist

Learning Checklist

Additional Resources

Related Guides on homelabbing.io

Recommended First Services

Essential Reading