Introduction

Setting up a home lab is an incredible journey that opens up countless learning opportunities in system administration, networking, security, and modern deployment practices. While it might seem daunting at first, the knowledge gained is invaluable for any tech enthusiast or IT professional.

In this post, I'll share a practical overview of how I use my home lab, highlighting the real-world projects I've tackled and the key lessons learned along the way. From self-hosting essential services to experimenting with automation, networking, and security, I'll focus on the hands-on experiences that have shaped my understanding of home server management and modern IT practices.

Why Set Up a Home Lab?

Before diving into the technical aspects, let's explore why you might want to invest time in setting up a home lab:

  1. Hands-on Learning and Career Development: Theory is great, but nothing beats practical experience. A home lab provides a safe environment to experiment and learn from mistakes. The skills you develop are directly applicable to enterprise environments, making you more valuable as an IT professional. I'll dive into this learning topic below;

  2. Control Over Your Data: Self-hosting gives you complete control over your data and privacy, reducing dependency on third-party services.
    Some examples are:

  • Running VaultWarden (a self-hosted Bitwarden alternative) locally, which keeps your password data under your control and reduces exposure to online threats. By self-hosting, you can avoid risks such as polymorphic extension attacks that target cloud-based password managers;
  • Running Adguard Home to provide DNS over HTTPS (DoH), which encrypts your DNS queries and prevents your internet provider from seeing or logging your browsing activity. This enhances privacy and security for all devices on your network.

  1. Cost Efficiency: Although setting up a home lab requires some upfront investment in hardware, it can be significantly more cost-effective over time compared to subscribing to multiple cloud services. By self-hosting solutions like Nextcloud for file storage and synchronization, or Immich for photo management, you gain virtually unlimited storage, constrained only by your own hardware, without recurring subscription fees. This approach allows you to scale your storage as needed, paying only for additional drives or upgrades, and often results in substantial long-term savings;

  2. Customization: A home lab lets you tailor every aspect of your environment to your unique needs—something rarely possible with commercial solutions. For example, Home Assistant is a highly customizable alternative to Google Home or Apple HomeKit. It supports thousands of integrations, allowing you to connect and automate devices exactly as you want. You can create complex automations, dashboards, and routines that fit your lifestyle, rather than being limited by the features or restrictions of proprietary platforms;

  3. Gives You New Ideas and Insights: Experimenting in your own environment exposes you to new technologies, workflows, and problem-solving approaches that you might not encounter otherwise. This often leads to creative solutions and a deeper understanding of IT concepts;

  4. It's Fun: Building and managing your own home lab is genuinely enjoyable. It’s a rewarding hobby that lets you tinker, experiment, and see immediate results from your efforts.

What do you need / How to start?

You can begin your home lab journey by experimenting with a virtual machine on your computer or in the cloud, which is a low-risk way to get started and learn the basics. However, the real benefits come from setting up a dedicated local server. Repurposing an old PC or laptop is a great, cost-effective option—many home lab enthusiasts start this way. For example, I began with a Chromebox: I replaced ChromeOS with Alpine Linux, and it has been running reliably for over six years. As my needs grew, I transitioned to using my old notebook as the primary server. This approach lets you make the most of existing hardware while building hands-on experience with real-world setups.

Some home lab enthusiasts experiment with single-board computers like the Raspberry Pi, Orange Pi, or Banana Pi. Some even build clusters of multiple boards to explore distributed computing or container orchestration at a small scale. While I personally find them less cost-effective compared to repurposing old PCs or laptops—especially given recent price increases and performance limitations—they can be a fun and educational platform if you enjoy tinkering with hardware.

While specialized operating systems like CasaOS or Umbrel OS designed specifically to home servers, I recommend using a standard Linux distribution. This approach offers learning opportunities and greater applicability in professional environments.

What can you learn?

Here are some of the key areas you can explore and learn:

  • Operating Systems: Deepen your understanding of Linux distributions, command-line tools, and system internals;
  • Containers and Orchestration: Get hands-on with Docker, Docker Compose, and Kubernetes to deploy and manage containerized applications;
  • Service Hosting: Self-host applications like wikis, media servers, password managers, and more;
  • Storage and File Systems: Explore RAID, LVM, and network file sharing protocols;
  • Backup and Recovery: Develop backup/recovery strategies;
  • Security: Practice hardening your systems, managing firewalls, setting up VPNs, and implementing authentication mechanisms;
  • Networking: Learn about IP addressing, routing, VLANs, DNS, DHCP, and network security;
  • Monitoring and Logging: Set up monitoring stacks (Prometheus, Grafana), alerts and log aggregation tools to keep your environment healthy;
  • Automation: Use tools like Bash scripts and CI/CD pipelines to automate repetitive tasks and deployments.

