> ## Content Index
> Fetch the complete content index at: https://lifeinproduction.co.uk/llms.txt
> Use this file to discover other available public pages before exploring further.

# Behind the Automation — Making the Media Stack Work for Me
- URL: https://lifeinproduction.co.uk/behind-the-automation-making-the-media-stack-work-for-me/
- Published: 2026-11-16T16:47:21.000Z
- Updated: 2026-11-16T16:49:40.000Z
- Description: From Windows engineer to Docker beginner. How I used AI, Sonarr, Radarr, SABnzbd and a few YAML headaches to automate my home media server.
- Author: Eric MacFarlane
- Tags: Technology, Docker, Self-Hosting, Home Lab, Media Automation

*Building My Media Stack — Part Two*

In [Part One](https://lifeinproduction.co.uk/building-my-media-stack-ive-got-an-idea/), I introduced the idea of building my own Netflix-style media server using a modest little mini-PC, an ageing QNAP NAS and a growing collection of Docker containers.

This time, we're getting into the technical side of things.

But before diving into Docker Compose files and configuration settings, it's probably worth explaining why I wanted all this automation in the first place.

Because, believe it or not, I didn't build it simply to see how many Docker containers I could squeeze onto an Intel N100.

Although, looking at the system now, you might be forgiven for thinking otherwise.

## The Problem With Doing Everything Yourself

I'd experimented with media servers before.

In the past, I'd used Plex alongside qBittorrent, but managing the media was largely a manual process.

If I wanted something added to my library, I'd have to find a suitable source, locate the content, start the download and hope it actually completed.

Then came the fun of checking the quality, sometimes re-encoding the video, renaming files, moving them into the correct folders and finally getting Plex to recognise everything.

A single film could turn into a project lasting hours, sometimes days.

It worked, but it was becoming a bit of a chore.

And considering I spend my working life in IT, the last thing I particularly wanted was another system requiring constant attention when I got home.

I wanted something simpler.

**Search for a title, add it to my library, and let the system deal with the rest.**

That was the goal.

The time spent requesting something should be measured in minutes, not hours. The actual downloading and processing could take however long it needed.

I just didn't want to be the one doing all the work.

## From Windows Expert to Linux Apprentice

There's something you should probably know about me.

I've spent pretty much my entire IT career working with Microsoft technologies.

From Windows 95 through to Windows Server 2025\. From Exchange 2003 to Exchange Online and Azure.

Need a Windows server building? No problem.

Want an enterprise network designing? I'm your man.

Wi-Fi problems? Leave it with me.

PKI, certificates, SSO, VPNs? I laugh in the face of certificate authorities.

I'm practically the VPN God.

But put me in front of a Linux terminal?

Suddenly I'm the junior engineer starting his first day, wondering what on earth I've just typed.

And Docker was an even bigger learning curve.

I was comfortable with VMware and Hyper-V. I understood hypervisors, virtual machines, virtual networking and storage.

Containers, however, were a different ball game.

With a virtual machine, I'm used to building an operating system and installing applications onto it.

Docker takes a different approach. Applications and their dependencies are packaged into images, containers share the host's kernel, and their configuration is defined through things like environment variables, networks and volume mounts.

And that's before we get to YAML.

## YAML — Death by Spacebar

One of my earliest Docker lessons was discovering just how particular YAML can be.

At first glance, Docker Compose looks simple enough.

A text file defining which applications you want to run, their ports, storage locations and networking.

How difficult could that be?

Well, it turns out you can't just type things wherever you fancy.

Indentation matters.

One misplaced space, and suddenly your beautifully configured container refuses to start.

I learned fairly quickly that the spacebar could be a surprisingly dangerous tool.

Eventually, I got into the habit of checking the configuration before attempting to start or recreate anything.

```bash
cd /home/eric/media-server

# Validate the Docker Compose configuration
docker compose config --quiet

# Start the configured services
docker compose up -d
```

The first command parses and validates the Compose configuration without applying changes.

It doesn't guarantee every application will work correctly, but it catches plenty of mistakes before Docker attempts to start anything.

A simple lesson, but one that saved me a fair amount of frustration.

And yes, it's now something I do routinely.

## Bringing AI Into the Build

One of the biggest differences between this project and things I've built in the past was having ChatGPT alongside me.

I knew what I wanted to achieve, but I was unfamiliar with many of the applications.

So I started using AI as a technical assistant.

I'd take screenshots, feed them into ChatGPT, explain what I wanted to achieve and follow the configuration instructions.

Sometimes that meant changing a setting in a web interface.

Other times it meant copying and pasting sections of Docker Compose YAML.

Did I always fully understand what I'd just done?

Absolutely not.

But that's where the fun started.

**I'd make something work, then go back and understand what I'd actually done.**

I'm not suggesting that blindly copying AI-generated configuration into a production environment is a particularly good idea.

AI can make mistakes, miss important details or suggest something that simply doesn't fit your environment.

But on my own little Debian server in the garage, it gave me an opportunity to experiment, ask questions and learn an entirely new way of working.

And when something broke, I had something to help me troubleshoot it.

Usually after I'd discovered yet another creative way of upsetting YAML.

## Deciding What Each Application Needed to Do

Once Docker was up and running, the next challenge was choosing the software.

Rather than finding one application that attempted to do everything, I went with a collection of specialised tools.

The automation layer would handle what I wanted in my library.

The downloading and processing layer would handle obtaining and preparing the files.

For films and television, that meant:

- **Radarr:** Managing films, quality profiles and automatic imports.
- **Sonarr:** Managing television series, seasons and episodes.
- **Prowlarr:** Centrally managing indexer connections.
- **SABnzbd:** Handling Usenet downloads, verification and extraction.

For music and books, I'd add:

- **Lidarr:** Managing artists and albums.
- **LazyLibrarian:** Managing books and reading material.
- **slskd:** Providing access to the Soulseek music-sharing network.
- **Gluetun:** Providing VPN routing for the Soulseek client.

Seerr would provide a friendly request interface, and Jellyfin would remain the application used to watch the finished media.

Each application had its own responsibility.

The interesting part was getting them to communicate.

## Docker Compose — The Foundations

The media-server project lives under:

`/home/eric/media-server`

With the application configuration stored separately under `/opt/appdata`.

My media library lives on the QNAP, mounted over NFS at:

`/mnt/qnap/media`

Temporary downloads use the mini-PC's SSD:

`/opt/local-ssd/downloads`

This was a deliberate design decision.

Initially, the media was stored locally because I already owned the QNAP but hadn't yet bought the hard drives. Once the disks arrived, I migrated the library onto the NAS while retaining the container paths.

Keeping the application configuration, temporary downloads and permanent media separate makes the environment easier to maintain.

It also means I can recreate containers without losing their settings.

Here's the actual Sonarr configuration from my Compose file:

```yaml
sonarr:
  image: lscr.io/linuxserver/sonarr:latest
  container_name: sonarr
  environment:
    - PUID=1000
    - PGID=1000
    - TZ=Europe/London
  volumes:
    - /opt/appdata/sonarr:/config
    - /opt/local-ssd/downloads:/downloads
    - /mnt/qnap/media:/media
  ports:
    - 8989:8989
  networks:
    - media-net
  restart: unless-stopped
```

There are several important parts worth understanding.

`image` identifies the Docker image being used.

`PUID` and `PGID` tell the LinuxServer.io container which user and group IDs to use for filesystem access.

The `volumes` section maps directories on the Debian host into the container.

For example:

`/opt/appdata/sonarr:/config`

Means Sonarr sees `/config` internally, but the actual data is stored on the Debian host.

Recreating the container doesn't mean starting Sonarr's configuration from scratch.

The network setting attaches the container to my existing Docker network, `media-net`.

This allows the applications to communicate using their service names rather than hardcoded container IP addresses.

For example:

`http://sabnzbd:8080`

It's a different way of thinking compared with traditional virtual machines, but once it clicked, I started appreciating how straightforward it made deploying and managing applications.

## Radarr — Automating the Film Collection

Radarr handles films.

Its job is to monitor the titles I've added, find suitable releases through configured indexers, send download jobs to a client and import completed media into the correct library location.

The Docker image I'm using is:

`lscr.io/linuxserver/radarr:latest`

With the web interface on port `7878`.

Its volume configuration follows the same approach as Sonarr:

```yaml
volumes:
  - /opt/appdata/radarr:/config
  - /opt/local-ssd/downloads:/downloads
  - /mnt/qnap/media:/media
```

The interesting configuration, however, happens inside Radarr itself.

One of my goals was finding a sensible balance between picture quality and file size.

I want films to look good, but I don't necessarily want every release taking up 40GB or more.

My preference is generally for good-quality 1080p, ideally using HEVC/H.265 encoding where appropriate.

That brings us to quality profiles and custom formats.

These allow Radarr to evaluate releases against rules such as resolution, source quality, codec preferences and file-size limits.

I've been working towards a preference for files around 2.5GB or less, allowing something larger when the quality justifies it.

Another feature I particularly wanted was automatic upgrades.

If I've already got a decent copy of a film and a better release becomes available later, I'd like Radarr to replace it automatically, within the rules and upgrade cutoffs I've configured.

The exact quality-profile scores and upgrade cutoffs are configured inside Radarr rather than Docker Compose, so they're separate from the container deployment itself.

## Sonarr — Television Without the Manual Work

Sonarr takes the same general principle and applies it to television.

But television is slightly more complicated.

Rather than managing a single film, Sonarr needs to understand series, seasons, individual episodes, release schedules and whether content is missing.

The image I'm using is:

`lscr.io/linuxserver/sonarr:latest`

With the web interface on port `8989`.

Once a series is added and monitored, Sonarr can search configured indexers, submit suitable releases to SABnzbd and manage the resulting files.

The same quality philosophy applies here.

I generally favour efficient 1080p releases, and I want the option to upgrade an existing episode when something better becomes available.

The major benefit is not having to manually check whether a new episode has appeared.

Sonarr handles that monitoring.

And when it's configured correctly, completed episodes are imported into the television library without me needing to rename files or move them around.

Which is exactly the sort of laziness I can get behind.

Sorry, efficiency.

## SABnzbd — Enter Usenet

Before building this system, I'd heard of Usenet but had never actually used it.

One of the things that attracted me was the ability to use encrypted connections rather than relying on my old torrent-based workflow.

Let's just say a little more privacy sounded appealing.

Purely for educational purposes, obviously.

There is an important technical distinction here.

Usenet connections can use SSL/TLS encryption between the download client and provider, but that isn't the same thing as end-to-end encryption or complete anonymity.

Your ISP can still see a connection to the provider, but a properly configured encrypted connection prevents it from reading the content of that traffic.

I researched providers using Google and ChatGPT, comparing the options and learning about things like retention, reliability and completion rates.

Eventually, I settled on Newshosting.

For the actual download client, I chose SABnzbd.

Its Docker configuration is relatively straightforward:

```yaml
sabnzbd:
  image: lscr.io/linuxserver/sabnzbd:latest
  container_name: sabnzbd
  environment:
    - PUID=1000
    - PGID=1000
    - TZ=Europe/London
  volumes:
    - /opt/appdata/sabnzbd:/config
    - /opt/local-ssd/downloads:/downloads
  ports:
    - 8080:8080
  networks:
    - media-net
  restart: unless-stopped
```

SABnzbd receives download jobs from applications such as Sonarr and Radarr.

It handles the actual Usenet transfer, checks downloaded files, performs repairs where possible and extracts the resulting content.

The media-management application then takes responsibility for importing the completed files.

This separation of responsibilities is important.

SABnzbd doesn't decide which films I want or where everything ultimately belongs in the library.

Its responsibility is downloading and processing.

Radarr and Sonarr manage the content.

### Connecting the applications

Within Sonarr or Radarr, SABnzbd is added as a download client.

Because the applications share the Docker network, they can communicate using:

```text
Host: sabnzbd
Port: 8080
```

Authentication uses the SABnzbd API key, which isn't something I'd publish in a blog post.

Download categories allow different applications to manage their own jobs.

For example, a television category can distinguish Sonarr's downloads from Radarr's film downloads.

The precise category names need to match the configuration in both applications.

Once the job finishes, the relevant media manager receives the completion status through SABnzbd's API and can begin importing the files.

### Why keep downloads on the SSD?

One thing worth explaining is the split between temporary and permanent storage.

SABnzbd downloads onto the local SSD.

The finished library lives on the QNAP.

Because these are different filesystems, moving a completed file to the NAS involves transferring the data rather than simply renaming a local filesystem entry.

Hardlinks also cannot work across separate filesystems.

That's a trade-off in the design, but one I'm comfortable with.

It keeps temporary downloading and extraction activity local, while the QNAP provides the larger permanent library.

It does mean paying attention to free space on the SSD and making sure the NAS mount is available before imports take place.

## Lidarr — Music Is a Different Challenge

My music tastes aren't exactly limited to the latest chart releases.

I'm into house, tech house, techno, trance and underground dance music.

And sometimes finding particular tracks or mixes can be a bit of a challenge.

Lidarr was the obvious application to explore for managing artists, albums and music metadata.

But I quickly discovered that Usenet wasn't necessarily the answer to everything I wanted.

That's where things became a little more interesting.

Lidarr runs using this image in my setup:

`lscr.io/linuxserver/lidarr:nightly`

Notice that I'm using the **nightly** build.

That was an intentional choice linked to getting a third-party plugin working.

We discovered the `Lidarr.Plugin.Slskd` project, which allows Lidarr to integrate with slskd and the Soulseek network.

The plugin needed a compatible nightly build of Lidarr to provide the required plugin functionality.

So, naturally, we changed the Docker image and started experimenting.

## slskd — A Different Kind of Downloading

Soulseek isn't BitTorrent.

It's a separate peer-to-peer network, and slskd provides a client that can be controlled through a web interface and API.

The Lidarr plugin makes slskd available as both an indexer and a download client.

That means Lidarr can use it for searches and then submit selected transfers.

The relevant part of my Docker configuration looks like this:

```yaml
slskd:
  image: slskd/slskd:latest
  container_name: slskd
  network_mode: "service:gluetun"
  depends_on:
    - gluetun
  environment:
    - PUID=1000
    - PGID=1000
    - TZ=Europe/London
    - SLSKD_REMOTE_CONFIGURATION=true
  volumes:
    - /opt/appdata/slskd:/app
    - /opt/local-ssd/downloads/soulseek:/downloads/soulseek
    - /mnt/qnap/media/music:/music:ro
  restart: unless-stopped
```

Again, the persistent configuration is stored separately from the container.

Downloaded music is written to the local SSD under the Soulseek download directory.

Lidarr also has access to the host's download directory, allowing it to work with the completed files and import them into the music library.

Getting the plugin and the applications talking to each other took some fiddling, along with a fair amount of assistance from ChatGPT.

But eventually, it worked.

The slightly amusing part is that although I've got the music automation working, I haven't really started using it routinely yet.

Sometimes the satisfaction comes from proving you can build something.

Actually using it is apparently a separate project.

## The VPN God Meets Docker Networking

Of course, running peer-to-peer traffic introduced another consideration.

I wanted the slskd container to use an encrypted VPN connection rather than sending its traffic directly over my home internet connection.

Fortunately, the VPN service bundled with my Usenet subscription gave me something to work with.

And this was finally an area where I felt comfortable.

VPNs, routing, firewalls and network isolation are things I've dealt with for years.

The challenge wasn't designing what I wanted.

It was translating that design into Docker Compose.

Enter Gluetun.

Gluetun is a container that establishes a VPN connection and provides network and firewall functionality for applications sharing its network stack.

I'm using WireGuard.

Here's a shortened extract from my configuration:

```yaml
gluetun:
  image: qmcgaw/gluetun:latest
  container_name: gluetun
  cap_add:
    - NET_ADMIN
  devices:
    - /dev/net/tun:/dev/net/tun
  environment:
    - VPN_SERVICE_PROVIDER=custom
    - VPN_TYPE=wireguard
    - WIREGUARD_CONF_SECRETFILE=/gluetun/wireguard/wg0.conf
    - TZ=Europe/London
  volumes:
    - /opt/appdata/gluetun:/gluetun
  networks:
    - media-net
  restart: unless-stopped
```

I've omitted the published web-interface port and all connection credentials from this example.

The WireGuard configuration is stored separately and referenced using the `WIREGUARD_CONF_SECRETFILE` setting.

The important part of the design is actually in the slskd configuration:

```yaml
network_mode: "service:gluetun"
```

This tells Docker that slskd should share Gluetun's network namespace.

Instead of having its own independent Docker network interfaces and routes, slskd uses Gluetun's.

Gluetun is then responsible for establishing the VPN tunnel and applying its firewall rules.

The intended behaviour is that traffic uses the VPN, and if the tunnel becomes unavailable, the firewall prevents an unintended fallback to the normal internet connection.

We did perform connectivity testing during the build, although I can't now remember every command we used.

For a properly documented security test, I'd want to verify the external IP address, permitted network routes and behaviour during a simulated tunnel failure.

There's an important lesson here: just because a VPN container reports that it's running doesn't necessarily mean you've verified every aspect of your network security.

And a dedicated Docker network by itself isn't a guarantee of isolation.

In my actual Compose file, Gluetun uses the existing `media-net` network, with its firewall and network namespace providing the VPN traffic controls.

It's a good example of taking familiar networking principles and learning how they apply in a containerised environment.

## The Container I Thought I'd Installed

Here's something slightly embarrassing.

When revisiting the configuration for this article, I was convinced we'd installed qBittorrent to handle the specialist music downloads.

It made sense in my head.

I'd used qBittorrent previously, I knew there was a peer-to-peer component, and I remembered configuring the VPN.

Except when we actually examined the Docker Compose file, there was no qBittorrent service.

So I checked Docker itself.

```bash
docker ps -a --format '{{.Names}}' | grep -i qbittorrent
```

Nothing.

Not a single matching container.

The working integration was slskd, not qBittorrent.

Which brings me back to something I said earlier about working with AI.

**Getting something working and understanding exactly what you've built aren't always the same thing.**

The system was doing what I wanted, but revisiting the configuration helped me properly understand the components involved.

That's the sort of lesson you don't necessarily learn from simply copying a tutorial.

And it's a pretty good reason to document your own projects.

## LazyLibrarian — Not Just Films and Music

The automation layer also includes LazyLibrarian.

This extends the concept into books and other reading material.

My container uses:

`lscr.io/linuxserver/lazylibrarian:latest`

With its web interface on port `5299`.

Like the other applications, it has persistent configuration storage and access to both the download directory and the NAS library.

```yaml
volumes:
  - /opt/appdata/lazylibrarian:/config
  - /opt/local-ssd/downloads:/downloads
  - /mnt/qnap/media:/media
```

It provides tools for managing authors, books and associated metadata, along with supported search and download integrations.

It's another example of how the media stack has gradually expanded beyond the original idea of simply watching films and television.

I won't pretend I've explored every feature of LazyLibrarian yet. It's part of the deployed environment, but it doesn't currently feature as heavily in my everyday workflow as the film and television automation.

And that's fine.

It's there to develop further when I decide what I want from it.

## From a Request to Jellyfin

So what does all this achieve?

For me, the entire process now starts with Seerr.

That's my media request interface.

I mainly use it myself, although a small number of friends can submit requests for me to approve.

I don't particularly want to give everyone access to the underlying administration interfaces.

After all, it's my NAS, my storage and my electricity bill.

For a typical film request, the process looks something like this:

1. I search for a film in Seerr and submit the request.
2. Seerr passes the request to Radarr once it's approved.
3. Radarr checks its monitored titles, quality rules and configured indexers.
4. When a suitable release is available, Radarr submits the job to SABnzbd.
5. SABnzbd downloads and processes the files on the local SSD.
6. Radarr imports the completed film into the library on the QNAP.
7. Jellyfin discovers the new media through its library scanning process.

Television follows a similar process through Sonarr.

Prowlarr helps manage the indexer connections, while the other applications handle their own parts of the workflow.

For me, it's now largely hands-off once the request has been approved.

I don't have to spend an evening managing filenames or moving folders.

And the first time I watched a film appear in my Jellyfin library after all that automation had worked?

That was a genuinely proud moment.

It might sound fairly ordinary to someone who's been using these tools for years.

But for someone who'd gone from knowing virtually nothing about the Docker media ecosystem to having all these services communicating, it was a big achievement.

## What I'd Still Like to Improve

Is the system perfect?

Of course not.

One thing I'd particularly like to introduce is better monitoring.

At work, I'm used to having visibility of infrastructure, alerts when things fail and systems telling me when something needs attention.

At home, I've built an increasingly complicated collection of containers and I'm largely trusting that they're doing what they're supposed to.

I'd like to introduce proper health monitoring, notifications and better visibility of resource usage.

But that can be a project for another day.

I've also learned that automation doesn't remove the need to understand what you're running.

Containers still need updating.

Permissions can still cause problems.

NAS mounts can become unavailable.

And a badly formatted YAML file can still ruin your evening.

## What I've Learned So Far

The biggest lesson from this part of the project hasn't really been about Sonarr, Radarr or SABnzbd.

It's been about learning a new approach to infrastructure.

After years of working with Windows servers and traditional virtualisation, Docker has given me an entirely different way of deploying and managing applications.

And using AI throughout the process has changed how I've approached learning.

I've been able to experiment with unfamiliar technologies, get assistance when something doesn't work and then go back and understand the configuration.

Sometimes I've learned the theory first.

Sometimes I've made it work first and learned the theory afterwards.

And occasionally I've discovered that I didn't even install the application I thought I had.

But that's all part of the journey.

What started as a little mini-PC in the garage has grown into a system that can manage films, television, music and books, with different applications handling the individual tasks.

And, most importantly, it largely removes the manual work that made my old media setup such a chore.

It's still evolving, and I've still got plenty to learn.

But I think I'm finally beginning to understand this Docker malarkey.

Well, until the next YAML indentation error.

---

*Next in Building My Media Stack: We'll look at post-processing, library organisation and how everything eventually makes its way into Jellyfin.*

### Technical references

- [Docker Compose documentation](https://docs.docker.com/compose/?ref=lifeinproduction.co.uk)
- [LinuxServer.io container documentation](https://docs.linuxserver.io/?ref=lifeinproduction.co.uk)
- [Lidarr slskd plugin](https://github.com/allquiet-hub/Lidarr.Plugin.Slskd?ref=lifeinproduction.co.uk)
- [Gluetun documentation](https://github.com/qdm12/gluetun-wiki?ref=lifeinproduction.co.uk)
- [SABnzbd documentation](https://sabnzbd.org/wiki/?ref=lifeinproduction.co.uk)