# Reality Check on dumping PVE for NixOS with Docker-only infra — retained record

> Retained reddit record from reddit:homelab.

Canonical: https://highsignal.app/data/records/c371314bc5aabc76

[← sources](https://highsignal.app/data)


source: [reddit](https://highsignal.app/data/reddit) (reddit:homelab)  published 2026-10-31 13:17 ingested 2026-11-01 02:39

[original source ↗](https://www.reddit.com/r/homelab/comments/1xka02d/reality_check_on_dumping_pve_for_nixos_with/)

## retained text



```
Hello fellow homelabbers, I'm sharing a short story to get a reality check; this is not a "Docker vs. LXC vs. VM" question (hopefully). I'm a dev/ex-infra guy living abroad with my wife and a toddler, so I don't have much spare time.

TL;DR: I'm thinking of dropping PVE, PBS, Ansible, Pulumi, and custom IaC scripts for a NixOS host with Docker and everything in Docker Stacks. Is it maintainable and what am I missing that can f\*\*k me up in the future?

A couple of years ago, I had some services running on a Raspberry Pi and an old laptop, but with a kid on the way, I was looking into getting some services to help with keeping memories and making life easier (HA, Immich, etc.). Got a couple of M920q and Proxmox VE, and the amazing community-scripts got me where I wanted, with some rudimentary backups. I didn't want to use Docker, as it seemed unnecessary given that the scripts, LXC, and VMs covered most of my needs.

Then, for some reason, I started experiencing intermittent issues with some services and difficulty updating them, which led me to read all the scripts and remember how they worked, slowly throwing away the time I had initially saved by using them. At the same time, they were reengineering all scripts, which took even more time to adapt to, at a time I was mostly sleep-deprived. At that time, I decided to get away from community-scripts and start my own IaC. Given my familiarity with Ansible, Docker, VMs, etc., it sounded easy (I'm a dev, so I obviously can't estimate properly).

So I created an inventory.yaml with a defined schema, put all service definitions in there (hostname, disk size, memory, DNS entries, IPs, mounting points, etc.), used Pulumi to handle the infra and Ansible to set things up. I accept the fact that I would now need Docker, and I'd use the service recommended deploy mode instead of fighting it like some of the community-scripts did (and was the root of my issues).  
Now I have several VMs and LXCs with Docker, and while it works, handling different deployment methods has made my IaC repo larger than I wanted. I feel like I'm managing an unnecessary layer of abstraction: I have Proxmox, an LXC or VM, Docker, then several containers by Docker. Then I need to manage services that run on Docker, others as LXC, and a few on VMs.

Also, the number of services that provide an official Docker image/compose outnumbers those that run bare metal, and it seems simpler to just create a Docker Compose for them rather than maintain code to handle an LXC or VM. I already know Docker, k8s, k3s, Helm, etc., so the idea here is not to learn anything; I want to simplify things and keep it simple(r). I don't need high availability; I have only 2 PVE hosts for now, but most of my services have a fixed host (due to space constraints or hardware limitations).

Where I'd like a reality check, for anyone who runs a similar target setup: I'm thinking of replacing PVE with NixOS (easier to recreate if necessary) and running Docker bare metal on it. Pulumi would go away completely; I'd create a folder per physical host with subfolders for every service/docker stack. Each subfolder will hold a backup script, a restore procedure, and docs in an MD, as well as a Docker Compose with SOPS. Deployment would be just a git clone from the folder and run a script with docker compose up (or podman with systemd units, not decided yet). I'd keep renovate-bot deployed at my Gitea instance to update everything. Adding/removing a new service means creating a folder with a backup script and a Docker Compose file; that is it. Backup is just creating a snapshot of the volume driver and, depending on the service, a DB dump. No more endless validations, Ansible books, Pulumi code, nothing. Testing a backup restore involves duplicating the Docker stack and restoring volumes to a different folder. I'd keep macvlan so I can filter the services' IPs on my OPNsense. I know I am getting one fewer abstraction, and that might be less secure if a container escapes root and likely requires more complicated firewall settings on the Docker host (Docker chains), but it seems worth the simplicity. The reason I'd like a reality check is that my past self avoided Docker at first, and now I'm all in on it. Is it maintainable long term? Am I missing something?
```



document fetched 2026-11-01 00:33 · canonical https://reddit.com/r/homelab/comments/1xka02d/reality_check_on_dumping_pve_for_nixos_with
