Building Linux Servers & Real Homelabs

Stop throwing away perfectly good hardware. That old desktop collecting dust? It's not outdated, it's just infrastructure waiting to happen.

In this guide I'm also going to go over all the tasty flavors of Linux you can use as well.

Introduction: Why Your "Old" Computer Is Actually Fine

Most people see an older desktop or laptop and think it's past its prime. I see something different: real infrastructure.

Not a toy. Not a learning sandbox. Actual, production-capable servers.

The model I use to run MAL+ and its connected services is built around multiple, decently strong machines working together as a small private network. My network does run on newer hardware, with some machines being more powerful than others - some handle specific jobs, and everything communicates together. But here's the crucial part that changes everything:

You can do the exact same thing with older hardware.

This isn't about compromise.

Linux was built to run on everything from supercomputers to phones, routers, servers, embedded systems, and old PCs - using the same kernel, the same networking stack, and the same filesystem layer. Modern infrastructure is designed to abstract away hardware almost completely. Once Linux is running, nearly everything above it treats hardware as just "resources": CPU cycles, memory, disk space, and network.

In this comprehensive guide, I'll show you how to transform aging computers into a Linux homelab that operates exactly like real production infrastructure. You'll learn about choosing and installing the right Linux distribution, understanding containerization with Docker, setting up media servers, exploring the Fediverse, and even getting creative with non-standard hardware enclosures.

This guide is designed for those with limited to no Linux experience - Windows users who are curious about taking control of their own infrastructure. By the end, you'll have the knowledge to build your own private cloud, media server, development environment, and more.

Table of Contents

1. Understanding Why This Works
2. Choosing Your Linux Distribution
3. Installing Linux: Step-by-Step
4. Understanding Docker and Containers
5. Setting Up Your First Services
6. Media Servers: Your Personal Netflix
7. The Fediverse and Decentralized Networks
8. Creative Hardware Enclosures
9. Next Steps and Advanced Topics
10. Resources and Citations

Understanding Why This Works: The Hardware Abstraction Principle

Linux Doesn't Care What It's Running On

On the surface, it sounds ridiculous. How could a dusty old desktop possibly behave the same as a data center server?

The answer is elegant: Modern infrastructure is designed to abstract away hardware almost completely. Once Linux is running, nearly everything above it treats hardware as just "resources" - CPU cycles, memory, disk space, and network.

When Debian boots on a used desktop and when it boots on a $20,000 rack server, it exposes the same interfaces:

• Process scheduling
• Memory management
• Disk I/O
• Networking
• Permissions

Every service above the kernel sees the same environment. From a software perspective: A core is a core. RAM is RAM. Storage is storage.

Performance scales, but behavior does not change. That's the foundation that makes everything else possible.

Docker Makes Hardware Even More Irrelevant

Docker containers don't talk to hardware directly - they talk to the Linux kernel. This means:

A Jellyfin container on an old Dell desktop is the same Jellyfin container on a cloud VM, which is the same Jellyfin container on an enterprise server.

• Same filesystem layout
• Same networking
• Same configuration
• Same behavior

Only throughput changes.

And here's the secret: most homelab workloads barely touch modern CPU limits. A basic media stack using Jellyfin, a torrent client, and metadata services typically uses only 5-15% CPU, a couple gigabytes of RAM, and some disk I/O while downloading. An old quad-core system handles this easily.

The Real Difference Is Throughput, Not Capability

The honest truth: The difference between old hardware and enterprise servers is not capability - it's scale.

Enterprise servers can handle thousands of simultaneous users, massive databases, and heavy compute loads. Older PCs are perfect for:

• Personal infrastructure
• Small communities
• Development environments
• Media libraries
• Learning and experimentation
• Self-hosting

But the architecture is identical. Same Linux. Same Docker. Same services.

Think of it like roads: A small town road and a ten-lane highway both follow the same traffic laws. Cars drive the same way. Lights work the same way. The only difference is how many cars can pass at once.

