Self-Hosted Media and Homelab 2026 — Jellyfin / Immich / Navidrome / Audiobookshelf / arr Stack / Tdarr Deep Dive

Prologue — The 2025 Crack, the 2026 Reshuffle

In spring 2025, Plex announced a price hike and a paywall on remote streaming on the same day. The question "why am I paying to watch my own content on my own server from my own phone?" carpeted r/selfhosted and r/Plex for a week, and the next week the Jellyfin wiki and GitHub issue tracker exploded with traffic. The community started calling it the "Plex Exodus."

By lucky timing, Jellyfin had just stabilized its 10.10 release. AV1 decode, Intel Arc / N100 iGPU hardware transcoding, HDR tone mapping, Trickplay thumbnails — most of what Plex had been holding behind its paid tier started working for free in the open-source camp.

This piece maps the self-hosted media homelab as it settled by May 2026 after that crack. Video (Jellyfin/Plex/Emby), photos (Immich/Photoprism), music (Navidrome), audiobooks (AudioBookshelf), comics and ebooks (Komga/Kavita), automation (the arr stack), transcoding (Tdarr/Unmanic/FileFlows), and the hardware and remote-access layer that holds it all up.

By the end you should know how far a single N100 mini PC can go, how far one NAS can carry a whole family's media stack, and that the cost lands well below a year of Netflix.

1. The 2026 Self-Hosted Map — Life After the Plex Affair

As of May 2026, the self-hosted media stack roughly arranges itself like this.

One change jumps off that table. Almost every core piece of 2026 self-hosted media has landed under a strong open-source license — GPL, AGPL, or MIT. While Plex slid from free toward partial paywall, the open-source side moved the other way and caught up or passed Plex on the things Plex used to be uniquely good at.

The minimal 2026 homelab

The baseline for "I want a family media stack without dedicating a room to it" usually looks like:

• N100 or N305 mini PC, 16 GB RAM, 1 TB NVMe + external 8 TB HDD
• Proxmox VE or Ubuntu 24.04 with Docker Compose
• Jellyfin + Immich + Navidrome + AudioBookshelf + the five arr tools + qBittorrent + Tdarr
• Gluetun container isolating VPN traffic (Mullvad or ProtonVPN)
• Tailscale and optionally Cloudflare Tunnel for remote access
• Borg/Restic daily backups to an external disk and a weekly remote sync to B2/R2

Total hardware bill around USD 350 to 450 plus disks. Electricity for an N100 averages 8 to 12 W — a couple of dollars a month. Cheaper than the combined cost of Netflix, Disney+, Apple Music, and Audible inside a year.

2. Jellyfin 10.10 — Solid Transcoding At Last

For years Jellyfin earned the same complaint. "On paper it does everything Plex does. In practice transcoding breaks." The 10.9 / 10.10 series in 2024 to 2025 finally moved that needle.

What 10.10 brought

• Intel QSV (Quick Sync) overhaul. AV1 and HEVC decode on N100, N305, and Arc A380 are stable. One N100 can sustain six to eight simultaneous 1080p H.264 transcodes.
• Better HDR-to-SDR tone mapping. Dolby Vision Profile 7 BL+EL and HDR10+ come down to SDR consistently. NVIDIA, Intel, and AMD acceleration all work.
• Trickplay thumbnails. The hover-on-timeline preview Plex had been showing off forever.
• Backdrops and multi-color themes. Series art behind the library view. The visual gap to Plex shrank.
• SyncPlay stability. Watch-together-with-friends sessions no longer drop.
• Mobile clients. Findroid for Android and Swiftfin for iOS fill the gap until the official mobile apps catch up.

Bring it up with one Compose file

# docker-compose.yml
services:
  jellyfin:
    image: jellyfin/jellyfin:10.10.4
    container_name: jellyfin
    user: '1000:1000'
    network_mode: host
    volumes:
      - ./config:/config
      - ./cache:/cache
      - /mnt/media/movies:/media/movies:ro
      - /mnt/media/tv:/media/tv:ro
      - /mnt/media/music:/media/music:ro
    devices:
      - /dev/dri:/dev/dri # Intel QSV / AMD VAAPI
    restart: unless-stopped
    environment:
      - JELLYFIN_PublishedServerUrl=https://jellyfin.example.com

