Home Server Lab Setup Guide
i5 7th Gen · 8GB DDR3 · 500GB SSD + 500GB HDD · Immich + Jellyfin + Kavita
TL;DR Recommendation
Bare-metal Ubuntu Server LTS + Docker + Docker Compose. No TrueNAS, no Proxmox.
Here's why in one line: your binding constraint is 8GB of non-ECC DDR3 RAM, and Immich's official recommendation is 8GB by
itself. Every layer you stack under your apps (a hypervisor, a ZFS pool) eats into that same 8GB. With only one SSD and one HDD,
you can't build RAID/redundancy anyway — so ZFS's headline feature (TrueNAS) and the "run lots of isolated VMs" feature
(Proxmox) both lose most of their value here, while still costing you RAM. Skipping the extra layer and running Docker directly
on the OS gets you the most headroom for the apps that actually matter to you.
The full reasoning and an alternative path (if you want Proxmox anyway) are below — jump to Part 1 if you just want to start.
1. Hardware Reality Check
Component
You have
Verdict
CPU
i5 7th gen (Kaby Lake), 4 Fine for this workload. No hardware transcoding needed for direct-play; Quick Sync
cores
available for the odd transcode (see optional section)
RAM
8GB DDR3
The real constraint — see budget below
Boot/apps
storage
500GB SSD
Use for OS, Docker, databases, thumbnails, transcode cache
Bulk storage
500GB HDD
Use for photo/video library, movies/shows, books/manga
Redundancy
None (1 SSD + 1 HDD, no
matching pairs)
If a drive dies, that data is gone. Plan backups accordingly (Part 10)
Rough RAM budget for your three apps, running together:
Service
Idle
Under load
Ubuntu Server (headless, no GUI)
~300–500MB —
Jellyfin
~150–300MB
Spikes during transcode if not using hardware
acceleration
Kavita
~100–150MB
Barely moves
Immich (server + Postgres + Redis)
~800MB–
1.2GB
—
Immich machine learning (face recognition, smart
search)
~500MB–1GB 1.5–3GB+ during initial library scan/indexing
Total
~2–3GB idle
4–6GB+ during an Immich scan
You have enough to run all three comfortably day-to-day. The tight moment will be the first Immich library import, when it's
thumbnailing, face-detecting, and CLIP-indexing everything at once while you're also streaming something on Jellyfin. Two
things you can do about that, covered later: (1) add a swap file as a safety net, (2) import your photo library in smaller batches
rather than dumping everything in at once the first time.
If your motherboard is an OEM business desktop (common combo for 7th-gen Kaby Lake + DDR3L), check its spec page for
max supported RAM — bumping to 16GB, if the board allows it and DDR3L SO-DIMMs/DIMMs are cheap where you are, would
remove this constraint entirely and is worth it more than any software tweak.
2. Platform Comparison: TrueNAS vs Ubuntu Server vs Proxmox VE
TrueNAS SCALE
Proxmox VE
Type-1 hypervisor (VMs/LXC)
Ubuntu Server + Docker
General-purpose Linux
server
What it is
NAS OS with ZFS + an app catalog
RAM overhead
before your apps
even start
ZFS wants ~1GB+ RAM just for itself, more Host OS ~1–2GB, plus a VM needs
as pools grow; on 8GB non-ECC this is real its own OS overhead (~0.5–1GB) on ~300–500MB, nothing else
overhead for modest benefit
top
None — you have one SSD and one HDD,
Redundancy
not matching pairs, so no mirror is
benefit given your
N/A (it's a hypervisor, not storage) N/A
possible. You still get bit-rot
disks
checksumming, but that's it
Best for
People who know exactly
People who want to run several
People with 3+ same-size drives who want
what they want to run and
different OSes/services in isolation,
a real NAS + snapshots
want max resources going
with snapshot rollback
to it
Fit for "just these 3 Workable via SCALE's app catalog, but
Docker apps on
you're paying ZFS RAM tax for
8GB"
redundancy you can't actually get
Workable, especially "Proxmox +
one Ubuntu VM running Docker,"
Best fit — no tax, all 8GB
available to Ubuntu + your
containers
TrueNAS SCALE
Proxmox VE
Ubuntu Server + Docker
but costs ~1.5–2GB you don't have
to spare
Bottom line: Proxmox is genuinely excellent, and if you plan to grow this into a multi-service homelab (Home Assistant, Pi-hole,
a second VM, etc.) later, it's worth the RAM cost and I've included a condensed path for it in Part 12. But for exactly three
Docker-native apps on 8GB DDR3, bare-metal Ubuntu Server wins on pure resource math, and it's also the simplest thing to
debug when something breaks at midnight.
3. Storage Layout
SSD (500GB) — OS root, fast/small I/O
├── / (Ubuntu Server)
└── /opt/appdata/
├── immich/postgres/ ← Immich's database (wants fast disk)
├── immich/model-cache/ ← ML model cache
├── jellyfin/config/
├── jellyfin/cache/
← transcode cache (wants fast disk)
└── kavita/config/
HDD (500GB) — bulk media, mounted at /mnt/data
├── immich-library/
← original photos & videos
├── jellyfin-media/
│ ├── movies/
│ ├── tv/
│ └── music/
└── kavita-library/
├── books/
├── comics/
└── manga/
Rule of thumb: anything that's a database or gets hammered with small random reads/writes (Postgres, transcode cache) goes on
the SSD. Anything that's bulk files read mostly sequentially (your actual media) goes on the HDD. This split matters more than total
capacity for how snappy the apps feel.
500GB of bulk storage will fill up faster than you expect once movies enter the picture — plan for external/USB expansion or a
second HDD down the line if your media library grows.
4. Network Prep (Jio + TP-Link extender)
A few things worth sorting out before you install anything:
Confirm you have one flat network, not double-NAT. Since the TP-Link is in extender/repeater mode (not "router mode"), it
should just be bridging Jio's WiFi and handing out IPs from the Jio router's own DHCP — so every device, wired or wireless,
ends up on the same subnet (e.g., 192.168.1.x ). Quick check: compare the server's IP (once installed) against your phone's IP on
the Jio router's admin page. If they're on the same subnet, you're good. If the TP-Link is issuing a different subnet (e.g.
192.168.0.x ), it's double-NATed — log into the TP-Link admin panel and switch its operating mode to "Access Point" or "Range
Extender" (not "Router").
Wireless backhaul is a real bottleneck. Right now, traffic between your server (on the TP-Link's LAN/WiFi) and the Jio
router's own segment has to cross a WiFi hop. This matters for 4K Jellyfin direct-play streams and large Immich uploads. If it's
at all possible to run a physical Ethernet cable from the Jio router to the TP-Link (putting the TP-Link in wired Access Point
mode instead of wireless-extender mode), do it — it removes that bottleneck entirely and is the single best network upgrade
you can make here. Cable directly from Jio router to the server itself, if that's physically feasible, is even better.
Set a DHCP reservation for the server. On the Jio router's admin page (usually 192.168.1.1 ), find the DHCP client list, locate
your server's MAC address once it's on the network, and reserve a fixed IP for it. This means you'll always know its address, and
it won't change after a reboot.
Don't rely on port forwarding for remote access. Reliance Jio broadband almost always sits behind Carrier-Grade NAT
(CGNAT) — you don't get a real public IPv4 address, so port forwarding on the Jio router typically does nothing (Jio's own
support will sometimes open 2–3 ports on request for things like CCTV, but it's limited and unreliable for a self-hosted app
stack). Part 11 covers the actual working solution: a VPN mesh tool like Tailscale, which works fine behind CGNAT with no port
forwarding needed.
Part 1: Prepare Installation Media
Step 1. On another PC, download the Ubuntu Server 24.04 LTS ISO from ubuntu.com/download/server. (26.04 LTS "Resolute
Raccoon" is also current and fine to use — 24.04 is simply the more battle-tested choice with the most existing guides/forum
threads if you hit an issue; either works identically for this purpose since none of this involves a desktop GUI.)
Step 2. Flash it to a USB drive (8GB+) using Rufus (Windows) or balenaEtcher (any OS). Select the ISO, select the USB drive,
write.
Step 3. Physically disconnect anything you don't want wiped. Only the 500GB SSD and 500GB HDD should be in the machine
(or at least, be very sure which disk is which before the installer asks).
Part 2: BIOS Settings
Boot into BIOS/UEFI (usually Del , F2 , or F10 at power-on — varies by motherboard).
Boot order: set the USB drive as first boot device.
Secure Boot: disable it (Ubuntu Server + third-party kernel modules are simpler without it).
Integrated graphics (iGPU): make sure it's enabled, not disabled — you'll want it later for Jellyfin hardware transcoding via
Intel Quick Sync (optional, Part 9).
Save and reboot.
Part 3: Install Ubuntu Server
Boot from USB, launch the installer (Subiquity), and walk through it:
Language → keyboard layout → skip network config for now (or let DHCP assign a temp IP, doesn't matter yet) → skip proxy →
default archive mirror.
Storage: choose "Custom storage layout" (not "guided" across both disks). Select only the 500GB SSD as the install target, use
the full disk, ext4, standard partitioning. Leave the HDD completely untouched here — you'll set it up manually after boot,
which is far less error-prone than juggling two disks in the installer.
Profile setup: set your username, hostname (e.g. homelab ), and password.
Install OpenSSH server — tick this. You'll want to manage this headless from another machine.
Skip the featured snaps (Docker snap included — you'll install Docker properly via apt later, not the snap).
Let it install, reboot, remove the USB when prompted.
Part 4: First Boot & Base Setup
SSH in from another machine (find the IP from your router's DHCP client list, or check the console directly):
bash
ssh yourusername@<server-ip>
Update everything:
bash
sudo apt update && sudo apt full-upgrade -y
sudo reboot
Install a few essentials:
bash
sudo apt install -y curl wget git nano htop parted net-tools
Mount the HDD. Identify it first:
bash
lsblk
You'll see something like sda (your SSD, already partitioned/mounted as / ) and sdb (your untouched HDD). Confirm the size
matches the HDD (500GB) before proceeding — you don't want to format the wrong disk.
bash
sudo parted /dev/sdb --script mklabel gpt mkpart primary ext4 0% 100%
sudo mkfs.ext4 /dev/sdb1
sudo mkdir -p /mnt/data
sudo blkid /dev/sdb1
Copy the UUID value that blkid prints, then:
bash
sudo nano /etc/fstab
Add this line at the bottom (replace with your actual UUID):
UUID=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx /mnt/data ext4 defaults 0 2
Save ( Ctrl+O , Enter , Ctrl+X ), then mount and verify:
bash
sudo mount -a
df -h
You should see /mnt/data listed with ~465GB available.
Add a swap file as a safety net for the RAM-tight moments mentioned earlier (4GB is a reasonable size given your 500GB SSD
has plenty of room):
bash
sudo fallocate -l 4G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
This won't make things fast — swap on any disk is slow — but it stops the kernel's OOM killer from randomly murdering a
container when RAM briefly spikes during an Immich scan.
Part 5: Install Docker Engine + Compose
Following Docker's official repository method (more reliable long-term than the convenience script):
bash
sudo apt update
sudo apt install -y ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
Let your user run Docker without sudo :
bash
sudo usermod -aG docker $USER
Log out and back in (or just exit your SSH session and reconnect) for that to take effect, then verify:
bash
docker --version
docker compose version
Part 6: Create the Directory Structure
bash
sudo mkdir -p /opt/appdata/immich/postgres
sudo mkdir -p /opt/appdata/jellyfin/{config,cache}
sudo mkdir -p /opt/appdata/kavita/config
sudo mkdir -p /mnt/data/immich-library
sudo mkdir -p /mnt/data/jellyfin-media/{movies,tv,music}
sudo mkdir -p /mnt/data/kavita-library/{books,comics,manga}
sudo chown -R $USER:$USER /opt/appdata /mnt/data
Part 7: Install Immich
Immich's own docs recommend downloading their release-pinned Compose files rather than hand-writing one (their compose
file references specific ML/Postgres extension versions that need to match).
bash
mkdir -p /opt/appdata/immich && cd /opt/appdata/immich
wget -O docker-compose.yml https://github.com/immich-app/immich/releases/latest/download/docker-compose.yml
wget -O .env https://github.com/immich-app/immich/releases/latest/download/example.env
Edit the .env file:
bash
nano .env
Set (or confirm) these values:
ini
UPLOAD_LOCATION=/mnt/data/immich-library
DB_DATA_LOCATION=/opt/appdata/immich/postgres
TZ=Asia/Kolkata
DB_PASSWORD=<replace-with-a-long-random-password>
Save and exit, then bring it up:
bash
docker compose up -d
First run will pull several images (server, machine-learning, postgres, redis) — give it a few minutes on first launch, especially
over a home connection. Check status with:
bash
docker compose ps
docker compose logs -f immich-server
Once it's up, browse to http://<server-ip>:2283 . The first account you register becomes the admin account. From there you
can add your photo library either by uploading through the web UI or by installing the Immich mobile app and pointing it at
http://<server-ip>:2283 for automatic phone backup.
RAM tip for the first import: if you're dumping a large existing photo library in for the first time, consider importing it in a few
batches rather than all at once — this spreads out the machine-learning indexing load instead of hitting Immich's
thumbnail/face-detection/CLIP jobs all simultaneously on a full RAM budget.
Part 8: Install Jellyfin + Kavita
These two are lightweight enough to live in one Compose stack.
bash
mkdir -p /opt/appdata/media-stack && cd /opt/appdata/media-stack
nano docker-compose.yml
Paste:
yaml
services:
jellyfin:
image: jellyfin/jellyfin:latest
container_name: jellyfin
user: "1000:1000"
environment:
- TZ=Asia/Kolkata
volumes:
- /opt/appdata/jellyfin/config:/config
- /opt/appdata/jellyfin/cache:/cache
- /mnt/data/jellyfin-media:/media:ro
ports:
- "8096:8096"
restart: unless-stopped
kavita:
image: jvmilazz0/kavita:latest
container_name: kavita
environment:
- TZ=Asia/Kolkata
volumes:
- /opt/appdata/kavita/config:/kavita/config
- /mnt/data/kavita-library/books:/books
- /mnt/data/kavita-library/comics:/comics
- /mnt/data/kavita-library/manga:/manga
ports:
- "5000:5000"
restart: unless-stopped
( user: "1000:1000" matches your default Ubuntu user's UID/GID, so Jellyfin can read/write its own config without permission
headaches — check yours with id -u / id -g if you're unsure, and adjust if different.)
Bring both up:
bash
docker compose up -d
Jellyfin: http://<server-ip>:8096 — the setup wizard will walk you through creating an admin account and adding your
/media/movies , /media/tv , /media/music folders as libraries.
Kavita: http://<server-ip>:5000 — same idea, create your admin account, then add /books , /comics , /manga as separate libraries
under Server Settings → Libraries.
Copy your actual files into /mnt/data/jellyfin-media/... and /mnt/data/kavita-library/... (via scp , a Samba/NFS share you set
up separately, or a USB drive) — both apps just scan whatever's in those mounted folders.
Part 9 (Optional): Hardware Transcoding for Jellyfin
Your i5 7th gen's integrated graphics (HD Graphics 630, on most non-"F" 7th-gen SKUs) supports Intel Quick Sync, which
offloads video transcoding from the CPU — worth doing since you don't have a lot of CPU/RAM headroom to spare on software
transcoding.
Check the render device exists on the host:
bash
ls -la /dev/dri
You should see renderD128 . Add it to the Jellyfin service in your compose file:
yaml
jellyfin:
# ...existing config...
devices:
- /dev/dri:/dev/dri
group_add:
- "44" # video group — check with 'getent group video' on your host
- "105" # render group — check with 'getent group render' on your host
Confirm the actual group IDs on your system ( getent group video and getent group render ) since they can differ slightly
between systems, then re-apply:
bash
docker compose up -d
In Jellyfin's admin dashboard, go to Playback → Transcoding, set hardware acceleration to Intel QuickSync (QSV), and enable
the codecs you need (H.264, HEVC, etc.).
Part 10 (Optional): Reverse Proxy for Clean URLs
Right now you're juggling three ports ( :2283 , :8096 , :5000 ). A lightweight reverse proxy like Caddy gives you clean local
hostnames and free HTTPS with almost no RAM cost (~50–100MB). This is optional — skip it if three ports doesn't bother you.
bash
mkdir -p /opt/appdata/caddy && cd /opt/appdata/caddy
nano Caddyfile
photos.home.arpa {
reverse_proxy localhost:2283
}
movies.home.arpa {
reverse_proxy localhost:8096
}
books.home.arpa {
reverse_proxy localhost:5000
}
docker-compose.yml :
yaml
services:
caddy:
image: caddy:2-alpine
container_name: caddy
network_mode: host
volumes:
- ./Caddyfile:/etc/caddy/Caddyfile
- caddy_data:/data
restart: unless-stopped
volumes:
caddy_data:
You'd then either add those hostnames to each device's hosts file, or better, run a local DNS resolver (like Pi-hole, a project for
another day) that points *.home.arpa at your server's IP.
Part 11: Remote Access (Tailscale)
Since Jio sits behind CGNAT, traditional port-forwarding + dynamic DNS won't reliably work. Tailscale sidesteps this entirely —
it builds a private mesh VPN between your devices without needing a public IP or open ports.
On the server:
bash
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up
This prints a login URL — open it on any browser to authenticate the server to your Tailscale account (free tier covers personal
use).
Then install the Tailscale app on your phone/laptop and log into the same account. Your server gets a stable Tailscale IP (and
MagicDNS name) that works from anywhere with internet — no router config, no CGNAT problem, and it's encrypted end-toend. Access Immich, Jellyfin, and Kavita from outside your home network exactly like you would locally, just using the Tailscale
address instead of the LAN IP.
Part 12: Data Redundancy & Backups
Which external drive to get: 1TB SSD or 750GB HDD?
Get the 750GB external HDD. Here's the reasoning: the redundancy approach below is a scheduled backup job (nightly, mostly
sequential writes), not a live, latency-sensitive mirror — so an SSD's random-access speed advantage buys you almost nothing
here. A USB3 external HDD comfortably sustains 100–150MB/s, which is more than enough for a nightly incremental job. The
HDD also gives you more usable capacity per rupee, and 750GB is plenty of headroom for what you actually need to protect
(see below) — it's your bulk, easily-re-acquired video library that would eat the rest. Save the SSD premium for something that
actually benefits from it, like your OS/appdata drive, which you already have.
Why not RAID1 over the USB drive?
It's tempting to reach for mdadm and mirror your internal HDD live onto the external one — but for this specific setup, I'd steer
you away from that, for two reasons:
USB reliability. RAID members expect a rock-solid, always-present block device. USB drives occasionally drop out (power
management, cable flakiness, USB controller quirks), and when that happens mid-array, mdadm doesn't handle it gracefully —
you end up with a degraded array needing a manual re-add and a full resync, and during that window you have zero redundancy
anyway.
RAID protects against the wrong failure mode for you. A mirror only protects against a drive physically dying. It does nothing
for the failure modes that actually threaten a home photo library — accidentally deleting a folder, a bad rm -rf , ransomware, or
a corrupted file. All of those get faithfully mirrored to the second drive instantly, because that's exactly what a mirror is
designed to do.
What you actually want is versioned backups — copies that let you go back in time, not just a live twin. That's what's below.
Set up the external drive
Plug in the external HDD, identify it:
bash
lsblk
Format and mount it the same way you did the internal HDD in Part 4 (double-check the device name before formatting — you
do not want to fat-finger this onto the wrong disk):
bash
sudo parted /dev/sdc --script mklabel gpt mkpart primary ext4 0% 100%
sudo mkfs.ext4 /dev/sdc1
sudo mkdir -p /mnt/backup
sudo blkid /dev/sdc1
Add it to /etc/fstab — note the nofail option this time, which stops the system from hanging at boot if the USB drive happens
to be unplugged:
UUID=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx /mnt/backup ext4 defaults,nofail 0 2
Install restic and take your first backup
restic gives you encrypted, deduplicated, versioned backups — after the first run, subsequent backups only write the data that
actually changed, so nightly runs are fast and space-efficient.
bash
sudo apt install -y restic
Set a repository password (write this down somewhere safe — separately from the server itself; if you lose it, the backups are
unrecoverable):
bash
sudo sh -c 'echo "your-strong-backup-password" > /root/.restic-password'
sudo chmod 600 /root/.restic-password
Initialize the backup repository on the external drive:
bash
export RESTIC_PASSWORD_FILE=/root/.restic-password
restic -r /mnt/backup/restic-repo init
What to actually back up, in priority order:
Priority
Path
Why
1
/mnt/data/immich-library
Your original photos/videos — irreplaceable
2
Immich's database (via pg_dumpall ,
see below)
Without it you keep the photos but lose albums, faces, and metadata
3
/opt/appdata/jellyfin/config ,
/opt/appdata/kavita/config
Small, saves you re-configuring libraries/users from scratch
4
/mnt/data/kavita-library
Depends how hard your specific collection would be to reassemble
—
/mnt/data/jellyfin-media
Skip by default — usually re-downloadable/re-rippable, and it's the one thing
big enough to blow through 750GB fast. Only include it if you have spare
capacity and it'd genuinely be painful to lose
One important detail: Immich's Postgres database is a live, running database, not a static file. Copying its raw data files while it's
running can produce a backup that won't restore cleanly. The reliable way to back it up is a logical dump, taken fresh before
each backup run:
bash
docker exec immich_postgres pg_dumpall -U postgres > /opt/appdata/immich/db_dump.sql
Put it all together in a script:
bash
sudo nano /opt/appdata/backup.sh
bash
#!/bin/bash
set -e
export RESTIC_PASSWORD_FILE=/root/.restic-password
REPO=/mnt/backup/restic-repo
# Bail out if the external drive isn't actually mounted — otherwise this
# would silently "succeed" while writing into an empty folder on the SSD
mountpoint -q /mnt/backup || { echo "Backup drive not mounted — aborting"; exit 1; }
# Consistent Immich database dump (not a raw file copy of the live DB)
docker exec immich_postgres pg_dumpall -U postgres > /opt/appdata/immich/db_dump.sql
restic -r "$REPO" backup \
/opt/appdata/immich/db_dump.sql \
/opt/appdata/jellyfin/config \
/opt/appdata/kavita/config \
/mnt/data/immich-library \
/mnt/data/kavita-library
# Keep 7 daily, 4 weekly, 6 monthly snapshots; delete anything older
restic -r "$REPO" forget --keep-daily 7 --keep-weekly 4 --keep-monthly 6 --prune
bash
sudo chmod +x /opt/appdata/backup.sh
Run it once by hand to confirm it works:
bash
sudo /opt/appdata/backup.sh
Then schedule it nightly:
bash
sudo crontab -e
0 3 * * * /opt/appdata/backup.sh >> /var/log/homelab-backup.log 2>&1
Restoring, if you ever need to (list snapshots, then restore one to a target folder):
bash
restic -r /mnt/backup/restic-repo snapshots
restic -r /mnt/backup/restic-repo restore latest --target /home/yourusername/restore-test
Test that restore at least once, on purpose, before you need it. A backup you've never restored from is a hope, not a backup.
Keep an eye on drive health
Since you now have three drives and no early-warning system, install SMART monitoring so a failing drive tells you before it dies
rather than after:
bash
sudo apt install -y smartmontools
sudo smartctl -a /dev/sda # repeat for /dev/sdb and /dev/sdc
Look at Reallocated_Sector_Ct and overall SMART health status — nonzero/growing reallocated sectors is an early sign a drive is
on its way out. Worth a quick manual check every month or so.
One more thing worth doing later
A 750GB drive sitting in the same room as the server protects you from disk failure, but not from theft, fire, or flood. Once this
routine is comfortable, consider periodically rotating that drive offsite (a relative's house, your office) or adding an rclone based encrypted sync to a cloud target for the Immich library specifically, since it's the one thing here that's genuinely
irreplaceable.
Maintenance Cheat Sheet
bash
# Update all containers in a stack
cd /opt/appdata/immich && docker compose pull && docker compose up -d
cd /opt/appdata/media-stack && docker compose pull && docker compose up -d
# Check resource usage live
docker stats
# View logs for a specific container
docker logs -f jellyfin
# Full system + container prune (careful — removes unused images/volumes)
docker system prune -a
Part 13: Troubleshooting Quick Reference
Symptom
Container immediately exits
Likely cause / fix
docker compose logs <service> — usually a permissions issue on a mounted folder, or a bad
.env value
Immich ML jobs make everything Expected under 8GB during a big first import — let it finish, or import in smaller batches;
sluggish
check docker stats to confirm it's immich-machine-learning eating RAM
Jellyfin stutters on 4K direct-play Likely the WiFi backhaul between TP-Link and Jio router — see network notes in Part 4 of
from another room
the intro
Can't reach the server from
outside your home
Expected — Jio CGNAT blocks inbound port forwarding. Use Tailscale (Part 11), not port
forwarding
Server's IP changed after a reboot Set the DHCP reservation on the Jio router (see network prep section)
Jellyfin transcoding pegs the CPU Enable Quick Sync hardware transcoding (Part 9)
Part 14: Alternative Path — Proxmox VE + Single VM
If you'd rather have snapshot/rollback safety and room to grow into other services later, and you're willing to trade some RAM
headroom for it, here's the condensed path. Current stable release is Proxmox VE 9.2 (Debian 13 "Trixie" based).
Flash the Proxmox VE ISO to USB, boot it, run through the installer, selecting the SSD as the target disk. Set a static IP or DHCP
reservation for the Proxmox host itself during install.
Post-install, switch off the enterprise repo prompt (no subscription needed for home use) and update: apt update && apt fullupgrade -y from the Proxmox shell.
In the Proxmox web UI ( https://<proxmox-ip>:8006 ), go to Datacenter → Storage → Add → Directory (or LVM-Thin), point it at
the HDD after initializing it under Disks, and give it a name like hdd-data .
Create a new VM: Ubuntu Server 24.04/26.04 ISO, allocate 2 cores, 6GB RAM (leaving ~2GB for the Proxmox host), a boot disk
on the SSD-backed storage (~40GB is plenty for OS + Docker), and a second disk from your hdd-data storage sized to the
HDD's full capacity.
Install Ubuntu Server inside the VM exactly as described in Part 3 onward of this guide — except now the "HDD" you mount at
/mnt/data is that second virtual disk (it'll show up as /dev/sdb inside the VM), and everything else (Docker install,
Immich/Jellyfin/Kavita compose files, directory layout) is identical.
The main added benefit: before any risky change (an Immich major version bump, a big config edit), take a VM snapshot from
the Proxmox UI — if something breaks, roll back in seconds instead of debugging at 1am.
Everything from Part 5 onward in this guide applies unchanged once you're inside that VM.
That's the whole stack: Ubuntu Server as the lean foundation, Docker Compose for each app, SSD for anything latencysensitive, HDD for bulk media, Tailscale for remote access since Jio's CGNAT rules out port forwarding, and a swap file plus
staged imports to keep Immich's ML jobs from starving the other two apps on 8GB of RAM.
0
You can add this document to your study collection(s)
Sign in Available only to authorized usersYou can add this document to your saved list
Sign in Available only to authorized users(For complaints, use another form )