Your homelab is just a tiny data center.

Choosing Your Linux Distribution

Distributions like Ubuntu or Debian are often recommended starting points because of their large community support. But which one is right for you?

For Bare-Metal Servers: Debian

Personally, I prefer Debian for bare-metal server installations. Here's why:

• Extremely stable - Debian is very stable and doesn't change between releases, resulting in a nice level of stability with fewer faults
• Minimal by default - No bloatware, just what you need
• Long support cycles - Current Ubuntu LTS 24.04 release receives updates until 2029, and Debian offers similarly long support
• Very lightweight - Perfect for machines that should run for months or years
• Perfect for servers - Debian is boring in the best possible way. It just works.

When to choose Debian:

• You want maximum stability
• You're setting up a server that will run 24/7
• You prefer minimal systems you build up yourself
• You have some Linux experience or are ready to learn

For Beginners: Ubuntu Server

Ubuntu Server is generally considered the most beginner-friendly server distribution. Benefits include:

• Huge community - Almost any issue you encounter has already been solved somewhere online
• Compatibility - Most software vendors test against Ubuntu, so instructions are usually available
• Easy setup - More hand-holding during installation
• Resource-light - Start minimal and add only what you need
• Based on Debian - You get Debian's stability with more user-friendly tooling

When to choose Ubuntu Server:

• You're new to Linux
• You want extensive documentation and tutorials
• You prefer a gentler learning curve
• You need maximum compatibility with third-party software

Understanding the Relationship: Debian, Ubuntu, and Containers

Here's an important concept: While I use Debian on the actual physical machines, I often use Ubuntu or Alpine Linux inside Docker containers.

This is like having an apartment building (your Debian server) with individual apartments (containers) that can have their own interior design (Ubuntu, Alpine, etc.). The building's infrastructure stays stable, but each apartment can be customized for its specific purpose.

We'll explore this more in the Docker section.

Other Distributions Worth Mentioning

For those seeking something more cutting-edge, Arch Linux uses a rolling release model while providing the latest version of all applications without needing to reinstall. However, Arch requires significantly more expertise and isn't recommended for beginners.

For virtualization-specific needs, Proxmox VE is worth exploring once you're comfortable with Linux basics.

Installing Linux: Complete Step-by-Step Guide

What You'll Need

Before we begin, gather these essentials:

Hardware Requirements:

• An old PC or laptop (Pentium 4 or newer recommended)
• At least 512MB RAM (1GB+ recommended for desktop environments)
• 10GB hard drive space minimum (20GB+ recommended)
• Internet connection (optional but helpful)

Software You'll Download:

