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. Most of it I built because I could, which is a terrible reason that has never stopped me.

I’ve been doing this kind of thing for a long time, with some significant interruptions along the way (and we’ll get to that). The stack looks different now than it did before the gap, mostly because the tools got better, but also because I came back a little more deliberate about what I actually needed versus what I was just running because it was Tuesday and I was bored.

Before Docker it 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, which is exactly as fun as it sounds. Docker fixed that. When the day finally comes to move balor to new hardware, it’s tar up the compose files and volumes, point at a new box, and be back online in an afternoon. Haven’t had to do it yet, but the option existing 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 below
• 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 setup deserves its own post and I keep putting it off. The short version: MergerFS pools drives of different sizes into one logical volume without the RAID risk of a single drive failure taking everything with it. Each file lives on one drive, so a dead drive loses those files and nothing else. It’s not a backup strategy (please have a backup strategy), but it’s a sane way to keep accumulating storage without committing to matching drives, which is helpful when half your drives were acquired one at a time over a decade.

The Intel Arc A380

The A380 is Intel’s entry-level discrete GPU, $120–160 depending on where you look, and on paper there’s nothing exciting about it. It’s not a gaming card, it’s not built for AI workloads, and nobody is making YouTube reviews comparing it to a 4090. But stick it in a Jellyfin box and it changes the whole situation. Transcoding stops being a CPU problem entirely, and that’s sort of the whole game.

Jellyfin talks to it through VA-API and Intel’s Quick Sync Video stack using the iHD driver. H.264 and HEVC are handled like you’d expect, but the one that actually surprised me was AV1: hardware encode and decode, on a sub-$160 card. AV1 used to mean pegging a CPU for a fraction of realtime. The Arc does it offloaded, while the Ryzen does literally anything else.

The ffmpeg invocation looks something like this when it’s working:

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

The Ryzen barely registers it. Felt like magic the first time I watched the CPU graph stay flat through a 4K transcode.

The Software Stack

All of this runs in Docker. The container count is somewhere around 32, give or take whatever I’ve added or torn down in any given week. Here’s what’s actually doing the work.

Media

• Jellyfin: the media server. Open source, no subscription, no telemetry, no asking you to pay extra for the codec your phone already supports. On the client side almost anything works, including phones, browsers, smart TVs, and Fire Sticks, and Kodi on a Raspberry Pi is still one of the best living-room front ends you can put in front of it. I ran that setup for years and loved it. 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. Lost Hyperion in the process (the ambient lighting that bled screen colors onto the wall behind the TV, which was genuinely great and I miss it), but gained an interface my household can use without finding me first. The Pi got liberated for other projects, which is how it always goes.
• Jellyseerr: request management. Users ask for things, the stack fetches them, everyone is happy.
• Sonarr / Radarr / Lidarr: automated TV, movie, and music management
• Bazarr: subtitles, because nothing kills a movie night like “wait, where are the subtitles?”
• SABnzbd: Usenet downloader
• Jellystat: Jellyfin usage tracking, which is how I have the numbers further down

Cloud & Productivity

• Nextcloud AIO: replaced Google Drive. Runs 13 containers under the hood for Collabora (documents), ClamAV, full-text search, push notifications, and Talk for video calls. More than I strictly need, but the AIO bundle is the path of least resistance.

Photos

• Immich: replaced Google Photos. Does face recognition and object detection locally via machine learning, and it works well enough that I stopped second-guessing the move.

Home Automation & Network

• Home Assistant: home automation
• Frigate: NVR with object detection for security cameras
• Mosquitto: MQTT broker
• WireGuard: VPN

Infrastructure

• Portainer: container management UI for when I don’t want to SSH
• syslog-ng: centralized logging
• Discord-Meshtastic MQTT bridge: I have a Meshtastic mesh radio node and it posts to Discord. No, this is not strictly useful. Yes, I built it anyway.

The Numbers

Jellystat has been tracking everything Jellyfin does, and the data is sort of interesting:

• 16,777 total plays
• 29 unique users
• ~7,520 hours watched
• Peak day: 9 simultaneous users, Valentine’s Day 2026. Apparently everyone had the same idea about a movie night.
• 74% direct play, 25% transcode, 1% direct stream. Most clients handle the files natively; the Arc covers the rest.

That’s a lot of hours of people watching things without paying for another subscription, which was sort of the whole point.

How to Set This Up

1. Debian or Ubuntu as the base. Kernel 6.2+ is required for the Arc’s i915 driver to work properly. I’m on 6.12 and it’s been rock solid.
2. Docker and Docker Compose. Each service gets its own docker-compose.yml under /mnt/dockers/dockercompose/. Don’t make one giant compose file. You will regret it.
3. MergerFS for multi-drive storage. SnapRAID alongside it if you want parity without committing to traditional RAID.
4. Reverse proxy. Nginx Proxy Manager or Caddy. HTTPS everywhere, including internal services. Future you will thank you.
5. Mount your storage at the same path in every media container. This is the one that catches everyone, including me, repeatedly. Sonarr, Radarr, Lidarr, Bazarr, and Jellyfin all need to see the same path inside their containers, or they can’t find each other’s files. Here the MergerFS pool is /mnt/dockers/merged on the host and /media inside every container, no exceptions. Mount it differently in one container and you’ll spend a weekend staring at library scans that return nothing and questioning your life choices. A full writeup on how the stack fits together is coming.

Arc A380 passthrough to Jellyfin. Add this to the compose file:

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

Then enable Intel QSV in Jellyfin’s admin panel under hardware acceleration. Turn on hardware encoding for H.264, HEVC, and AV1 while you’re there.

The Arc A380 went in about a year and a half ago, which counts as recent only by homelab standards, and it was an immediate upgrade. Transcoding went from something the CPU had to fight through to something that just happens in the background, like it should.

If your Jellyfin box is CPU-transcoding everything, an Intel Arc in the $120–160 range is probably the most impactful thing you can add to it. On a tighter budget, the A310 is worth a look. You give up 2GB of VRAM and a bit of compute, but the encode and decode engines are essentially the same silicon, so the transcoding story is nearly identical for less money.