My Homelab in 2026: 32 Containers, 85TB, and an Arc A380 That Changed Everything

I run a lot of stuff at home. Too much, probably. But the server hums along in the corner of my closet like a loyal, slightly obsessive friend, and I’ve never once regretted building it.

I’ve been doing this kind of thing for a long time — with some significant interruptions along the way. The stack looks different now than it did before the gap, mostly because the tools got better, but also because I got a little more deliberate about what I actually needed versus what I was just running because I could.

The old setup was bare metal everything — services installed directly on the OS, NFS shares feeding a Kodi install on a Raspberry Pi, the whole thing held together with symlinks and hope. Moving to new hardware meant reinstalling and reconfiguring everything from scratch. Docker changed that completely. When the day comes to move to new hardware, it’s tar up the compose files and volumes, point at a new box, and be back online in an afternoon. I haven’t had to do it yet, but knowing I could without a week of reinstalling and reconfiguring is worth something. Future-proofed, or at least future-calmed.

Here’s what’s actually running on the box I call balor.

The Hardware

• CPU: AMD Ryzen 5 5600X (6-core / 12-thread)
• RAM: 32GB DDR4
• OS Drive: 1TB NVMe SSD
• GPU: Intel Arc A380 (ASRock) — more on this in a moment
• Media Storage: 10 spinning HDDs in a MergerFS pool, ~85TB total, 56TB used
• Docker data: Dedicated 1.8TB HDD
• OS: Debian 13 (Linux 6.12.74)

The storage situation is its own post someday. MergerFS lets me pool drives of different sizes into one logical volume without the risk of a full RAID rebuild wiping everything if a drive dies. Each file lives on one drive. Simple. Survivable.

The Intel Arc A380: My Favorite Bargain

This little card deserves its own section. The Arc A380 is Intel’s entry-level discrete GPU — you can find them for around $120–160 — and on paper it’s nothing impressive. It’s not gaming hardware. It’s not an AI accelerator. But for one specific job, it’s extraordinary: media transcoding.

Under the hood, Jellyfin talks to it through VA-API and Intel’s Quick Sync Video (QSV) stack, using the iHD driver. The card handles H.264, HEVC (H.265), and — this is the part that genuinely impressed me — AV1 hardware encoding and decoding. AV1 is the codec that used to melt CPUs just to decode. This $90 card does it in hardware, offloaded completely from the Ryzen.

The Jellyfin-ffmpeg invocation when the Arc is doing its thing looks something like:

-init_hw_device vaapi=va:/dev/dri/renderD128,driver=iHD
-init_hw_device qsv=qs@va
-codec:v:0 av1_qsv -preset veryfast

The CPU barely notices. The Arc handles it and moves on.

The Software Stack (Docker, All of It)

Everything runs in Docker containers. 32 of them, at last count. Here’s the breakdown by category:

Media

• Jellyfin — the media server. Open source, no subscription, no telemetry. On the client side, almost anything works: phones, browsers, smart TVs, Fire Sticks, and if you want the full living-room experience, Kodi on a Raspberry Pi is still one of the best front ends you can put in front of it. I ran that setup for years. Eventually I swapped the Pi for the native Jellyfin app on the smart TV — ostensibly to “simplify,” but honestly I just needed the HDMI port back. The trade-off was real: I lost Hyperion (the ambient lighting that bled the screen colors onto the wall behind the TV, which was glorious), but gained a genuinely seamless interface that my less technically inclined household members could actually use without calling me over. Net positive, I think. I miss the glow. The Pi, at least, has been liberated for other projects — which is how it always goes.
• Jellyseerr — request management. Users ask for things, the stack fetches them.
• Sonarr / Radarr / Lidarr — automated TV, movie, and music management
• Bazarr — subtitle fetching and management
• SABnzbd — Usenet downloader
• Jellystat — Jellyfin statistics and usage tracking

Cloud & Productivity

• Nextcloud AIO — my Google Drive replacement, running 13 containers including Collabora (closet), ClamAV, full-text search, push notifications, and Talk for video calls

Photos

• Immich — Google Photos replacement with machine learning face/object recognition. It’s remarkable.

Home Automation & Network

• Home Assistant — home automation brain
• Frigate — NVR and object-detection for security cameras
• Mosquitto — MQTT broker tying it all together
• WireGuard — VPN for remote access

Infrastructure

• Portainer — container management UI
• syslog-ng — centralized logging
• Discord-Meshtastic MQTT bridge — yes, I have a Meshtastic mesh radio node and yes it posts to Discord. No regrets.

The Numbers (Because Jellystat Knows)

Jellystat has been quietly tracking everything Jellyfin does. Here’s what the data says:

• 16,777 total plays across all users
• 29 unique users who’ve watched something
• ~7,520 hours of content consumed
• Peak day: 9 simultaneous users — Valentine’s Day 2026, apparently everyone was in the mood for a movie
• 74% direct play, 25% transcode, 1% direct stream — most clients can play files natively; the Arc handles the rest

That’s nearly a year of continuous playback across people who just wanted to watch something without a subscription.

How to Set Something Like This Up

The short version:

1. Start with Debian or Ubuntu. Stable base, great driver support for the Arc. You need kernel 6.2+ for i915 to handle Arc properly; 6.12 is rock solid.
2. Install Docker and Docker Compose. Every service here runs via docker-compose.yml. Each stack lives in its own directory under /opt/docker/.
3. For multi-drive storage, look at MergerFS. Pair it with SnapRAID if you want parity protection without the risks of traditional RAID.
4. Reverse proxy everything with Nginx Proxy Manager or Caddy. HTTPS for all services, even internal ones.
5. Mount your MergerFS pool identically across every container that touches media. This one trips people up. Sonarr, Radarr, Lidarr, Bazarr, and Jellyfin all need to see your media at the same path inside their containers. On this box, the MergerFS pool lives at /mnt/dockers/merged on the host. Every media container mounts it as /media. That means when Sonarr drops a finished show into /media/TV/, Jellyfin already knows exactly where /media/TV/ is — no translation needed. If you mount it as /data in one container and /media in another, you’ll spend a weekend wondering why your library scans keep failing. (A full breakdown of how this stack fits together is its own post — the Docker networking and volume strategy alone is worth a dedicated writeup.)

Add the Arc A380. Pass through /dev/dri/renderD128 to the Jellyfin container in your compose file:

devices:
  - /dev/dri/renderD128:/dev/dri/renderD128

Then in Jellyfin’s admin panel, enable Intel QSV under hardware acceleration and set it to prefer hardware encoding for H.264, HEVC, and AV1.

The whole stack took years to accumulate, container by container, rabbit hole by rabbit hole. But the Arc A380 — which I added about a year and a half ago, recent only by homelab standards — made an immediate difference when it went in: suddenly transcoding was a solved problem, not a resource fight.

If you’re running Jellyfin and your CPU is sweating through 1080p transcodes, an Intel Arc card in the $120–160 range is probably the best money you’ll spend on your homelab this year.