Each of these areas offers practical, hands-on experience that builds both foundational and advanced skills, making your home lab an invaluable resource for continuous learning.

Linux

Of course that if we are building a server we are going to use Linux, and this is a rabbit hole by itself: the file system structure, commands, files permissions, systemd and daemons are just some examples.

Setting up a home lab on Linux teaches you:

  • System administration fundamentals;
  • Package management;
  • Service management with systemd;
  • Log analysis and system monitoring;
  • Shell scripting for automation.

Containers

Containers are the go-to way to spin up applications. It's easier, more secure and more maintainable. We can use compose files with Docker Compose and have the benefits of Infrastructure as Code (IaC).

The container journey teaches you:

  • Container lifecycle management (starting, healthy, unhealthy);
  • Volume management and data persistence;
  • Docker Compose for multi-container applications;
  • Container security best practices, such as running containers as non-root users and minimizing container privileges;
  • Image building and optimization;
  • Docker networking concepts (host, bridge, shared networks, etc).

A useful networking strategy in Docker Compose is to create a shared network for all applications, while also assigning each application its own private network for internal communication between its components. For example, a web application and its database can communicate over a dedicated private network, isolating sensitive traffic from other services. At the same time, the web application can be attached to a shared network, allowing it to interact with reverse proxies or other shared infrastructure. This approach improves security and organization by limiting cross-application access and making network policies easier to manage.

networks:
    network_shared:
      external: true
    paperless:
      driver: bridge

  webserver:
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    depends_on:
      - db
    networks:
      - network_shared
      - paperless

  db:
    image: docker.io/library/postgres:15
    networks:
      - paperless

Container orchestration

There are lightweight Kubernetes distributions like K3s and K3d (K3s in Docker) that are ideal for a home server, because they require fewer resources and are easier to set up compared to a full Kubernetes installation.

With container orchestration, you'll learn:

  • Automated deployment and scaling of applications;
  • Load balancing;
  • Rolling updates and rollbacks;
  • Managing persistent storage for containers;
  • Use of Helm charts.

This will give you some hands-on experience with kubernetes and modern DevOps practices.

File Sharing and Storage

Understanding storage solutions is crucial for a home lab. You'll learn about:

  • Different file sharing protocols (SMB/CIFS and NFS) and how to expose and mount those protocols;
  • How to mount file systems at startup and configurations to abort on or ignore errors;
  • Storage pooling with LVM (combining multiple physical drives into a single logical volume);
  • Software RAID for redundancy;
  • File system permissions (and how they differ in SMB and NFS).

Backup Strategies

A solid backup strategy is essential to protect your data from accidental loss, hardware failure, or security incidents. In a home lab, you'll likely experiment with several backup tools and approaches:

  • Borg: Efficient, deduplicating, and encrypted backups. Great for incremental backups and remote storage.
  • Rsync: Flexible file synchronization and backup tool, ideal for local and remote backups with minimal bandwidth usage.
  • Rclone: Syncs files and directories to and from many cloud storage providers, making offsite backups easy. It allows layering virtual encrypted storage on top of any storage provider, ensuring data privacy and security.

Key concepts you'll learn:

  • Backup scheduling and automation;
  • Incremental and differential backups;
  • Encryption and data integrity verification;
  • Retention policies to manage storage usage.

Experimenting with these tools will help you design a backup solution tailored to your needs and ensure your data is always safe.

In my setup, I use Borg to create deduplicated backups of both my servers and personal computer. Once the backups are complete, I leverage Rsync to securely sync these archives to Google Drive (encrypting them at rest) for offsite redundancy. For local photo backups, I rely on Rsync to efficiently mirror and synchronize photo directories between multiple hard drives, ensuring quick recovery and data integrity.

Reverse Proxy and SSL

A crucial component for secure service access:

In my setup, I use NGINX Proxy Manager together with DuckDNS (pointing to my local IP, meaning it is only accessible by my local network or VPN) and Let's Encrypt for automated SSL certificate provisioning. This combination allows me to expose my self-hosted services over HTTPS, routing all access exclusively through NGINX Proxy Manager, which acts as a reverse proxy—ensuring that only authenticated and encrypted traffic reaches my internal services.

Authentication and Security

Security is critical in any server environment, so I'll learn:

  • OpenID and OAuth2;
  • Single Sign-On (SSO) implementation;
  • Network segmentation;
  • Firewall configuration.

