From a Raspberry Pi to an Enterprise Workstation: My Homelab Journey

I never planned to build a homelab. I just wanted to learn Linux. That's it.

If you had told me a few years ago that I'd end up with an Enterprise workstation running multiple VMs, a local AI setup with a 24GB GPU, OPNsense, Plex, Tailscale, and enough networking gear to confuse my parents, I would've laughed.

The funny part is, I still don't have an actual rack. Most of my systems are lying here and there around the room, connected by a mix of planning, improvisation, and too many cables.

Back then, all I wanted was one Linux machine I could SSH into. Looking back now, every hardware upgrade happened because of a real problem at that time. Nothing was bought because someone online called it "essential." This is how the homelab happened by accident.

2020 - The Raspberry Pi Phase

Like a lot of people, this started during COVID when I was in college. I bought a Raspberry Pi 4B with a 128GB pendrive attached for storage because it looked cool and cheap enough to mess with. At first, it did absolutely nothing useful except save me from renting a server on AWS, which I didn't want to pay a monthly fee for.

My routine was simple: install Ubuntu Server, break it, reinstall it, repeat. Honestly, I learned more from breaking Linux than from tutorials.

That tiny board became my playground for SSH, systemd, cron, Docker, and networking, plus the painful truth that SD cards are terrible for anything important. The Pi was not powerful, but it gave me the one thing that mattered most: a machine I wasn't afraid to destroy. That freedom hooked me.

2021 - Linux Became My Daily Driver

Somewhere along the way, Linux stopped being a side hobby and became my everyday system. I moved my personal laptop to Arch Linux with i3 after a lot of hopping from Garuda Linux to Debian to Ubuntu to Pop!_OS.

People joke that Arch users install it just to say they use Arch. Maybe. But for me, installing it was the easy part; configuring it and installing the necessary drivers was where the real learning happened. Boot issues, display managers, audio bugs, network weirdness, and package conflicts from hell. Nothing is hidden from you, and that is exactly why it teaches so much.

It was frustrating at times, especially when a bad package release broke things, and I had to live boot just to downgrade. Still, I wouldn't trade that phase for anything. My laptop still runs Arch today.

Dotfiles: https://github.com/harshitRuwali/dotfiles

2023 - The Network Started Growing

Once you have one always-on machine, your brain changes. You want more services, more storage, and more experiments.

Around March 2023, I picked up a Raspberry Pi 5. The extra performance finally made self-hosting feel smooth instead of painful. That same month, I bought a TP-Link ER605 and later on a 16-port PoE switch.

Did I need 16 ports at that point? Not even close. But I knew this was not going to stop at one server. That purchase quietly changed how I thought. I stopped thinking in terms of individual devices and started thinking in terms of infrastructure.

The "Can I Self-Host This?" Era

This phase lasted way longer than I expected. Every time I found an open-source tool, my first thought wasn't "Should I use this?" It was "Can I host this myself?"

That one question ate a lot of weekends. Plex, reverse proxies, Compose stacks, monitoring, backups, VPNs, DNS, auth, everything. If a guide existed, I tried it. If there was no guide, I probably broke something trying anyway.

Storage Teaches You Humility

Storage always looks simple until it doesn't. At one point I added a 2TB drive and thought, "No chance I'll fill this." That confidence aged badly.

Media, VM backups, Docker volumes, datasets, models, ISOs, logs, everything wants disk. Very quickly, 2TB felt tiny.

March 2026 - The MiniPC Phase

Before the workstation, I got a miniPC around March 2026. It was small, quiet, and way more capable than I expected. Around that time, I had started doing more Rust projects, and local compilation was absolutely cooking my laptop.

The miniPC gave me flexibility to run builds and services without worrying about my laptop overheating or slowing down. It was a small step, but it made a big difference in how I approached my homelab.

That machine became my bridge between Raspberry Pi experiments and proper development workflows.

That step mattered more than it looked from outside. It gave me clarity on what to buy next.

Later in 2026 - The Workstation Jump

This was the big leap. I got a Dell Precision T7920 (2x Intel Xeon 6138, 40 cores, 80 threads; 128GB ECC RAM; Nvidia RTX A5000), and compared to anything I had before, it felt ridiculous: enterprise-grade hardware, ECC RAM, plenty of PCIe lanes, dual-socket capable.

This wasn't just another PC. It was a proper infrastructure box. First thing I did was wipe it and install Proxmox, because virtualization was the entire reason I bought it.

Falling Into the Proxmox Rabbit Hole

I thought I'd run maybe one or two VMs. Yeah, that didn't happen.

Very quickly it turned into:

• AI VM
• Dev VM
• OPNsense firewall VM
• Cloud services VM
• Plex
• qBittorrent
• Tailscale router
• Grafana Monitoring VM
• Memory system VM (Postgres + Redis + Vector DB)
• And more

Each service had a clear purpose, and more importantly, each had its own failure domain. Breaking one VM stopped being a "whole lab is down" event.

Snapshots became addictive, experimentation became low-risk, and that was when I really understood the virtualization hype.

Networking Became the Fun Part

I never expected this, but networking became one of my favourite parts. Setting up OPNsense, creating isolated networks, building bridges and VLANs, keeping AI workloads off LAN while exposing only what I actually wanted, and routing securely over Tailscale.

Half the fun wasn't making it work. Half the fun was debugging why it didn't. Those sessions taught me more than any course could.

The AI Server Phase

One major reason for getting a workstation was simple: run models locally.

With the RTX A5000 in place, that 24GB VRAM opened a lot of doors, and now I could experiment without always depending on external APIs. Qwen, embeddings, vector DBs, RAG pipelines, memory systems, inference servers - most of my recent side projects wouldn't exist without this machine.

It also gave me huge respect for how hard model serving actually is: memory pressure, quantization trade-offs, context limits, and GPU scheduling. You don't really understand this stuff until you're staring at nvidia-smi wondering where the VRAM disappeared.

The Shipping Incident

No homelab story is complete without pain.

When the workstation reached my hometown, I wasn't there. I was on a video call with my dad trying to debug why the GPU wouldn't come up. We spent hours checking cables, reseating parts, questioning the PSU, questioning the GPU, and questioning our life choices.

Eventually we found the real issue: one PCIe slot was damaged in shipping. We moved the GPU to another slot, and everything worked. That was probably one of my longest remote debugging sessions ever, and my dad had way more patience than I did that day.

Tweet: https://x.com/harshitruwali/status/2074536063759167569?s=20

The Part I Didn't Expect

People usually ask what services I run, but honestly that's the least interesting part.

This lab was never really about Plex, Docker, Proxmox, or Kubernetes. It was about learning from real failures. Every problem was real, every mistake had consequences, and every fix taught me something.

Networking made sense because I had to debug it. Storage made sense because I ran out of it. Linux made sense because I broke it repeatedly. Virtualization made sense because I needed isolation. AI infra made sense because I wanted local inference. These weren't tutorial exercises anymore; these were real systems I cared about.

What's Next?

The lab is still evolving, and there is still a lot I want to build: a proper NAS, high availability, Ceph, better observability, and cleaner GitOps workflows. Maybe Kubernetes too, maybe not.

That's the best part of a homelab. It is never finished. It just grows with your curiosity.

Final Thoughts

Sometimes I look at all these machines lying around the room and laugh.

All this started from one Raspberry Pi and a curiosity for Linux. Somewhere between reinstalling Ubuntu for the tenth time and debugging a broken PCIe slot over a video call, I accidentally built the best learning environment I've ever had.

If there is one thing this journey taught me, it is this: you don't need enterprise hardware to begin. You just need one system you're willing to break. Everything else follows.