Passing /dev/dri to the container is the single line that turns on N100, Arc, and iGPU transcoding. Host networking is there so DLNA discovery works.

Does the N100 really sustain N parallel transcodes?

Benchmark in one breath. Direct-play 1080p H.264 with AAC: unlimited. 4K HEVC HDR transcoded to 1080p H.264 SDR: about 1.5 to 2 concurrent on an N100. Add an Arc A380 (around USD 100) and you jump to six to eight concurrent. 4K Dolby Vision Profile 7 is still finicky — keep client-side direct play in mind for those titles.

Where Jellyfin still trails

• Official mobile UI still rougher than Plex. Findroid and Swiftfin help.
• Metadata matching is fine for TMDB / TVDB but gets noisy on Korean and Japanese content. AniDB plugins or custom matchers are usually needed.
• Live TV works but is not at Plex's level.
• Parental controls and policies are present but not as deep as Plex's policy engine.

Switching from Plex to Jellyfin — checklist

• Mount the same library folders rather than moving files.
• Normalize filenames to the TRaSH-Guides format.
• Expect a slow first pass while TMDB / TVDB metadata is re-fetched.
• Recreate user accounts; watch history can move via a tool like jellyfin-plex-watched-sync.
• Let Bazarr refetch subtitles in bulk rather than migrating them.

3. The Plex 2025 Affair — What Changed

In April 2025 Plex announced two things at once.

1. A Plex Pass price increase. Monthly, yearly, and lifetime all went up 30 to 50 percent.
2. A remote-streaming paywall. Watching your own server from outside your network — previously free — was gated behind Plex Pass or the new Remote Watch Pass.

The second one was the lightning rod. The whole identity of a self-hosted media server is "my data, my device, anywhere." Putting a gate on the "anywhere" part hit a nerve. The most-quoted comment on r/selfhosted was something like:

My internet, my electricity, my disks, my files. And to watch them from outside I have to pay Plex? Then maybe Plex was never the right answer.

What Plex still does well

To be fair, Plex still wins on several fronts.

• Official mobile and TV apps. Apple TV, Roku, Fire TV, Tizen, webOS, PlayStation, Xbox — the widest official client matrix.
• DVR and live TV. An antenna plus HDHomeRun is still smoothest on Plex.
• Plex Watch Together and Discover. Social features Jellyfin does not really have.
• Metadata matching across languages. Korean and Japanese content match more cleanly out of the box.

Stay on Plex if

• A family member already lives inside the Apple TV / Roku Plex client and will not climb a Jellyfin learning curve.
• You already own a Lifetime Plex Pass.
• DVR and live TV matter.
• Your library is Korean-heavy and bad metadata stings.

Leave Plex if

• Remote streaming is core and you do not want to keep paying for it.
• License control and data sovereignty matter on their own.
• You want first-class N100 / Arc hardware acceleration.
• Your clients are web, mobile, and Android TV anyway.

Where Emby sits

Emby is wedged between Plex and Jellyfin. Its core is partly open source, with key features behind the Emby Premiere subscription. By 2026 its momentum has clearly faded, and new open-source contributions flow almost entirely to Jellyfin. People with smoothly running Emby servers stay; new homelabs rarely start there.

4. Immich — The Google Photos Answer

Photos are a different category from video. The volume of data added daily, the urgency of backup, the family-wide sharing, and — especially after the end of free Google Photos — the appetite for a serious alternative all exploded together. By 2026, Immich effectively owns that seat.

What Immich does well

