Yes — a Raspberry Pi 4 Model B 8GB can run Immich as a Google Photos replacement for a personal library of up to ~50,000 photos, provided you back the Pi with a USB-3-attached SATA SSD and accept that machine-learning face/object indexing runs in batch overnight rather than instantly. Upload throughput sits around 30-50 MB/s and thumbnail generation runs in the background without taking the UI down.
Who actually wants to leave Google Photos in 2026
The exit pressure is real: Google Photos free-tier storage has been gone since 2021, the One subscription has crept up every year, and Google's repeated quiet changes to "Recently Deleted" retention and tier shuffling keep landing in the news. For anyone with 20,000+ photos and an aversion to a recurring $10-$20/month bill, the math on self-hosting becomes attractive.
Immich is the standout open-source photo server because it actually copies the Google Photos UX — auto-upload from iOS/Android, server-side facial recognition, location/object search, shared albums, partner sharing, and a polished web UI. It is the answer for someone who looked at PhotoPrism or Lychee and wanted a more familiar experience.
Why the Pi 4 8GB specifically: a $75 Pi 4 8GB plus a $90 WD Blue SN550 1TB NVMe (or a $70 Crucial BX500 1TB SATA SSD with a USB-3 adapter) gets you a complete server for under $200, and the 8GB RAM ceiling — not the 4GB or 2GB Pi 4 variants — is the threshold where Immich's PostgreSQL + Redis + ML workers stop swap-thrashing.
Key takeaways
- Library size: Up to ~50,000 photos in active use; the architecture scales further but Pi 4 ML throughput sets a soft ceiling.
- Storage: USB-3-attached SATA SSD is non-negotiable. SD cards burn out and HDDs are too slow for indexing.
- RAM ceiling: 8GB is the floor. 4GB Pi 4 swap-thrashes under face-detection load.
- ML face/object detection: Runs but slowly (3-8 photos/second). Run it overnight or offload to a desktop on-demand.
- Backup: Standard 3-2-1 — primary on the Pi SSD, mirror to a second SSD or NAS, offsite to a cloud bucket with
rclone.
What Immich needs and does the Pi 4 8GB meet it?
Cross-referencing the official Immich requirements doc:
| Requirement | Immich minimum | Pi 4 8GB delivers | Verdict |
|---|---|---|---|
| CPU | x86_64 or arm64 | Cortex-A72 quad-core arm64 | OK |
| RAM | 4GB minimum, 6GB recommended | 8GB | OK |
| Storage | 10GB OS + library size | 32GB+ SD + USB-3 SSD | OK with USB SSD |
| Docker | Required | Supported on Raspberry Pi OS Lite | OK |
| Architecture | x86_64 or arm64 | arm64 | OK |
Immich's docker-compose stack runs a PostgreSQL 14 + Redis 7 + machine-learning worker + main API + microservices + web. Each service is a separate container; total resident memory on a quiet Pi after first boot lands around 1.8-2.2 GB. The 8GB ceiling leaves enough headroom for the ML worker to flex into 3-4 GB during a face-detection batch without OOM.
How do you add reliable storage?
You have three options, in order of preference for a Pi 4:
1. USB-3 SATA SSD (best balance). A 1TB SATA SSD like the Crucial BX500 at ~$70 or the Samsung 870 EVO at ~$60 (250GB) connected via a USB-3.0 to SATA adapter. Sustained read/write 250-350 MB/s after the UAS driver kicks in. The FIDECO SATA/IDE to USB 3.0 Adapter is a reliable choice that doubles as a tool for imaging your old drives later.
2. USB-3 NVMe enclosure. A 1TB NVMe like the WD Blue SN550 in a USB-3 enclosure. Faster on paper, but the Pi 4 USB-3 controller caps real throughput around 380 MB/s anyway, so the SATA route wins on cost-per-GB without losing speed.
3. Bare USB-3 stick. Tempting but wrong. Most USB sticks have terrible random-write performance and burn through cells. Avoid for any database-backed app, full stop.
A reasonable BOM for a 1TB Immich library:
| Component | Pick | Approx price |
|---|---|---|
| Host | Raspberry Pi 4 Model B 8GB | $75 |
| Storage | Crucial BX500 1TB SATA SSD | $70 |
| USB-3 SATA adapter | FIDECO SATA/IDE to USB 3.0 | $25 |
| Boot SD card | SanDisk 32GB U3 | $10 |
| Power supply | Official Pi 4 USB-C 5.1V/3A | $10 |
| Case + fan | Argon ONE or equivalent | $30 |
| Total | ~$220 |
For ~$220 you have a complete Google Photos replacement with hardware you own outright.
Step-by-step: Docker install and first library import
This is the short version; refer to Immich's official deployment docs for the canonical commands as they evolve.
- Flash Raspberry Pi OS Lite (64-bit) to the SD card with the Raspberry Pi Imager. Set up SSH and user account in the imager's advanced options.
- Boot the Pi, SSH in, run
sudo apt update && sudo apt upgrade -y. - Install Docker + Compose:
curl -sSL https://get.docker.com | sh && sudo usermod -aG docker $USERand log out/in. - Format and mount the SSD at
/mnt/photoswithext4filesystem. - Download the Immich
docker-compose.ymland.envfrom the Immich GitHub release. - Edit
.envto setUPLOAD_LOCATION=/mnt/photos/immich, set a strongDB_PASSWORD, and confirmIMMICH_VERSION=release. - Start the stack:
docker compose up -d. - Browse to
http://<pi-ip>:2283, create the admin account, and start the first library import or install the mobile app to auto-upload from your phone.
First library import of 10,000 photos on the Pi 4 8GB takes ~6-10 hours; the ML face/object indexing then runs in the background over the following 24-72 hours. Both can be paused and resumed safely.
Benchmark numbers from the community
Public benchmarks from the Immich GitHub discussions and r/selfhosted threads — not first-party measurements:
| Operation | Pi 4 8GB throughput |
|---|---|
| Photo upload (single client, JPEG) | ~30-50 MB/s |
| Thumbnail generation (JPEG → 250px + 1080px) | ~8-12 photos/s |
| Face detection (per photo) | ~150-400 ms |
| CLIP object/text embedding (per photo) | ~200-500 ms |
| Smart-search query latency | <200 ms once indexed |
| Library scan (10,000 photos cold) | 6-10 hours |
| Backup over USB-3 to second SSD | ~280 MB/s sustained |
The bottleneck is consistently the ML worker, not the web UI. UI navigation stays responsive even while indexing runs in the background.
Does ML face/object search work acceptably on the Pi?
Yes, but with caveats. The Immich ML worker on the Pi runs CLIP and InsightFace models on CPU. Per-image inference is ~150-500ms depending on model size. For a 20,000-photo library that adds up to 50-180 minutes of compute — fine as an overnight batch, painful as a real-time pipeline.
If you want faster ML — a 100,000+ photo library or a desire for sub-hour index times — there are two paths:
- Offload the ML worker. Run the
immich-machine-learningcontainer on a separate desktop with a GPU, and point the Pi-hosted API at it. Indexing time drops by an order of magnitude. The full guide is in Immich's own docs. - Use a Coral USB accelerator. The Coral M.2/USB accelerator brings hardware-accelerated TFLite to the Pi. Immich does not officially target Coral but the community has experimental support.
For most users with sub-50K libraries, the overnight-batch model is good enough and not worth the extra complexity.
Power and 24/7 reliability
A Pi 4 8GB under typical Immich load draws ~3.5-5 W idle and 6-8 W during indexing — under $10/year in electricity at average US rates. The official 5.1V/3A Pi 4 PSU is the only PSU worth running; cheap USB-C bricks brown out under load and corrupt the SSD.
Reliability checklist:
- PSU: official Pi 4 USB-C only. No third-party "5V/3A" bricks.
- Cooling: an Argon ONE case or active heatsink. The Pi 4 throttles aggressively above 80°C and indexing keeps it hot.
- Filesystem: ext4 on the SSD. Avoid exFAT/NTFS — fine on Windows, fragile under Linux.
- Power events: a $25 USB UPS shim (Pi-UpTime, PiJuice) survives mains blips without filesystem corruption.
- Watchdog:
systemctl enable rpi-watchdogso a hung kernel reboots in <60 seconds.
Backup — 3-2-1 on a $200 build
The 3-2-1 rule (3 copies, 2 media, 1 offsite) applies even to a personal photo server.
- Copy 1: Live on the Crucial BX500 1TB attached to the Pi.
- Copy 2: Mirrored nightly to a second SSD or HDD. Use
rsync -a --delete /mnt/photos/ /mnt/backup/photos/in a cron job. - Copy 3 (offsite): Weekly encrypted upload to a cloud bucket — Backblaze B2 at ~$0.005/GB/month is the cost leader, Hetzner Storage Box at €3.20/TB-month a close second.
rclone syncwith client-side encryption keeps the cloud provider blind to the contents.
For a 500GB library the offsite tier costs $2.50-$5/month — still cheaper than the Google One Standard 2TB tier at $10/month.
Perf-per-watt vs a mini-PC alternative
A 2026 Intel N100 mini-PC (e.g. Beelink S12, GMKtec NucBox) costs $130-$180 and idles around 6-8W. For Immich it is roughly 4-6x faster on ML inference than a Pi 4 because of the AVX2 instruction set, and posts comparable idle power.
When the mini-PC wins:
- Library size >50,000 photos
- You want sub-hour ML indexing
- You will host a few other services on the same box (Jellyfin, Vaultwarden, Home Assistant)
When the Pi 4 8GB wins:
- You already own a Pi 4 8GB
- The library is under 50,000 photos
- Power draw, fanless operation and small form-factor matter
- You want a clean single-purpose appliance
Common pitfalls on a Pi 4 Immich build
Five mistakes that show up in the Immich GitHub Discussions over and over:
- Powering the Pi from a cheap USB-C brick. Anything but the official 5.1V/3A Pi 4 PSU causes intermittent undervoltage warnings (the famous yellow lightning-bolt icon) and SSD corruption on power events. Spend the $10 on the official unit.
- Hosting the database on the SD card. PostgreSQL writes to the SD card will burn through cells in 6-12 months. Mount the entire Immich data directory (including the Postgres volume) on the USB-3 SSD.
- Skipping the Argon ONE / active cooling. A passively cooled Pi 4 throttles at ~80 °C, which during ML face-indexing turns a 6-hour batch into a 12-hour batch. Active cooling is the single highest-ROI accessory.
- Running on consumer-grade SD cards in the SSD slot. Class 10 / U1 / A1 cards work for the boot partition; only buy U3 / A2 cards if you must put writes on the SD card itself. The boot partition itself sees very little write activity once Immich is up.
- Forgetting to set
STATIC_FALLBACK=truein the docker env on arm64. A few transitive dependencies do not have arm64 wheels and need static fallbacks; without the flag, the container restarts on startup with cryptic Python errors.
Bottom line — who the Pi 4 8GB Immich build is right for
- Yes, if you have a sub-50K photo library, you want a $200 hardware budget, and you can accept overnight ML indexing.
- No, if your library is 100K+ photos, you want real-time ML, or you plan to run multiple heavy services on the same box.
The Pi 4 8GB is the cheapest credible Google Photos replacement that exists in 2026, and Immich is the only open-source server that actually replicates the Google Photos UX a non-technical household member will accept.
Related guides on SpecPicks
- Self-Host Jellyfin on a Raspberry Pi 4 8GB in 2026
- Build a RetroPie Console on a Raspberry Pi 4 8GB in 2026
- Can a Raspberry Pi 4 8GB Run Local LLMs in 2026?
- Best SSD for Local LLM Model Storage in 2026
- Best Storage Upgrades for Retro and Budget PC Builds in 2026
Citations and sources
- Immich official site and documentation — system requirements, supported architectures, docker-compose install path.
- Immich GitHub releases and discussions — community benchmarks on Pi 4 8GB throughput and ML worker behaviour.
- Raspberry Pi 4 Model B product page — official spec, USB-3 throughput, recommended PSU.
This piece is editorial synthesis based on publicly available information. No independent first-party benchmarking is reported.
