A lot of developers learn infrastructure from courses — spinning up a VPS, clicking through the AWS console, following a tutorial. I did all of that too. But nothing clicked until I started running my own homelab on an old laptop sitting under my desk in Albany.

This post is about what I built, what broke, what I learned, and why I think every backend developer should go through the pain of running their own production-grade infrastructure — even if it’s just a $40 Raspberry Pi.

---

What Even Is a Homelab?

A homelab is just a personal server (or cluster of machines) you run at home to experiment with. Mine is an old ThinkPad running Ubuntu 22.04 LTS with 16GB RAM and a 512GB SSD. Nothing exotic.

The magic isn’t the hardware — it’s the fact that it’s always on, always yours, and you’re responsible for every layer of the stack. No managed services. No “click here to enable HTTPS.” Just you, the terminal, and Google.

The Stack I Run

After months of iteration, here’s what’s currently running — all Dockerized, all behind nginx as a reverse proxy:

• Nginx Proxy Manager — reverse proxy + SSL termination via Let’s Encrypt
• Cloudflare Tunnel — zero-trust exposure, no open ports on my router
• Portainer — Docker container management UI
• Uptime Kuma — self-hosted status page and alerting
• Vaultwarden — self-hosted Bitwarden-compatible password manager
• Gitea — private Git server for side projects
• Grafana + Prometheus — metrics and observability
• Nextcloud — personal cloud storage and calendar sync

Getting Everything Running

Step 1 — Docker Compose setup

Everything runs via docker compose. Each service gets its own compose.yml in a dedicated folder. This makes it trivial to start, stop, or update individual services without touching others.

version: "3.8"

services:
  app:
    image: jc21/nginx-proxy-manager:latest
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
      - "81:81"
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt

Step 2 — Cloudflare Tunnel (no open ports!)

Instead of forwarding ports on my home router, I use Cloudflare Tunnel — an outbound-only connection that proxies traffic through Cloudflare’s edge to my services.

# Install cloudflared
$ curl -L https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64 -o cloudflared
$ chmod +x cloudflared && sudo mv cloudflared /usr/local/bin

# Authenticate and create tunnel
$ cloudflared tunnel login
$ cloudflared tunnel create homelab

# Run as a Docker container
$ docker run -d --name cloudflared cloudflare/cloudflared:latest tunnel --no-autoupdate run --token YOUR_TOKEN

What Running This Taught Me

I can’t overstate how much this accelerated my understanding of real infrastructure. Here’s what actually sank in because things broke:

1. DNS propagation is real — I spent 4 hours debugging a “broken” service that was just waiting for TTL to expire.
2. Reverse proxy routing — understanding how nginx decides which upstream to send a request to changed how I think about microservices.
3. Certificate renewal — Let’s Encrypt certs expire every 90 days. Auto-renewal sounds easy until it silently fails at 3am.
4. Container networking — Docker bridge networks, host networking, and why containers can’t reach each other when you expect them to.
5. Observability is not optional — once you have Grafana + Prometheus running, you can’t go back to flying blind.

---

You build it, you run it. This brings developers into contact with the day-to-day operation of their software. — Werner Vogels, CTO of Amazon

This is the whole point. Reading about nginx upstream configuration in a tutorial is very different from debugging why your 502 Bad Gateway keeps appearing at random intervals.

Resources That Actually Helped

• r/homelab — the community is incredibly helpful for beginners
• Docker Compose docs — actually read them, not just the quickstart
• Nginx official docs — confusing at first, but worth the read
• Cloudflare Zero Trust docs — for the tunnel setup above

Final Thoughts

My homelab has directly shaped how I think about the systems I build at work. When I set up Docker + EF Core migrations at my internship, I already understood the deployment model intuitively — because I’d broken it a dozen times at home first.

If you’re a developer who wants to go deeper on infra, DevOps, or distributed systems, start a homelab. Break things. Fix them. The muscle memory you build is worth more than any certification.

And if you want to talk homelab setups, distributed systems, or compare hot chocolate ratings across Albany cafés — shoot me an email.