• First-class iOS and Android apps. Auto-upload, background sync, original-quality retention, lock-screen widgets.
• Face recognition and ML. People, places, objects auto-tagged. CLIP-embedding semantic search ("sunset over the ocean" returns the right shots).
• EXIF preserved with a map view. Capture coordinates intact. Travel timelines.
• Shared albums and external libraries. Family albums; existing NAS photo trees mounted as external libraries.
• Speed. Postgres + Redis backbone. Fifty-thousand-photo libraries scroll smoothly.

A Compose excerpt

services:
  immich-server:
    image: ghcr.io/immich-app/immich-server:release
    container_name: immich_server
    volumes:
      - /mnt/photos:/usr/src/app/upload
      - /etc/localtime:/etc/localtime:ro
    env_file: .env
    depends_on:
      - redis
      - database
    ports:
      - '2283:2283'
    restart: always

  immich-machine-learning:
    image: ghcr.io/immich-app/immich-machine-learning:release
    container_name: immich_ml
    volumes:
      - ./model-cache:/cache
    env_file: .env
    restart: always

  redis:
    image: redis:7-alpine
    container_name: immich_redis
    restart: always

  database:
    image: ghcr.io/immich-app/postgres:14-vectorchord0.3.0-pgvectors0.2.0
    container_name: immich_postgres
    env_file: .env
    volumes:
      - ./postgres:/var/lib/postgresql/data
    restart: always

Postgres ships with pgvector / vectorchord extensions. That is what powers cosine-similarity searches over CLIP embeddings.

Operational traps

• First boot pulls multi-gigabyte ML models. Mount the model-cache volume so restarts do not re-download.
• Backup is on you. Immich is neither RAID nor backup. Both the library and the Postgres database must be backed up to recover.
• Face recognition runs on CPU but is 30 to 50x faster with a GPU. N100 plus 10k photos takes days; a discrete GPU takes hours.
• Do not mix external (read-only) and upload (read-write) libraries. A misconfigured write can corrupt EXIF.

Immich vs Photoprism vs PhotoStructure

Photoprism still appeals if you want to treat your photos as a catalog and run mobile auto-backup with a different tool. PhotoStructure is good at merging multiple libraries but its 2026 momentum is low.

5. Navidrome and AudioBookshelf — Music and Audiobooks

Navidrome

A Subsonic-API-compatible music server. Lays a Spotify-style UX over your own library.

• Subsonic compatibility — dozens of clients (Substreamer, play:Sub, Symfonium, Sublime Music, DSub) work out of the box.
• Great metadata — pairs cleanly with libraries already groomed in MusicBrainz Picard.
• Smart playlists — rule-driven auto-playlists.
• Last.fm / ListenBrainz scrobbling — back up your listening history.
• 2026 updates — Last.fm / ListenBrainz import, better transcoding, notification system.

services:
  navidrome:
    image: deluan/navidrome:latest
    user: 1000:1000
    ports:
      - '4533:4533'
    environment:
      ND_LOGLEVEL: info
      ND_SESSIONTIMEOUT: 24h
      ND_BASEURL: ''
      ND_SCANSCHEDULE: '@every 6h'
      ND_LASTFM_ENABLED: 'true'
    volumes:
      - ./data:/data
      - /mnt/music:/music:ro
    restart: unless-stopped

Artist/Album/01 - Track.flac is the safest tree layout. Normalize metadata in MusicBrainz Picard once and Navidrome will love you.

AudioBookshelf

An audiobook plus podcast server. The thing Plexamp does not do well.

• M4B / MP3 / FLAC audiobooks with automatic chapterization.
• Podcast subscriptions and downloads.
• Bookmarks, progress sync, sleep timer.
• Official iOS and Android apps.
• Metadata matching — Audible / Google Books / Audnexus.

Audiobook files are big — 1 to 2 GB per title is common. Keep them on a separate NAS path and mount read-only.

services:
  audiobookshelf:
    image: ghcr.io/advplyr/audiobookshelf:latest
    ports:
      - '13378:80'
    volumes:
      - /mnt/audiobooks:/audiobooks
      - /mnt/podcasts:/podcasts
      - ./config:/config
      - ./metadata:/metadata
    environment:
      - TZ=Asia/Seoul
    restart: unless-stopped

