Plex Homelab Architecture: Storage, GPU Transcoding, and Library Design

A beginner-friendly but technical architecture guide for building a Plex, Sonarr, Radarr, SABnzbd, Prowlarr, and Tdarr homelab that is fast, recoverable, and easy to operate.

Rights and lawful use: Apply this architecture only to a library you are entitled to store, organize, back up, and transcode. A technically functional acquisition or processing path does not create permission to copy, bypass controls, share, or retain protected media.

Who this is for: Use this guide if you need to decide where Plex, Arr applications, downloads, transcode work, configuration databases, and media storage should live before installing them. It explains the beginner path while preserving the ownership and failure-domain detail an experienced builder needs.

Why Architecture Matters Before App Settings

Most Plex homelabs start with one app and one folder. That works until the library grows, multiple users start streaming, downloads happen during playback, and background transcoding begins competing with Plex for GPU time. At that point, the problem is rarely a single bad checkbox. The problem is architecture. A stable Plex and Arr environment needs a clear separation between media storage, application configuration, download staging, transcode cache, GPU work, reverse proxy access, and backups.

The beginner version is simple: Plex should serve clean final media folders, Sonarr and Radarr should organize media, Prowlarr should centralize indexers, SABnzbd should download into staging folders, and Tdarr should optimize completed media after import. The technical version adds a few rules: consistent paths, predictable Linux permissions, local cache for heavy temporary writes, scheduled GPU workers, safe remote access, and configuration backups stored away from the host.

Series note: This is the foundation article for the Plex and Arr homelab series. The later Sonarr, Radarr, Prowlarr, SABnzbd, storage, GPU, reverse proxy, backup, and monitoring guides all build on this architecture.

The Core Components

• Plex Media Server is the playback layer. It should read final media folders and avoid heavy background work during peak viewing.
• Sonarr is the TV authority. It tracks series, episodes, monitoring, quality profiles, imports, and upgrades.
• Radarr is the movie authority. It tracks movies, root folders, custom formats, lists, imports, and upgrades.
• Prowlarr is the indexer manager. It keeps Usenet and torrent indexers consistent across Sonarr and Radarr.
• SABnzbd is the download worker. It should use local incomplete storage when possible and leave final organization to Sonarr and Radarr.
• Tdarr is the post-processing engine. It should process final imported media, not incomplete downloads, and it should notify Plex and the Arr apps after replacements.

A Clean Data Flow

1. A movie, episode, or list item is added to Radarr or Sonarr.
2. Radarr or Sonarr searches indexers that Prowlarr manages.
3. A selected release is sent to SABnzbd using the correct category.
4. SABnzbd downloads, repairs, and unpacks into a download staging folder.
5. Radarr or Sonarr imports the completed file into the final media root.
6. Plex scans the final media library and exposes the title for playback.
7. Tdarr waits for the file to settle, then transcodes or skips it according to policy.
8. Tdarr validates the output before replacement.
9. Tdarr refreshes Plex and triggers a Radarr or Sonarr rescan so metadata, codec, size, and MediaInfo stay current.

1. 1. RequestManual Add / List

   A wanted movie or episode is added to Radarr or Sonarr by a person, request app, or curated list.

2. 2. SearchProwlarr Sources

   Radarr or Sonarr queries synced sources and receives candidates that still must pass app rules.

3. 3. ScoreArr Decision

   Quality profile, custom formats, language, cutoff, and rejection rules decide whether the candidate is acceptable.

4. 4. DownloadSAB Category

   Accepted jobs download into the movies or TV category, not directly into the final Plex root.

5. 5. ImportRadarr / Sonarr

   The Arr app imports, renames, tracks the file, and updates its database as the system of record.

6. 6. OptimizeTdarr

   Tdarr may later transcode or skip the imported file, then validates output before replacement.

7. 7. RefreshPlex + Arr Rescan

   Plex refreshes playback metadata; Radarr/Sonarr rescan file size, codec, audio, and MediaInfo.

