Notion is a fine tool right up until you stop trusting it with your team's internal documentation. Maybe it's the price per seat once you cross ten users, maybe it's the idea of client credentials and internal runbooks sitting on someone else's servers, or maybe you just want your wiki to still exist if a SaaS company decides to pivot or shut down. Docmost is one of the better answers to that problem: an open-source, self-hosted alternative that gives you real-time collaborative documents, nested wiki spaces, and comments, running entirely on hardware you control.
Proxmox VE is a natural home for it. Instead of dedicating a whole VM to a note-taking app, you can drop Docmost into a lightweight LXC container that boots in seconds and uses a fraction of the RAM a full virtual machine would need. This guide walks through the whole process on a current Proxmox VE 9.2 host: creating the container, installing Docker inside it, and getting Docmost's three-container stack (app, PostgreSQL, Redis) up and answering requests on port 3000.
None of this requires prior Docker experience. If you've never typed docker compose before, you'll still be able to follow along — every command here is explained, not just pasted.
What You Will Learn
- What Docmost actually is and where it fits compared to Notion, Confluence, or a plain wiki
- How to create and configure an LXC container on Proxmox VE that's ready to run Docker
- How to install Docker Engine inside that container and deploy Docmost with Docker Compose
- How to generate the secrets Docmost needs and avoid the mistakes that break its login cookies
- How to troubleshoot the stack when a container won't start or the web page never loads
What Is This Feature?
Docmost is an open-source workspace for documentation and knowledge bases. Think Notion's editor combined with Confluence's structure: nested pages organized into "spaces," real-time collaborative editing where you can see a colleague's cursor move as they type, comments attached to specific blocks of text, and a permissions system for who can see or edit what. It's built with a modern editor (based on the same Tiptap/ProseMirror technology a lot of other collaborative tools use) and stores everything in a PostgreSQL database, with Redis handling real-time sync between connected users.
To run it, you'll be using an LXC container — a lightweight form of virtualization built into Proxmox VE. Unlike a full VM, which emulates its own virtual hardware and boots a complete kernel, an LXC container shares the host's kernel and just isolates a set of processes and filesystem. That makes it start almost instantly and use noticeably less RAM and disk than a comparable VM, which is exactly what you want for a single web app like this one.
Inside that container you'll install Docker, a tool for packaging an application and everything it depends on into a self-contained "container" (a different, more specific meaning of the word than the LXC container hosting it — yes, it's a bit confusing that both layers use "container"). Docmost ships as an official Docker image, and its recommended install method uses Docker Compose, a way of describing multiple related containers — the app, its database, its cache — in one YAML file so you can start or stop the whole stack with a single command.
Why Would You Use It?
The obvious case is cost. Notion's team plan adds up fast once you're past a handful of users, and Confluence licensing gets even less fun. Docmost is free and open source, and the only ongoing cost is the small VM or container it runs in — which, on hardware you already own for a homelab, is effectively nothing.
Then there's control. Your documentation lives on a disk you can back up, encrypt, or move whenever you want. Nobody outside your network can read it unless you expose it, and there's no risk of an account getting locked or a service quietly deprecating a feature you depend on. For small businesses handling anything remotely sensitive — client contracts, internal passwords references, HR notes — that matters more than a slicker UI.
It's also genuinely a good editor, not just a "good enough" open-source stand-in. Real-time collaboration, page history, diagrams, and a reasonably fast search all work out of the box. I wouldn't put it head-to-head against Notion's AI features, because it doesn't try to compete there, but as a straightforward team wiki it holds up well.
Prerequisites
Before you start, make sure you have the following:
- A working Proxmox VE host — this guide was written against Proxmox VE 9.2, but the steps are essentially identical on any current 8.x or 9.x install
- A Debian 13 (or Debian 12) LXC template downloaded, or access to download one from the built-in template list
- At least 2 CPU cores and 4 GB of RAM free to assign to the container — Docmost, Postgres, and Redis together are lighter than they sound, but 4 GB gives you comfortable headroom
- Roughly 15-20 GB of free storage for the container's disk
- Basic comfort typing commands into a terminal — you don't need to know Docker already, just be willing to copy commands carefully
- Optional but recommended for real use: a domain name or local DNS entry, since Docmost's real-time editing depends on cookies that behave better over HTTPS
Step-by-Step Tutorial
Step 1: Download the Debian 13 template
In the Proxmox VE web interface, click your node, then local (Storage), then CT Templates, then Templates. Search for debian-13 and download the standard template. If you'd rather use Debian 12 because it's what you already run elsewhere, that works fine too — nothing in Docmost cares which one you pick.
Step 2: Create the LXC container
Click Create CT in the top right. On the General tab, give it a hostname like docmost and set a root password (or add an SSH key). On the Template tab, pick the Debian 13 template you just downloaded. On Disks, 16-20 GB is plenty for the app and database unless you plan to upload a lot of large attachments. On CPU, 2 cores is a sensible default. On Memory, set 4096 MB with roughly 512 MB of swap. On Network, a DHCP address on your usual bridge (typically vmbr0) is fine to start with — you can switch to a static IP later.
Leave the container as Unprivileged unless you have a specific reason not to; it's the safer default and works fine with Docker once nesting is enabled, which is the next step.
Step 3: Enable nesting so Docker can run inside the container
Docker needs a couple of kernel features that aren't turned on by default in an unprivileged container. After creating the container (don't start it yet), go to its Options tab, select Features, and enable nesting and keyctl. You can also do this from the host shell:
pct set 105 -features nesting=1,keyctl=1Replace 105 with your container's actual VMID, which you'll see in the left-hand tree in the Proxmox VE web UI.
Step 4: Start the container and log in
Start the container from the web UI or with pct start 105, then open its console (or SSH in once you've set a static IP). Log in as root with the password you set earlier.
Step 5: Update the system and install Docker
Run an update first, then install Docker using the official convenience script — it's the fastest reliable path on a fresh Debian container:
apt update && apt upgrade -y
apt install -y curl ca-certificates
curl -fsSL https://get.docker.com | shThat last command adds Docker's own repository and installs Docker Engine along with the Compose plugin. Confirm it worked with:
docker --version
docker compose versionBoth should print a version number. If either command isn't found, nesting probably isn't enabled — go back to Step 3.
Step 6: Create a directory for Docmost and its compose file
mkdir -p /opt/docmost
cd /opt/docmostNow generate a secret key. Docmost uses this to sign session cookies, and it has to be long and random:
openssl rand -hex 32Copy the output somewhere — you'll paste it into the compose file in a moment.
Step 7: Write the docker-compose.yml file
Create the file with a text editor (nano docker-compose.yml works fine on a fresh container) and paste in the following, adjusting the values marked in bold below:
services:
docmost:
image: docmost/docmost:latest
depends_on:
- db
- redis
environment:
APP_URL: 'http://192.168.1.50:3000'
APP_SECRET: 'paste-your-openssl-output-here'
DATABASE_URL: 'postgresql://docmost:changeme@db:5432/docmost?schema=public'
REDIS_URL: 'redis://redis:6379'
ports:
- "3000:3000"
restart: unless-stopped
volumes:
- docmost_data:/app/data/storage
db:
image: postgres:17
environment:
POSTGRES_DB: docmost
POSTGRES_USER: docmost
POSTGRES_PASSWORD: changeme
restart: unless-stopped
volumes:
- db_data:/var/lib/postgresql/data
redis:
image: redis:7
restart: unless-stopped
volumes:
- redis_data:/data
volumes:
docmost_data:
db_data:
redis_data:Three things to change before you save: replace 192.168.1.50 in APP_URL with your container's real IP address (or a domain name if you have one pointed at it), replace paste-your-openssl-output-here with the secret you generated in Step 6, and change changeme in both the POSTGRES_PASSWORD line and the DATABASE_URL line to the same strong password — they have to match exactly, or the app container won't be able to log into the database.
Step 8: Start the stack
docker compose up -dDocker will pull the three images — Docmost, Postgres, and Redis — which takes a minute or two depending on your internet connection. Once it's done, check that all three containers are actually running:
docker compose psYou should see three entries, all showing a status of "Up" or "running." If one shows "Restarting," skip ahead to the Troubleshooting section below.
Step 9: Open Docmost and create your workspace
From a browser on the same network, go to http://your-container-ip:3000. The first time you load it, Docmost walks you through creating a workspace name, an admin account, and your first space. From there it behaves like any other note-taking app — create pages, invite teammates, and start writing.
If you're planning to actually use this day to day rather than just try it out, put a reverse proxy with a real TLS certificate in front of it (Nginx Proxy Manager or Caddy both work well) and update APP_URL to the HTTPS address. Real-time collaboration and some cookie-based session behavior in Docmost don't work as reliably over plain HTTP once more than one person is using it.
Commands Explained
| Command | What it does |
|---|---|
pct set 105 -features nesting=1,keyctl=1 | Enables the kernel features an unprivileged LXC container needs before Docker will run inside it |
pct start 105 | Boots the container with the given VMID from the Proxmox VE host shell |
curl -fsSL https://get.docker.com | sh | Downloads and runs Docker's official install script, setting up Docker Engine and the Compose plugin together |
openssl rand -hex 32 | Generates a 64-character random hex string, used here as Docmost's session-signing secret |
docker compose up -d | Starts every service defined in docker-compose.yml in the background (detached mode) |
docker compose ps | Lists the containers defined in the compose file and their current status |
docker compose logs -f docmost | Streams the live log output of the Docmost app container, useful for catching startup errors |
docker compose down | Stops and removes the containers without touching the named volumes, so your data survives |
Common Errors
A handful of mistakes account for most of the trouble people run into here.
"Cannot connect to the Docker daemon" right after installing Docker almost always means nesting isn't enabled on the container, or you started the container before setting it and need to restart it after the change. Go back and check the Features tab, then run pct reboot 105 from the host.
The docmost container keeps restarting and the logs show a database authentication error. This is nearly always a mismatch between POSTGRES_PASSWORD in the db service and the password embedded in DATABASE_URL for the docmost service. They have to be identical, character for character — copy-paste one into the other rather than typing it twice.
The login page loads but you get logged out immediately after signing in, or real-time editing shows a disconnected icon. This is almost always an APP_URL problem — either it doesn't match the address you're actually using in the browser, or you're accessing Docmost over HTTP while a reverse proxy in front of it is rewriting things in a way that breaks cookies. Double-check that APP_URL matches exactly what's in your browser's address bar, protocol included.
"Bind for 0.0.0.0:3000 failed: port is already allocated." Something else in the container is already using port 3000. Check with ss -tulpn | grep 3000, stop whatever's holding it, or change the left-hand side of the ports mapping in the compose file (for example "3001:3000") and reload the page on the new port.
Troubleshooting
Start with logs — they solve most problems here far faster than guessing. Run docker compose logs -f from inside /opt/docmost to watch all three services at once, or add a service name (docker compose logs -f db) to isolate one.
If the container itself seems unresponsive, confirm from the Proxmox VE host that it's actually running: pct status 105. A container that shows as running but is unreachable is usually a networking issue rather than a Docmost issue — check that it picked up an IP with pct exec 105 -- ip a, and that you can ping its gateway.
Running low on disk inside the container will silently break Postgres in ways that are annoying to diagnose. Check with df -h before assuming the app itself is broken; a 90%+ full root filesystem is a common, boring cause of "everything just stopped working" reports.
If you changed an environment variable in the compose file and Docmost doesn't seem to notice, remember that editing the file alone doesn't restart the container — you need docker compose up -d again, which recreates any service whose configuration changed.
Best Practices
Back up the Postgres data, not just the LXC container. A vzdump snapshot of the whole container will catch everything on disk, including the Docker volumes, which is good enough for most homelab use — but if you want an application-consistent backup you can restore selectively, run a periodic pg_dump from inside the container and ship that file somewhere separate too.
Pin your image versions once you have something working. The compose file above uses docmost/docmost:latest, which is fine to get started, but "latest" can pull in a breaking change on a random Tuesday. Once you're happy with the setup, switch to a specific version tag and upgrade deliberately with docker compose pull followed by docker compose up -d.
Put it behind a reverse proxy with a real certificate if more than one person will use it. It's not just about looking professional — Docmost's real-time collaboration features lean on secure cookies and WebSocket connections that are more reliable over HTTPS.
Give the container real resource limits rather than leaving CPU and RAM unbounded. Two cores and 4 GB is comfortable for a small team; if you're running dozens of concurrent editors, watch the container's summary graphs in Proxmox VE and bump memory before you hit swap.
Frequently Asked Questions
Can I run Docmost in a VM instead of an LXC container?
Yes, and it works the same way — install Docker and run the same compose file. The LXC route just uses less RAM and boots faster, which is why it's the better default for a single app like this.
Does Docmost need internet access to work?
No, once it's installed it runs entirely offline. You only need internet access during setup to pull the Docker images and Debian packages.
Can I import my existing Notion pages?
Docmost supports importing Notion exports (the ZIP file Notion generates from its export feature) from the workspace settings. Formatting comes across reasonably well for text and headings; expect to manually fix some embeds and databases.
Is Docmost's free version missing important features?
The self-hosted community edition covers spaces, real-time editing, comments, page history, and permissions — everything most teams actually use day to day. Docmost also sells a paid cloud version and enterprise features like SSO, but you don't need either to run a solid internal wiki.
How do I update Docmost later?
From /opt/docmost, run docker compose pull to fetch newer images, then docker compose up -d to recreate the containers with them. Your data stays in the named volumes and isn't touched by the update.
What happens to my data if I delete the LXC container by accident?
If you haven't taken a backup, it's gone — Docker volumes live on the container's disk, and deleting the container deletes that disk. This is exactly why the Best Practices section above isn't optional reading.
Conclusion
Docmost is one of those self-hosted projects that actually feels finished rather than like a rough clone of something better. Running it in a Proxmox VE LXC container costs you maybe fifteen minutes of setup and a few hundred megabytes of RAM, and in exchange you get a private, collaborative wiki that isn't tied to anyone else's pricing decisions or uptime. The setup here — one container, three Docker services, a reverse proxy if you want it — scales just fine from a personal notes app to a small team's actual documentation home. Once it's running, the maintenance is genuinely light: pull new images occasionally, back up the database, and otherwise leave it alone.