Where Plexamp and Subsonic fit

Plexamp is still a top-tier experience for Plex users. The 2026 consensus is that Navidrome plus a polished Subsonic client has largely caught up.

6. Komga and Kavita — Comics and Ebooks

Two strong contenders almost evenly split the comic and ebook self-hosting share.

Komga

• Comics specialist — CBZ / CBR / PDF / EPUB.
• OPDS support — external readers (Panels, Chunky, Paperback) work.
• Series metadata — ComicVine, Mylar3, GCD.
• Read-progress sync.
• Per-user and per-book access control.

Kavita

• Comics + ebooks + manga in one app. Komga is comic-first; Kavita stretches across comics, ebooks, and study material.
• OPDS support.
• Read-progress sync.
• Multiple libraries with a rich permission model.
• Mobile-friendly web reader.

Picking criteria are simple. Comic-heavy library: Komga. Mixed comics, ebooks, and magazines: Kavita. Plenty of people run both and split libraries by content type.

services:
  komga:
    image: gotson/komga:latest
    ports:
      - '25600:25600'
    volumes:
      - ./config:/config
      - /mnt/comics:/data
    environment:
      - TZ=Asia/Seoul
    restart: unless-stopped

  kavita:
    image: jvmilazz0/kavita:latest
    ports:
      - '5000:5000'
    volumes:
      - ./kavita-config:/kavita/config
      - /mnt/books:/books
    environment:
      - TZ=Asia/Seoul
    restart: unless-stopped

Ebook conversion and cleanup

File format matters for a comic and book library. A lot of people run Calibre on the side to normalize EPUB, clean metadata, and tidy cover art. Add Calibre-Web on top for a slick web OPDS experience.

7. The arr Stack — Sonarr / Radarr / Lidarr / Readarr / Prowlarr / Bazarr

The arr stack is still the spine of media automation in 2026 — same shape, sturdier in the joints.

Role split

The flow in one picture

Request system or wishlist seeds an entry → arr tool searches via Prowlarr-managed indexers → download client (qBittorrent / SABnzbd) gets the job → upon completion files move to the import path with normalized names → library refresh → Bazarr fetches subtitles → Jellyfin or Plex reloads metadata.

What Prowlarr changed

The old way: configure indexers separately in Sonarr, Radarr, Lidarr, and so on. Prowlarr collapses that into a single hub. Add an indexer once and every arr picks it up automatically. Passwords, cookies, and RSS URLs all live in one place.

Bazarr — the subtitle endgame

Bazarr mirrors the Sonarr / Radarr library and pulls subtitles from OpenSubtitles, Subscene, Addic7ed, Subdivx, and others automatically. Language priorities (for example Korean, then English, then Japanese), score thresholds, forced-subtitle handling, sync corrections — it manages all of that. Practically a requirement for multi-language families.

A docker-compose snippet

services:
  sonarr:
    image: lscr.io/linuxserver/sonarr:latest
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Asia/Seoul
    volumes:
      - ./sonarr/config:/config
      - /mnt/media:/media
      - /mnt/downloads:/downloads
    ports:
      - '8989:8989'
    restart: unless-stopped

  radarr:
    image: lscr.io/linuxserver/radarr:latest
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Asia/Seoul
    volumes:
      - ./radarr/config:/config
      - /mnt/media:/media
      - /mnt/downloads:/downloads
    ports:
      - '7878:7878'
    restart: unless-stopped

  prowlarr:
    image: lscr.io/linuxserver/prowlarr:latest
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Asia/Seoul
    volumes:
      - ./prowlarr/config:/config
    ports:
      - '9696:9696'
    restart: unless-stopped

  bazarr:
    image: lscr.io/linuxserver/bazarr:latest
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Asia/Seoul
    volumes:
      - ./bazarr/config:/config
      - /mnt/media:/media
    ports:
      - '6767:6767'
    restart: unless-stopped