Rights gateUse these workflows only for media you own or are authorized to store, download, organize, or transcode.

System of recordRadarr and Sonarr own library state. Tdarr should update them after replacements, not silently drift away.

The Folder Model

The cleanest setup uses one shared top-level data path that every media app understands. That does not mean every file lives on one physical disk. It means the applications see the same logical layout. This prevents the classic problem where SAB reports one path, Radarr sees another path, and imports fail because both applications are technically correct but not speaking the same filesystem language.

/data
  /downloads
    /usenet
      /movies
      /tv
    /torrents
      /movies
      /tv
  /media
    /movies
    /movies-animated
    /movies-comedy
    /tv
  /transcode
    /plex
    /tdarr

For a beginner, the rule is: downloads are temporary, media folders are final. For a technical user, the rule is: avoid cross-filesystem moves when you want hardlinks or atomic imports, avoid network storage for high-churn temporary writes, and make sure every application sees paths consistently.

Local Disk vs NAS Storage

NAS storage is excellent for the final library because it centralizes capacity, snapshots, and resilience. Local SSD or NVMe storage is better for incomplete downloads, repairs, unpacking, Plex transcode cache, and Tdarr cache. These are write-heavy workloads. Running them across CIFS or NFS can work, but it adds latency and creates more chances for stale locks, permission mismatches, and slow repair or unpack stages.

• Best on NAS: final movies, final TV, completed library backups, exported configs, and long-term logs.
• Best on local disk: incomplete downloads, SAB repair/unpack work, Plex transcode cache, Tdarr transcode cache, temporary scripts, and test outputs.
• Depends: completed downloads. If Radarr/Sonarr import across the same filesystem, completed downloads can live near the library. If your NAS is slower, keep incomplete local and completed/imported final on NAS.

GPU Strategy at the Architecture Level

Plex and Tdarr can both use the GPU, but they should not be allowed to fight for it blindly. Plex is interactive. A user feels it immediately when a stream buffers. Tdarr is batch work. A transcode job can wait. The architecture should therefore reserve GPU capacity for Plex during peak viewing and let Tdarr run harder during off-peak windows.

Plex documentation notes that hardware-accelerated streaming depends on platform, hardware, driver support, and sometimes subscription features. NVIDIA systems also have hardware and driver-related encoding limits. That is why the operational design matters: verify the NVIDIA driver after kernel updates, verify nvidia-patch if you use it, and keep Tdarr worker counts lower during household viewing hours.

Library Design

A Plex library should represent how people actually browse. Do not create ten libraries just because folders exist. Also do not cram every category into one folder if you know the collection has different rules. Movies, TV, animated movies, stand-up comedy, and family content can be separate if that improves browsing, permissions, or automation. They should be separate because the user experience is better, not because the filesystem got messy.

• Movies: general films managed by Radarr.
• Animated Movies: a separate Radarr root if you want a dedicated Plex library or family-friendly destination.
• Comedy: a separate Radarr root when stand-up specials are browsed differently from normal movies.
• TV: series managed by Sonarr.
• Test Library: optional, useful for testing Tdarr flows before production.

Configuration Ownership

Every app should own its own configuration and database, and those folders should be backed up. The final media library is usually too large to back up in full for many homelabs, but the application configs are small and critical. If you lose a server but keep configs, compose files, service definitions, and media paths, rebuilding is realistic. If you lose configs, you may spend days re-creating indexers, tags, quality profiles, list settings, API integrations, and watched metadata.

Security Boundaries

Plex remote access is different from exposing every admin app. Plex is designed for remote playback. Sonarr, Radarr, Prowlarr, SABnzbd, Tdarr, and Nginx Proxy Manager are administrative tools. Treat them as private management surfaces. If you reverse proxy them, use HTTPS, strong authentication, access lists, VPN, or identity-aware controls. Do not put every media admin interface directly on the public internet just because it has a login page.

Beginner Build Checklist

