Outline vs Docmost

Both of these are Notion-shaped wikis: nested pages, spaces, live co-editing, a modern block editor. On features they are close enough that a feature table will not help you, and every roundup that publishes one is wasting your time.

The decision is made in two places that most articles skip. First, how you log in, where Outline has a hard requirement that disqualifies it for a large fraction of self-hosters. Second, what is actually inside the image you pull, where Docmost is more complicated than its AGPL badge suggests.

Outline cannot log you in without a third-party provider#

This is not a configuration preference. Outline's shipped .env.sample says plainly that credentials for at least one third-party sign-in provider are required, or you will have no sign-in options. There is no local username and password, no bootstrap admin, no reset link. Generic OIDC, Google, Slack, Microsoft Entra and Discord are the options.

For a company with Google Workspace or Entra, that is a non-issue and arguably a feature. For one person self-hosting a wiki, it means the dependency chain is:

1. Deploy an identity provider: Keycloak, authentik or Pocket ID, or Authelia's OIDC provider.
2. Register an Outline client in it.
3. Then deploy Outline.

And it means an IdP failure is an Outline outage. A wrong client secret, an expired certificate, a container that will not start after a host reboot: any of those and you cannot get into Outline to fix anything, because the fix is in the IdP. If you are going to run Outline, keep the IdP on separate infrastructure and keep a restore of it you have actually tested. Single sign-on for self-hosters is worth reading before you accept that trade for a single-user wiki.

Docmost's free edition has ordinary local accounts. First run gives you a setup page where you create the workspace and the owner account, and that is the whole ceremony.

What the spec table is telling you#

Three containers each, Postgres plus Redis each, port 3000 each, and RAM figures within 100 MB of each other. The rows that carry information are licence and sso. Outline is source-available; Docmost's sso value is none, which for a wiki in 2026 is a deliberate commercial decision rather than a missing feature. The ops load difference (4 for Outline, 3 for Docmost) is almost entirely Outline's hard IdP dependency plus secrets that are unrecoverable if lost.

Docmost's licence split, exactly#

The root LICENSE in the Docmost repository is AGPL-3.0 and the code you can clone genuinely is AGPL. The README then carves out three trees under a separate proprietary Docmost Enterprise licence:

• apps/server/src/ee
• apps/client/src/ee
• packages/ee

That server ee directory is a git submodule pointing at https://github.com/docmost/ee, a private repository that returns 404. So a plain git clone --recurse-submodules fails on it and you cannot rebuild the official image from public source. The docmost/docmost image you actually run in production contains closed code, dormant until an offline-validated licence key unlocks it.

What that key unlocks, precisely:

At 6 US dollars per seat per month with a ten seat minimum billed annually, the floor is roughly 720 dollars a year even if three people use it.

By comparison, BookStack and Wiki.js both ship OIDC, SAML and LDAP for free. If SSO is a requirement and you will not pay, this comparison is not the one you should be reading; see BookStack vs Wiki.js.

Outline's licence, exactly#

Outline is BUSL-1.1 with a Change Date of 1 September 2030, after which that release becomes Apache-2.0. Source-available, not open source, and it will not satisfy a policy that demands an OSI licence.

The restriction that matters is the Additional Use Grant: you may not run Outline as a "Document Service", meaning a commercial offering that lets third parties create their own teams and documents on your instance. Selling, reselling or hosting Outline as a service terminates your rights. Running it as your own company's internal wiki is explicitly fine. See Licence drift for how common this pattern has become.

So neither of these is the clean open source option. Docmost is closer, in that the source you clone is AGPL, but the artifact you deploy is not reproducible from it.

The secrets that make a backup incomplete#

Both projects have the same failure mode and both bury it.

Outline: SECRET_KEY encrypts values inside the database. Outline's own backup page warns that losing it makes all encrypted database content inaccessible, so a perfect pg_dump is not a complete backup. You also generate UTILS_SECRET, both with openssl rand -hex 32. And the backup page tells you to snapshot Postgres and save your environment variables without mentioning file storage, which is a trap: the sample default is FILE_STORAGE=local, writing every uploaded image to the /var/lib/outline/data volume. Restore the database without that volume and every document renders with broken images.

Docmost: APP_SECRET must be at least 32 characters and the app refuses to start on the placeholder REPLACE_WITH_LONG_SECRET. Attachments and pasted images go to /app/data/storage under the default STORAGE_DRIVER=local, and nothing in the dump brings them back.

The complete backup set for either one is three things:

# database
docker compose exec -T db pg_dump -U <user> <db> > wiki-$(date +%F).sql
# uploads volume (Outline: /var/lib/outline/data, Docmost: /app/data/storage)
docker run --rm -v <volume>:/src -v "$PWD":/out alpine \
  tar czf /out/wiki-files-$(date +%F).tar.gz -C /src .
# and the .env file, stored somewhere other than this host

Restore order for both: database up, restore the dump, restore files, then start the app so migrations settle against a complete schema. Rehearse it once using Backups that actually restore.

Stability: mature product versus 0.x#

Outline dates from 2016 and the editor shows it. Docmost's first release was 2024 and it is still on 0.x with real version jumps: v0.90.0 in May 2026, v0.90.1 a week later, then straight to v0.95.0 in July 2026 with 0.96 betas already published. A 0.x minor here is not a patch release. Pin an exact tag rather than latest, dump before each bump, and read the notes. An update strategy that does not lose data covers making that a habit rather than an emergency.

The verdict, by situation#

If you are one person and you came here to pick a personal wiki, the honest answer is that neither is aimed at you. BookStack costs less attention, Trilium Notes costs far less RAM, and HedgeDoc does shared Markdown pads without accounts at all. Docmost is the right call in this pairing, not necessarily in the category.

What to do next#

Allocate a dedicated subdomain first, because Outline refuses subpaths outright and Docmost expects APP_URL to be the real public address. Reverse proxy and TLS has the config. If you are going the Outline route, deploy the identity provider first and test a login flow before you import a single document. Then compare the whole shape against alternatives in Documents. If this is a migration, Replace Notion covers getting the data out first.