Critical pitfall — hardlinks and folder layout

This is where most first-time arr setups break. The download folder and the media folder have to live on the same filesystem so hardlinks can connect them; that is what lets a file be seeded and also live in the library without doubling disk usage. Recommended layout:

• /data/torrents/movies, /data/torrents/tv, /data/torrents/music
• /data/media/movies, /data/media/tv, /data/media/music

Mount /data as a single tree into the containers. Splitting /data/torrents and /data/downloads breaks hardlinks.

8. Jellyseerr and Overseerr — Request Systems

Where do you receive "can you add this movie" requests from family? Slack and chat threads forget. The request system fills that gap.

Overseerr — Plex pedigree

• TMDB / TVDB integrated search.
• Plex user federation — every family member logs in with their existing Plex account.
• Direct hooks into Sonarr, Radarr, and Lidarr — approval pushes the title into the library.
• Notifications (Discord, Telegram, Slack, Email, Pushover).

Jellyseerr — Overseerr fork with Jellyfin and Emby support

• Everything Overseerr does, plus Jellyfin / Emby authentication.
• More active development as of 2026 than upstream Overseerr.
• Required if you run both Jellyfin and Plex backends in parallel.

Operating tips

• Auto-approve vs manual approve — auto is usually fine for family, manual when friends are invited.
• Per-user quotas — keep one person from eating the queue.
• A separate 4K library — use Sonarr-4K and Radarr-4K instances and expose them only to clients that can direct play.
• Discord webhooks are the cleanest notification channel — new request, approval, download complete.

9. qBittorrent and SABnzbd — Download Clients

qBittorrent

The de facto torrent client. Light, with a category and tag system that maps neatly to the arr stack, and a clean web UI.

• Category equals folder equals arr mapping — the "sonarr" category points to /downloads/sonarr, "radarr" to /downloads/radarr.
• Seed ratio and time limits.
• Mandatory seed time on private trackers — keep an eye on it.
• Bandwidth schedules.
• Port forwarding — critical inside a VPN container.

Gluetun — the VPN container pattern

services:
  gluetun:
    image: qmcgaw/gluetun
    cap_add:
      - NET_ADMIN
    devices:
      - /dev/net/tun:/dev/net/tun
    environment:
      - VPN_SERVICE_PROVIDER=mullvad
      - VPN_TYPE=wireguard
      - WIREGUARD_PRIVATE_KEY=$$WIREGUARD_PRIVATE_KEY
      - SERVER_CITIES=Stockholm
    ports:
      - '8080:8080' # qBittorrent webui
      - '6881:6881' # torrent traffic
      - '6881:6881/udp'
    restart: unless-stopped

  qbittorrent:
    image: lscr.io/linuxserver/qbittorrent:latest
    network_mode: 'service:gluetun'
    depends_on:
      - gluetun
    environment:
      - PUID=1000
      - PGID=1000
      - WEBUI_PORT=8080
    volumes:
      - ./qbittorrent/config:/config
      - /data/torrents:/data/torrents
    restart: unless-stopped

All qBittorrent network traffic is forced through Gluetun's VPN tunnel. If Gluetun dies, qBittorrent loses internet — built-in kill switch.

SABnzbd / NZBGet — Usenet

Usenet lives in its own universe. You need an indexer subscription and a Usenet provider (SuperNews, Newshosting, Eweka), but speeds saturate the line reliably, there is no seeding obligation, and tracking risk is essentially nil.

• SABnzbd — friendlier UI, strong post-processing.
• NZBGet — lighter and faster but rougher UX (a fork is active again starting in 2024).

10. Tdarr, Unmanic, FileFlows — Transcoding Orchestration

Libraries get huge fast. One 8K Blu-ray remux is 80 GB; one season of a show is 200 GB. Combine that with a family member whose client only supports H.264 and live transcoding starts burning CPU. The answer is to transcode in advance, in bulk.

Tdarr