• Choose one host or a clear two-host role split.
• Decide which folders live on NAS and which live on local SSD/NVMe.
• Create one consistent media path layout.
• Use a shared media group and cooperative permissions.
• Install Plex, Sonarr, Radarr, Prowlarr, SABnzbd, and Tdarr with persistent config directories.
• Connect Prowlarr to Sonarr and Radarr.
• Connect Sonarr/Radarr to SABnzbd categories.
• Connect Plex libraries to final media folders.
• Point Tdarr at final media folders only.
• Back up every application config before enabling heavy automation.

Technical Validation Checklist

• A completed TV download imports without remote path mapping confusion.
• A completed movie download imports into the intended Radarr root folder.
• Plex can read imported files without permission fixes.
• Tdarr can read, transcode, validate, and replace files without permission fixes.
• Radarr and Sonarr update MediaInfo after Tdarr replaces a file.
• Plex hardware transcoding works and shows GPU use during a real transcode.
• Tdarr worker limits protect Plex during peak hours.
• All config folders are included in a NAS-hosted backup set.
• Reverse proxy exposure is limited to apps that truly need remote access.

Beginner Walk-Through: What Happens When You Add a Movie

Imagine you add a movie to Radarr. Radarr does not download the movie itself. It checks indexers that came from Prowlarr, chooses a release based on your quality profile and custom formats, and sends the job to SABnzbd. SABnzbd downloads into a temporary area. When the job is complete, Radarr imports the file into the final movie folder. Plex sees the final file and adds it to the library. Later, Tdarr checks whether the file matches your codec, audio, subtitle, and size policy. If it does not, Tdarr creates a new optimized file, validates it, replaces the original, refreshes Plex, and tells Radarr to rescan.

That chain is why the architecture matters. If SAB writes directly into the movie library, Radarr loses control. If Tdarr processes incomplete files, it can transcode something still being unpacked. If Plex scans before the file is stable, users may see broken items. If Radarr never rescans after Tdarr replaces the file, Radarr makes future upgrade decisions using stale file details.

Technical Design Decisions to Document

• Which host runs Plex and whether it has the primary GPU.
• Which host runs Tdarr Server and which hosts run Tdarr Nodes.
• Which storage paths are local and which are NAS mounted.
• Which app owns each root folder.
• Which ports are LAN-only and which are behind a proxy.
• Which files are included in backups and where those backups live.
• Which GPU worker limits apply during peak and off-peak hours.

A simple diagram or README file in your backup folder is enough. The important part is that future-you can rebuild the stack without reverse-engineering every decision from memory.

Implementation Playbook: Build the Stack in the Right Order

Why this section matters: Most failed media stacks are not failed because Plex, Sonarr, or Radarr are bad apps. They fail because they were installed in a random order, with paths and permissions decided after the fact. Build the foundation first, then add automation.

Ubuntu Host Baseline

Start by preparing the Ubuntu host before installing media applications. This makes the rest of the series easier to follow because every later app can use the same users, groups, paths, and update habits.

sudo apt update
sudo apt install -y curl ca-certificates gnupg lsb-release acl unzip jq
sudo groupadd -f media
sudo mkdir -p /data/{downloads,media,cache}
sudo mkdir -p /data/downloads/{incomplete,usenet,torrents}
sudo mkdir -p /data/downloads/usenet/{movies,tv}
sudo mkdir -p /data/media/{movies,tv,movies-animated,movies-comedy}
sudo mkdir -p /data/cache/{plex,tdarr,sabnzbd}
sudo chgrp -R media /data
sudo chmod -R 2775 /data

The leading 2 in mode 2775 sets the set-group-ID (setgid) bit on directories, which makes new children inherit the directory's media group. It is not the sticky bit. Setgid does not replace correct user IDs, group membership, access control lists, or application umask settings, but it gives shared paths a predictable group default.

Docker Host Baseline

If you want the stack to be Docker-first, install Docker Engine and Compose, then keep the media stack in one compose directory. The goal is not to make every container privileged or magical. The goal is to make container paths boring and predictable.

sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
  -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

sudo tee /etc/apt/sources.list.d/docker.sources >/dev/null <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF

sudo apt update
sudo apt install -y \
  docker-ce \
  docker-ce-cli \
  containerd.io \
  docker-buildx-plugin \
  docker-compose-plugin

sudo usermod -aG docker "$USER"
sudo install -d -o "$USER" -g media -m 2775 /opt/media-stack

This repository block follows Docker's documented Ubuntu installation pattern as fact-checked on July 15, 2026. Docker's supported Ubuntu releases and package versions change, so reopen the official install page before running it. Log out and back in before using the new group membership. Membership in the docker group is effectively root-level access to the host; add only trusted administrators.

Recommended Install Order

1. Prepare storage and permissions first.
2. Install Plex and verify it can read the final media roots.
3. Install Prowlarr and add/test indexers.
4. Install SABnzbd and test download folders.
5. Install Sonarr and Radarr and verify one controlled import each.
6. Install Tdarr and test one controlled transcode in a test library.
7. Add custom formats and list integrations only after manual imports work.
8. Add reverse proxy, backups, and monitoring after the internal workflow is stable.

Definition of Done

• A movie can be added in Radarr, downloaded by SABnzbd, imported into the movie root, scanned by Plex, processed or skipped by Tdarr, and rescanned by Radarr.
• A TV episode can follow the same path through Sonarr.
• No step requires manual permission fixes.
• No app writes incomplete downloads into a Plex library.
• All application config folders are backed up to storage outside the host.

What This Does Not Prove

This architecture is documentation-backed. Correct paths and one successful import do not prove GPU capacity, NAS throughput, sustained import speed, power use, stream concurrency, transcode quality, or recovery time. No TechGeeks measurements for those claims are reported here. Measure them with your codecs, clients, subtitles, network, storage, and failure cases before buying hardware or setting production limits. Plex Pass requirements, supported hardware acceleration, container images, application settings, and Ubuntu/Docker support are version-sensitive.

Keep application control planes LAN-only or VPN-only, restrict configuration backups because they contain tokens and provider settings, and test restoration of a disposable app database before broad automation. A redundant array or filesystem snapshot is not an independent backup. Preserve a known-good container image or package version plus the pre-update configuration; if a database migration prevents downgrade, stop the service and restore the matched backup rather than forcing an older binary onto new data.

Series Navigation

This architecture article establishes the storage, path, permission, GPU, and configuration boundaries used by the rest of the Plex, Arr, and Tdarr series. Follow the linked component guides only after these shared decisions are documented, because later application tuning assumes the underlying ownership model is stable.

• Plex Homelab Architecture: Storage, GPU Transcoding, and Library Design
• Media Server Storage Design: NAS, CIFS/NFS Mounts, Permissions, and Local Cache
• Prowlarr Setup Guide: Clean Indexer Management for Sonarr and Radarr
• Sonarr Homelab Setup Guide: Install, Update, Optimize, and Connect to Tdarr
• Radarr Homelab Setup Guide: Install, Update, Optimize, Lists, and Tdarr Integration
• SABnzbd Performance Tuning for a Homelab Media Server
• Custom Formats and Quality Profiles Explained for Radarr and Sonarr
• Radarr Import Lists That Do Not Fill Your Library With Junk
• Plex + Tdarr GPU Strategy: Sharing NVIDIA GPUs Without Hurting Playback
• Reverse Proxy for Media Apps: Nginx Proxy Manager, SSL, Access Lists, and Security
• Backup and Disaster Recovery for Plex, Sonarr, Radarr, Tdarr, Prowlarr, and SABnzbd
• Monitoring and Health Checks for a Plex and Arr Homelab
• The Complete Plex, Arr, and Tdarr Homelab Media Automation Series

Related foundation: Building a Production-Grade Tdarr GPU Transcoding Stack for a Homelab.

References

• Plex hardware-accelerated streaming
• Plex library settings
• Docker Engine installation on Ubuntu
• Servarr Docker Guide
• Tdarr Docker Compose documentation
• Production-grade Tdarr GPU transcoding stack