• Linux distribution ISO file (we'll cover this)
• USB flash drive creation tool (Rufus for Windows, Etcher for Mac/Linux)
• A USB flash drive (4GB or larger)

Step 1: Download Your Linux Distribution

For Debian:

1. Open your web browser and navigate to debian.org
2. Click the large "Download" button on the homepage
3. For most modern desktops/laptops, you want the "amd64" netinst image (around 800MB)
4. The netinst (network install) image is smaller and grabs the latest software from the internet during installation

Alternative: Download the larger complete installation image if you're installing on a machine without internet access.

For Ubuntu Server:

1. Visit ubuntu.com/download/server
2. Download the latest LTS (Long Term Support) version
3. The file will be around 2-3GB

Step 2: Create a Bootable USB Drive

Step 3: Boot From USB

This is where beginners often get stuck. Don't worry - it's simpler than it seems.

1. Insert the USB drive into your target computer
2. Restart the computer
3. During startup, press the appropriate key to enter BIOS/UEFI settings (common keys are Del, F2, F12, Esc)
   • The key is usually shown on screen briefly during boot
   • Common keys by manufacturer:
     • Dell: F12
     • HP: Esc or F9
     • Lenovo: F12 or F1
     • ASUS: F2 or Del
4. Navigate to Boot Order/Boot Menu
5. Move USB device to first priority
6. Save and exit (usually F10)

Step 4: Installing Debian (Detailed Walkthrough)

The installer will load. Here's what to expect:

Initial Setup Screens

1. Select a language - Choose your preferred language
2. Select your location - This sets your timezone
3. Configure keyboard - Usually auto-detected correctly
4. Configure network - If connected via Ethernet, this happens automatically
   • If using WiFi, you'll be prompted to select your network and enter the password

Important: Creating User Accounts

Root Password settings are the most important. Remember this password, as you will likely use commands as administrator in Debian, typing "sudo" before commands in the terminal and confirming with the root password.

1. Set root password - This is your admin/superuser password

   • Make it strong - Mix letters, numbers, symbols
   • Write it down somewhere safe
   • You'll need this for system administration

2. Create a regular user account

   • Full name: Can be anything
   • Username: lowercase, no spaces (example: john or jsmith)
   • Password: Can be different from root password

Pro tip: Use the regular user account for daily tasks. Only use root for system changes.

Partitioning Your Hard Drive

This is the scary part for beginners. Let's demystify it:

The installer gives you a few choices for partitioning your disk. If you plan to install Debian on the entire drive, the "Guided – use entire disk" option is perfectly safe and easy.

Choose: "Guided - use entire disk"

Then select your hard drive:

• /dev/sda - Traditional hard drives
• /dev/nvme0n1 - Modern NVMe SSDs
• Double-check you're not selecting your USB stick!

Partitioning scheme:

Choose "Separate /home partition" (strong recommendation). Your personal files live in /home. If you ever need to reinstall Debian or try a different distro, having /home on its own partition means your files stay safe.

Review and confirm:

• Check the summary
• Select "Finish partitioning and write changes to disk"
• Confirm "Yes" to write changes

** WARNING:** This will erase everything on the selected drive. Make sure you've backed up important data!

Package Selection

Near the end of installation, you'll see "Software selection":

If you wish to use Debian as a lightweight server in CLI and TTY mode, you can unselect the Debian Desktop environment. But if you want to use Debian with a Graphical User Interface, then you must select the Debian Desktop environment.

For beginners, I recommend:

• Debian desktop environment
• GNOME (or your preferred desktop)
• standard system utilities
• SSH server (for remote access)
• web server (we'll install manually later)

For server-only (no graphical interface):

• Debian desktop environment (uncheck)
• standard system utilities
• SSH server
• web server (install manually later)

Install GRUB Boot Loader

GRUB is the operating system bootloader. The installer will attempt to automatically detect other installed operating systems and add them as boot options to the GRUB menu.

• Select "Yes" to install GRUB
• Choose your primary hard drive (usually /dev/sda or /dev/nvme0n1)

First Boot

The system will reboot. Remove your USB drive when prompted.

Log in with your username (the one you created, not root) and press Enter. Then type your user password.

First thing to do: Update your system

Open a terminal and type:

sudo apt update && sudo apt upgrade -y

This updates all packages to their latest versions. It's like giving your new OS a quick refresh.

Congratulations! You've successfully installed Linux. You now have a functioning server operating system.

Understanding Docker and Containers

Now that you have Linux running, it's time to understand the technology that makes modern infrastructure so powerful: containerization.

What Are Containers? The Apartment Building Analogy

Think of containers as packaging an application and all its dependencies - like libraries, frameworks, and configuration files - into a single, standardized unit. This ensures that the application runs the same no matter where it's deployed.

Imagine your server is an apartment building:

• The building = Your Debian/Ubuntu server
• Individual apartments = Docker containers
• Each apartment has:
  • Its own filesystem
  • Its own software
  • Its own dependencies
  • Its own environment

But they all share the same foundation (Linux kernel) underneath.

Why Docker Changes Everything

Docker's popularity stems from its ability to solve a variety of challenges developers face: consistency across environments ("build once, run anywhere"), speed (containers are fast to start and stop), efficient use of resources (containers share the host system's resources more effectively than virtual machines), and version control for your applications.

Real-world example:

Instead of installing Jellyfin directly on your server (which gets messy fast), you run Jellyfin in a container. Want to also run a website? Put it in another container. Need a database? Another container.

They never conflict. You can delete and rebuild them instantly. Your host system stays clean and simple.

Docker Concepts You Need to Know

Docker images are the fundamental building blocks of containers. They are immutable, read-only templates containing everything needed to run an application, including the operating system, application code, runtime, and dependencies.

Key concepts:

1. Docker Images - Blueprints for containers (like architectural plans)
2. Docker Containers - Running instances of images (like actual apartments built from the plans)
3. Docker Hub - A public registry where developers can share and access pre-built images
4. Dockerfile - A text file that contains the steps needed to create a Docker image
5. Docker Compose - A tool for defining and running multi-container Docker applications, simplifying the management of interconnected containers

Installing Docker on Your New Linux Server

Open a terminal and run these commands:

For Ubuntu/Debian:

# Update package index
sudo apt update

# Install prerequisites
sudo apt install -y apt-transport-https ca-certificates curl software-properties-common

# Add Docker's official GPG key
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# Add Docker repository
echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Install Docker
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

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

# Log out and back in for group changes to take effect

Verify installation:

docker --version
docker compose version

Your First Container: Hello World

Let's prove Docker works:

docker run hello-world

This command verifies your Docker setup and demonstrates the container lifecycle.

You should see a message confirming Docker is working correctly.

Understanding Docker Compose: Multi-Container Applications

Docker Compose is a tool for defining and running multi-container Docker applications using a simple YAML file.

Instead of running individual containers with long command-line arguments, you define everything in a docker-compose.yml file.

Example structure:

version: '3.8'
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
  database:
    image: postgres:latest
    environment:
      POSTGRES_PASSWORD: mysecretpassword

We'll use this extensively in the next sections.

Setting Up Your First Services: Docker Stacks in Action

Now let's build something real. Instead of running single apps, you'll group services into stacks - just like production infrastructure.

Creating Your First Directory Structure

# Create a home for your Docker projects
mkdir -p ~/docker
cd ~/docker

This is where all your configurations will live.

Stack Example 1: Simple Web Server

Let's start simple: a basic website.

Create a new directory:

mkdir ~/docker/website
cd ~/docker/website

Create docker-compose.yml:

version: '3.8'

services:
  nginx:
    image: nginx:latest
    container_name: my-website
    ports:
      - "80:80"
    volumes:
      - ./html:/usr/share/nginx/html
    restart: unless-stopped

Create a simple webpage:

mkdir html
echo "<h1>My First Docker Website!</h1>" > html/index.html

Start the service:

docker compose up -d

Visit http://localhost in your browser. You should see your webpage!

What just happened?

• Docker downloaded the nginx image
• Created a container from it
• Mapped port 80 (standard web traffic)
• Connected your local html folder to the container
• Started it in detached mode (-d = runs in background)

Stack Example 2: Complete Application with Database

Let's build something more complex: a web application with a database.

mkdir ~/docker/webapp
cd ~/docker/webapp

Create docker-compose.yml:

version: '3.8'

services:
  # Database
  database:
    image: postgres:15
    container_name: webapp-db
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: appuser
      POSTGRES_PASSWORD: secure_password_here
    volumes:
      - postgres-data:/var/lib/postgresql/data
    restart: unless-stopped

  # Web application
  webapp:
    image: your-app:latest
    container_name: webapp
    ports:
      - "8080:8080"
    environment:
      DATABASE_URL: postgresql://appuser:secure_password_here@database:5432/myapp
    depends_on:
      - database
    restart: unless-stopped

volumes:
  postgres-data:

Key concepts here:

1. Multiple services working together
2. Volumes for persistent data (database doesn't lose data when container restarts)
3. Environment variables for configuration
4. depends_on ensures database starts before the web app
5. Internal networking - containers can talk to each other by service name

Managing Your Stacks

Essential Docker Compose commands:

# Start services
docker compose up -d

# View logs
docker compose logs -f

# Stop services
docker compose down

# Stop and remove all data
docker compose down -v

# Update and restart
docker compose pull
docker compose up -d

# View running containers
docker compose ps

Media Servers: Building Your Personal Netflix

For most people, this is the first "wow" moment. Set up Jellyfin or Plex, add automated downloads, and suddenly you have your own Netflix that you control.

Understanding Media Servers

Jellyfin and Plex are the best examples of media server software. These software tools remotely deliver multimedia content to the requested client/receiver.

You organize your movies, TV shows, and music on your server. The media server:

• Scans and catalogs your content
• Downloads metadata (posters, descriptions, ratings)
• Transcodes video for different devices
• Streams to phones, tablets, smart TVs, browsers

Jellyfin vs Plex: Which Should You Choose?

Plex is the polished, commercial option with a free tier and optional paid features. Jellyfin is completely open-source and free forever - no premium tiers, no paywalls, no phone-home authentication.

Jellyfin Advantages:

• Completely free - Jellyfin is the basic media server that Plex was many years ago. It shows your content and your content only, isn't commercialized, and is entirely free
• All files, metadata, and watch history are stored exclusively on your NAS. No data is sent to external servers
• Works offline (no cloud authentication required)
• Fully open source
• No feature paywalls

Plex Advantages:

• More polished interface
• Plex has the edge regarding client support across PC, mobile, TV, game consoles, and other platforms
• Easier setup for beginners
• Better metadata accuracy

Important update: In April 2025, Plex changed how remote streaming works. Remote playback is now a Plex Pass feature, meaning you will not be able to stream media outside of your home for free anymore.

My recommendation: Start with Jellyfin. It's free, private, and you control everything. As someone who values true self-hosted ethos, Jellyfin is brilliant and worth sticking with.

Installing Jellyfin with Docker

mkdir -p ~/docker/jellyfin
cd ~/docker/jellyfin

Create docker-compose.yml:

version: '3.8'

services:
  jellyfin:
    image: jellyfin/jellyfin:latest
    container_name: jellyfin
    user: 1000:1000  # Replace with your user ID
    network_mode: host
    volumes:
      - ./config:/config
      - ./cache:/cache
      - /path/to/your/media:/media  # Change this to your media location
    restart: unless-stopped
    environment:
      - JELLYFIN_PublishedServerUrl=http://YOUR-IP-ADDRESS  # Optional

Before starting:

1. Find your user ID:

   id -u
   

2. Create media directories:

   mkdir -p ~/media/movies
   mkdir -p ~/media/tv
   mkdir -p ~/media/music
   

3. Update the docker-compose.yml with your paths

Start Jellyfin:

docker compose up -d

Access Jellyfin:

Open your browser and go to http://localhost:8096 (or your server's IP address with :8096)

Follow the setup wizard to:

1. Create an admin account
2. Add your media libraries
3. Configure metadata providers
4. Set up users (if sharing with family)

Automated Media Stack: Jellyfin + Downloads

This is where things get powerful. Let's create an automated media downloading and organizing system.

mkdir -p ~/docker/media-stack
cd ~/docker/media-stack

Create docker-compose.yml:

version: '3.8'

services:
  # Media Server
  jellyfin:
    image: jellyfin/jellyfin:latest
    container_name: jellyfin
    network_mode: host
    volumes:
      - ./jellyfin/config:/config
      - ./jellyfin/cache:/cache
      - ./media:/media
    restart: unless-stopped

  # Torrent Client
  qbittorrent:
    image: linuxserver/qbittorrent:latest
    container_name: qbittorrent
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York  # Change to your timezone
      - WEBUI_PORT=8080
    volumes:
      - ./qbittorrent/config:/config
      - ./media/downloads:/downloads
    ports:
      - 8080:8080
      - 6881:6881
      - 6881:6881/udp
    restart: unless-stopped

  # File organizer (optional but recommended)
  filebot:
    image: jlesage/filebot:latest
    container_name: filebot
    volumes:
      - ./filebot/config:/config
      - ./media:/storage
    ports:
      - 5800:5800
    restart: unless-stopped

The magic of this setup:

The torrent client downloads directly into Jellyfin's folders. Jellyfin immediately sees new content. No moving files. No manual work. Everything flows automatically.

How it works:

1. Download content with qBittorrent
2. Files land in the /downloads folder
3. Use FileBot or manual organization to move to proper folders (/media/movies, /media/tv)
4. Jellyfin automatically scans and adds new content
5. Metadata is fetched (posters, descriptions, etc.)

Note: Sometimes you have to go to IMDB, get part of the URL, and paste it into Jellyfin's "identify" feature to populate correct information, but otherwise it works autonomously.

The Fediverse and Decentralized Networks

Part of my network runs through GhostCMS tied into ActivityPub. That's what connects MAL+ into the Fediverse.

What Is the Fediverse?

Instead of a single corporation hosting everything, independent servers talk to each other. Your homelab can be one of those servers.

The Fediverse runs on home servers, VPSs, rented VMs, old hardware, and big servers - all talking to each other seamlessly. A Mastodon or Ghost + ActivityPub node on someone's spare PC federates just fine with massive instances.

Why? Because protocols don't care about hardware.

If the server responds correctly, it's part of the network. Same software. Same standards. Same behavior.

Deep Dives Into the Fediverse

For comprehensive explanations:

• The Fediverse - Main article explaining the entire concept
• Social Media II: The Fediverse - In-depth exploration

What You Can Host

Your homelab can run:

• Blogs (Ghost + ActivityPub plugin)
• Social profiles (Mastodon, Misskey)
• Communities (Lemmy)
• Media sharing (Pixelfed, PeerTube)
• Services that still interact across the wider Fediverse network

This is how parts of MAL+ operate. It's decentralized social networking that you control.

Creative Hardware Enclosures: Thinking Outside the Box

I rarely see objects as just objects anymore. When I look at totes, bins, metal trays, toolboxes, and shelving, I see potential server cases.

The Philosophy

Servers don't need to be pretty. They need to be safe and functional.

A small Home Depot HDX tote just looks like a computer case for a cluster of single-board computers. An aluminum panel becomes an open-air rig. Industrial containers transform into outdoor lab possibilities.

My Evaluation Checklist

When considering any enclosure, I always evaluate:

1. Power Safety

• Can I route power safely inside?
• Is there risk of shorts?
• Can cables be properly managed?

2. Heat Management

• Can airflow be added?
• Are there ventilation points?
• Will components overheat?

3. Durability

• Will it last long-term?
• Can it handle the weight?
• Is it structurally sound?

4. Environment

• Indoor, garage, or outdoor?
• Temperature extremes?
• Moisture concerns?

5. Access

• Can I upgrade easily?
• Is maintenance practical?
• Can I reach components?

Creative Enclosure Ideas

Small plastic totes (6-10 qt):

• Perfect for Raspberry Pi clusters
• Single-board computer (SBC) projects
• Small network hardware
• Modifications: Drill ventilation holes, add small fans, cable management clips

Aluminum panels or sheets:

• Open-air test benches
• Wall-mounted server boards
• Custom rack alternatives
• Benefits: Excellent heat dissipation, easy access, lightweight

Tool cases or metal boxes:

• Mobile server setups
• Protected outdoor installations
• Portable development stations
• Considerations: Ensure proper grounding, add rubber feet for vibration

Server rack alternatives:

• Wall-mounted wooden shelves with proper ventilation
• Industrial wire shelving (adjustable, great airflow)
• Repurposed furniture with modifications
• Key: Maintain proper spacing between devices

Safety First

WARNING - Critical safety considerations:

1. Never compromise electrical safety - Use proper wiring, grounding
2. Heat kills hardware - Ensure adequate cooling
3. Fire hazards - Keep flammable materials away, don't overload circuits
4. Physical stability - Secure heavy equipment properly
5. Accessibility - Don't create death traps for maintenance

Creativity saves money and makes projects fun, but safety is non-negotiable.

Next Steps and Advanced Topics

Recommended Learning Path

My recommendation for beginners:

1. Install Debian or Ubuntu on an old PC
2. Install Docker and docker-compose
3. Run a simple web server stack
4. Set up Jellyfin media server
5. Add automation tools
6. Explore Jupyter for data science
7. Experiment with additional services
8. Build a multi-machine network

Topics to Explore Next

Containerization Deep Dive:

• Learn Kubernetes for container orchestration at scale, understanding nodes, clusters, pods, the control plane, and how they interact to ensure seamless operations
• Advanced Docker networking
• Custom image creation
• CI/CD pipelines

Virtualization:

• Proxmox VE for running multiple operating systems
• Proxmox makes hardware management easy through its easy-to-use UI and terminal, supports clustering and high availability, and runs on almost anything

Networking:

• VLANs for network segmentation
• Reverse proxies (Nginx Proxy Manager, Traefik)
• VPNs for secure remote access
• DNS with Pi-hole or AdGuard Home

Monitoring and Management:

• Portainer for Docker management
• Grafana for metrics visualization
• Prometheus for monitoring
• Uptime Kuma for service monitoring

Self-Hosted Services:

• Nextcloud (personal cloud storage)
• Vaultwarden (password manager)
• Home Assistant (home automation)
• Gitea (Git repository hosting)
• Paperless-ngx (document management)

Resources for Continued Learning

Online Communities:

Note that while online communities can be valuable resources for troubleshooting and learning, information quality varies significantly. Reddit communities in particular can contain biased opinions, outdated information, or conflicting advice depending on the thread and participants. Always cross-reference information you find in forums with official documentation, and be prepared to do additional research to verify recommendations. Community advice should be a starting point for your own investigation, not the final word.

That said, these communities can be helpful when used critically:

• r/homelab - Homelab enthusiasts sharing setups and advice
• r/selfhosted - Self-hosting specific discussions
• r/docker - Docker-focused community
• Various Discord servers focused on homelab topics

Official Documentation:

• Docker Official Documentation
• Debian Administrator's Handbook
• Ubuntu Server Guide
• Awesome Self-Hosted (comprehensive list of services)

Final Thoughts

The infrastructure behind MAL+ isn't magic. It's just Linux servers working together. And older computers can do the same job with almost no functional difference.

With Debian for stability and containers for flexibility, you can build:

• Hosting platforms
• Media servers
• Development labs
• Automation systems
• Decentralized services
• Your own private cloud

All from hardware people throw away.

Once you experience running your own infrastructure, everything changes. You stop being a user of services. You become the operator of your own. And that's where the real power and learning begins.

The barrier to entry is lower than ever. The tools are mature, the community is supportive, and the benefits are tremendous. Whether you're learning new skills, saving money on subscriptions, protecting your privacy, or simply enjoying the satisfaction of building something yourself - a homelab offers all of this and more.

Start simple. Be patient with yourself. Break things. Fix them. Learn.

Your journey into self-hosted infrastructure starts with that old PC sitting in your closet. What will you build with it?

Author's Note: This guide represents years of practical experience building and maintaining Linux-based infrastructure. The MAL+ network mentioned throughout runs on these exact principles - older hardware, Linux, Docker, and decentralized services working together seamlessly. If you have questions or want to share your homelab journey, reach out through MAL+.

Last Updated: February 2026

License: This guide is provided freely for educational purposes. Feel free to share, adapt, and learn from it.