• Scans the whole library and flags files that violate policy.
• HEVC conversion, AV1 conversion, subtitle extraction, track cleanup.
• Distributed nodes — split encoding across multiple machines.
• Strong stats and dashboard.

Unmanic

• Single-node, simpler.
• Easy workflows that are intuitive to author.
• Lighter than Tdarr but weak on distribution.

FileFlows

• Workflow (nodes + edges) approach — visual pipeline builder.
• Partly commercial (free core plus paid license for extra node capacity).

A sample policy — library standardization

• All video must be HEVC 10-bit. Keep only AV1 or HEVC.
• Keep Korean and English audio tracks; drop the rest.
• Convert PGS subtitles to SRT via OCR; leave ASS untouched.
• Replace the original only if the new file is smaller (guard against quality regressions).

Encode the policy into Tdarr and you can move a 5 TB library to 2.5 TB within a month. The catch: encoding equals CPU and GPU time equals electricity equals wall-clock days. A standalone N100 takes days per 4K HEVC encode. An NVIDIA NVENC card or an Arc A380 cuts that to something usable.

FileBot — the cleanup endgame

FileBot is not an encoder — it is the gold standard for normalizing filenames and folder structures. The kind of fix-the-old-library, Korean-and-Japanese-collection, family-video-import scenarios that the arr stack cannot auto-detect. Commercial license but one-time purchase.

11. TRaSH-Guides — The arr Configuration Bible