I use Authentik to handle OpenID authentication, integrating it with NGINX to secure proxied services.

Networking

Essential networking concepts you'll learn:

  • DNS management and local DNS resolution;
  • Port forwarding (and why not to do it);
  • Network troubleshooting.

In my setup, I use DuckDNS to obtain a free domain name, resolving to a local IP, so it is only accessible in my local network. For local DNS resolution and caching, AdGuard Home acts as my DNS server, providing fast lookups and enhanced privacy for all devices on my network. To securely access my home lab from anywhere without exposing ports or relying on traditional port forwarding, I leverage ZeroTier—a peer-to-peer VPN solution that uses UDP hole punching to create encrypted, direct connections between devices, even behind NAT or firewalls. This combination ensures secure, reliable, and private connectivity to my services, both locally and remotely.

Monitoring and Maintenance

Keeping your services healthy:

  • System monitoring and resource usage with Prometheus/Grafana;
  • Application health-check monitoring;
  • Log aggregation and analysis;
  • Alerts configuration.

For monitoring the health and performance of my home lab, I use a combination of tools:

  • Uptime Kuma provides real-time health checks for all my services, alerting me immediately via Telegram if any become unreachable.
  • Prometheus collects detailed metrics from both containers and the host system, using cAdvisor for container-level insights and Node Exporter for system metrics. These metrics are visualized in Grafana dashboards, giving me a comprehensive view of resource usage and trends.
  • I’ve set up alerting rules in Grafana to notify me via Telegram whenever critical thresholds are breached, ensuring I can respond quickly to issues.
  • For log monitoring, I rely on Dozzle to view container logs in real time. It’s lightweight and simple, which suits my needs since I don’t require long-term log retention.

Automation and Scheduling

Automation is the secret sauce that transforms a home lab from a collection of services into a streamlined, low-maintenance environment. By automating routine tasks, you reduce manual effort, minimize human error, and ensure your services remain reliable and up-to-date.

Some practical automation strategies include:

  • Automated Backups: Schedule regular backups using tools like cron, or backup software with built-in schedulers (Pika Backup, Vorta). This ensures your data is always protected without manual intervention;
  • Scripted Automations: Use shell scripts, or CI/CD pipelines (e.g., GitHub Actions) to deploy and update your applications consistently;
  • Scheduled Maintenance: Automate cache cleanups, and other housekeeping tasks to keep your environment running smoothly.

Conclusion

Setting up a home lab is an ongoing journey of learning and discovery. While it requires time and dedication, the knowledge and skills gained are invaluable. Start small, focus on one area at a time, and gradually expand your infrastructure as you learn.

Remember that mistakes are part of the learning process - having a good backup strategy means you can experiment freely without fear of losing data.

Applications/Tools

Here's a comprehensive list of tools mentioned in this article:

  • AdGuard Home - Network-wide DNS privacy and ad blocking
  • DuckDNS - Free dynamic DNS service
  • Let's Encrypt - Free SSL certificate authority
  • NGINX - Web server and reverse proxy
  • NGINX Proxy Manager - GUI for NGINX proxy management
  • Traefik - Modern reverse proxy and load balancer
  • ZeroTier - P2P VPN for secure remote access
  • K3s - Lightweight Kubernetes distribution
  • K3d - K3s in Docker for local development
  • cAdvisor - Container resource usage metrics
  • Dozzle - Real-time container log viewer
  • Grafana - Metrics visualization and alerting
  • Node Exporter - Hardware and OS metrics
  • Prometheus - Metrics collection and storage
  • Uptime Kuma - Uptime monitoring
  • Borg - Deduplicating backup program
  • Pika Backup - User-friendly Borg backup frontend for GNOME
  • Rclone - Cloud storage sync tool
  • Rsync - Fast file copying and syncing
  • Vorta - Desktop backup client for Borg
  • Home Assistant - Home automation platform
  • Immich - Self-hosted photo backup solution
  • Nextcloud - File hosting and collaboration
  • Vaultwarden - Password management server
  • Authentik - Open-source Identity Provider focused on flexibility and versatility.

References

Related

Integration tests with AWS S3 buckets using Localstack and Testcontainers

Testing AWS integrations with a local AWS emulator

blog.genezini.com

Liked this post?

I post extra content in my personal blog.

Daniel Genezini | It works on my machine

My blog where I share my experiences about .NET, Blazor, AWS, and other tech stuff. Very important note: Everything that I post works on my machine!

blog.genezini.com

Follow me