TRaSH-Guides (https://trash-guides.info) is the community-maintained reference for arr quality, naming, and folder structure. By 2026 it is fair to say that the vast majority of people running the arr stack seriously follow it.

What it covers

• Quality profiles — which sources (WEB-DL, BluRay, Remux) get which priority.
• Custom Formats — score-based rules for things like Korean subtitles, HDR10, Dolby Vision, Atmos.
• Naming format — Sonarr / Radarr rename tokens.
• Folder structure — the hardlink-safe layout.
• Quality definitions — size floors and ceilings per resolution.
• Recyclarr — a tool that syncs all the above as code.

Recyclarr — arr configuration as YAML

# recyclarr.yml
sonarr:
  main:
    base_url: http://sonarr:8989
    api_key: !env_var SONARR_API_KEY

    quality_definition:
      type: series

    custom_formats:
      - trash_ids:
          - 9b27ab6498ec0f31a3353992e19434ca # WEB-DL
          - 6a7b462c80caa912f46c8c6e1eb0a31f # Korean
        quality_profiles:
          - name: WEB-1080p

radarr:
  main:
    base_url: http://radarr:7878
    api_key: !env_var RADARR_API_KEY

    quality_definition:
      type: movie

Run Recyclarr on cron daily and the latest TRaSH recommendations propagate into your arr instances automatically. The value compounds as you add more instances.

A five-step on-ramp

1. Unify the folder layout with the TRaSH recommendation first (/data/media, /data/torrents).
2. Set Sonarr and Radarr filename formats to the TRaSH conventions.
3. Add one or two key Custom Formats (for example x265 penalty, Korean, HDR10).
4. Start with one baseline profile such as WEB-1080p or BluRay-2160p.
5. Adopt Recyclarr to keep future updates synchronized.

12. Hardware — N100, Synology, UnRAID, TrueNAS Scale, Proxmox

N100 / N305 mini PCs — the 2026 default

Intel N100 / N305 mini PCs went mainstream between 2024 and 2025. Beelink, MINISFORUM, GMKtec, and ASUS NUC 11 to 14 are the common brands.

• 8 to 16 GB RAM, 512 GB to 2 TB NVMe, 2.5 GbE.
• TDP 6 to 15 W. Full load rarely exceeds 25 W at the wall.
• iGPU equals Intel UHD equals QSV. 4K HEVC transcoding works.
• USD 200 to 400.

Enough for a family media server on its own. SATA bays are limited so plan an external USB HDD or a separate NAS.

Synology — still dominant, with caveats

Synology had a noisy 2025 — a new 7th-generation lineup and tighter first-party HDD compatibility requirements on some models. By 2026:

• Still the home-NAS leader for UX, mobile apps, and reliability.
• Container Manager (the former Docker package) hosts the arr stack and Jellyfin in one place.
• First-party HDD restrictions vary by model and firmware — verify before buying.
• DSM 7.x with Active Backup and Hyper Backup is still a real strength.

UnRAID — the de facto media-homelab OS

UnRAID supports mixed-size HDDs, per-disk spin-down, and an optional ZFS pool. The most popular media-homelab choice.

• Lifetime or annual licensing. Even after the 2024 pricing tweaks it is reasonable.
• Unified UI for Docker, VMs, and plugins.
• Community Applications marketplace — arr stack, Jellyfin, Immich, AudioBookshelf and more are all one-click installs.
• Tdarr node, Plex / Jellyfin GPU passthrough — all configurable from the UI.

TrueNAS Scale — the ZFS answer

A ZFS-based NAS OS for people who take data integrity, snapshots, and replication seriously.

• The 2024 shift moved center of gravity from Core (FreeBSD) to Scale (Linux/Debian).
• Apps went from TrueCharts to a first-party catalog.
• Apps run via containers and Kubernetes (k3s) — steeper learning curve than UnRAID.
• For people whose priority is data preservation more than media.

Proxmox VE — virtualization king

If you want one host running many VMs and containers (not just media), Proxmox is the answer.

• Unified KVM and LXC management.
• ZFS and Ceph support.
• Backup, replication, HA.
• The home for the "NAS plus media server plus Home Assistant on one box" build.

Disks — RAID is not backup

This is one of the self-hosting commandments.

• RAID (or ZFS RAIDZ) is for availability, not backup.
• Backups go to a separate disk — ideally one external plus one cloud.
• Borg, Restic, or Kopia for daily incremental backups.
• Backblaze B2 or Cloudflare R2 for cheap S3-compatible remote copies.
• Run a recovery rehearsal once a quarter.

13. Remote Access — Tailscale, Cloudflare Tunnel, WireGuard

Tailscale — the first answer

Ninety percent of homelabs end here.

• Install the client on every device, log in with the same account, and a 100.x.y.z private IP appears automatically.
• No more port forwarding, dynamic DNS, or certificate renewal.
• MagicDNS gives you names like my-jellyfin.tailnet.ts.net.
• Tailscale SSH absorbs SSH-key management.
• Free for 100 devices and 3 users (still true in 2026).

Cloudflare Tunnel — when you need a public surface

For sharing something with people outside your family — say, a Jellyseerr that a friend uses, or a public blog. Run cloudflared on your server and Cloudflare brokers your domain back to it without opening any ports.

• Zero open ports.
• Cloudflare handles DDoS protection, bot mitigation, and TLS.
• Access policies (SSO, email OTP, Google Workspace) for who can hit what.

Bare WireGuard

The lightest and fastest VPN protocol. Tailscale uses it internally. Running it bare means handling key distribution, handshakes, and dynamic DNS yourself. By 2026 most self-hosters have moved on to Tailscale or Netbird.

Recommended pairing

• You and family — Tailscale mesh VPN.
• Friends — Cloudflare Tunnel plus Access (email OTP).
• Fully public (blog/wiki) — Cloudflare Tunnel plus WAF.
• Never exposed (arr admin, qBittorrent web UI) — Tailscale-only.

14. Korean and Japanese Homelab Scenes

Korea

• Synology dominates — DS218+, DS220+, DS920+, and DS923+ are the home NAS norm.
• N100 mini PCs exploded — Coupang and AliExpress prices around KRW 300 to 400k.
• External HDD + NAS combos — data on the Synology, Docker plus Jellyfin on the N100.
• Gigabit symmetric internet is standard — remote streaming is not an upstream-bandwidth issue.
• Subtitle culture — Korean subtitle matching is finicky; Bazarr with extra Korean subtitle indexers is almost mandatory.
• Clients — Apple TV, Shield TV, and Android TV boxes dominate; some folks use the built-in Plex / Jellyfin apps on LG / Samsung smart TVs.

Japan

• QNAP and Synology codominate, with a strong DIY camp — homebrew home servers run deep.
• Raspberry Pi 5 renaissance — Pi 5 plus Pi NVMe HAT is a viable small media server.
• Anime-only libraries — Sonarr-anime forks plus Anilist matchers instead of stock Sonarr.
• Metadata matchers — AniDB and AniList plugins are practically required.
• Mobile and satellite uplinks — fiber plus 5G router hotspots; connectivity itself is not the bottleneck.
• Clients — TVer and Abema sit in their own ecosystem; Jellyfin is complementary.

Both countries

• Electricity costs run higher than in the United States, which biases people toward N100-class low-power builds.
• Living spaces are smaller; an N100 plus one or two external HDDs is more realistic than a tower NAS.
• Data-sovereignty awareness was lower than in the United States, but has risen sharply since Google Photos went paid and the Plex affair landed.

15. Security, Backup, Operations — Five Things That Bite

1. Validate your VPN-container kill switch. Once a month, kill Gluetun and confirm qBittorrent loses internet rather than leaking to your ISP.
2. Backups: 3-2-1. One original, one separate disk, one cloud. One restore rehearsal per quarter.
3. Logs and alerts. Watchtower auto-updating containers is risky. Diun for notifications plus manual review is the better stance.
4. Certificate and token expiry. Bazarr / Sonarr API keys, Cloudflare API tokens, WireGuard keys — keep them in a separate vault.
5. Legal gray zones. Parts of the self-hosted media workflow (especially indexers and trackers) sit under jurisdiction-specific rules. Know what you are pulling and from where.

16. References

• Jellyfin official site — https://jellyfin.org
• Jellyfin documentation — https://jellyfin.org/docs/
• Jellyfin 10.10 release notes — https://github.com/jellyfin/jellyfin/releases
• Plex official site — https://www.plex.tv
• Plex Remote Watch Pass announcement (Apr 2025) — https://www.plex.tv/blog/
• Emby official site — https://emby.media
• Immich — https://immich.app
• Immich GitHub — https://github.com/immich-app/immich
• Photoprism — https://www.photoprism.app
• Navidrome — https://www.navidrome.org
• Navidrome GitHub — https://github.com/navidrome/navidrome
• AudioBookshelf — https://www.audiobookshelf.org
• Komga — https://komga.org
• Kavita — https://www.kavitareader.com
• Sonarr — https://sonarr.tv
• Radarr — https://radarr.video
• Lidarr — https://lidarr.audio
• Readarr — https://readarr.com
• Prowlarr — https://prowlarr.com
• Bazarr — https://www.bazarr.media
• Jellyseerr — https://docs.jellyseerr.dev
• Overseerr — https://overseerr.dev
• qBittorrent — https://www.qbittorrent.org
• SABnzbd — https://sabnzbd.org
• NZBGet — https://nzbget.com
• Tdarr — https://tdarr.io
• Unmanic — https://docs.unmanic.app
• FileFlows — https://fileflows.com
• FileBot — https://www.filebot.net
• TRaSH-Guides — https://trash-guides.info
• Recyclarr — https://recyclarr.dev
• Gluetun — https://github.com/qdm12/gluetun
• Tailscale — https://tailscale.com
• Headscale — https://github.com/juanfont/headscale
• Cloudflare Tunnel — https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/
• Synology — https://www.synology.com
• UnRAID — https://unraid.net
• TrueNAS Scale — https://www.truenas.com/truenas-scale/
• Proxmox VE — https://www.proxmox.com/en/proxmox-virtual-environment/overview
• r/selfhosted — https://www.reddit.com/r/selfhosted/
• r/jellyfin — https://www.reddit.com/r/jellyfin/
• selfh.st newsletter — https://selfh.st
• awesome-selfhosted — https://github.com/awesome-selfhosted/awesome-selfhosted