Published

Outline

Team knowledge base and wiki: Markdown-style documents in collections, real-time co-editing, search, comments and an API. Self-hosting for your own team is allowed under its Business Source License, but sign-in always goes through an external provider (OIDC, Google, Slack, Microsoft or email links). The stack is Outline, PostgreSQL and Redis, with attachments on local disk.

Resources by load level

What the app itself needs at each level, next to what we recommend for a server that runs only this app.

Level	What it means	App requirements	Recommended
LightEstimate	Up to 25 members, ~2,000 documents, a few people editing at once, under 5 GB of attachments.	1.75 vCPU · 2.25 GiB RAM · 13.5 GiB disk	2.22 vCPU · 4.2 GiB RAM · 25.07 GiB disk
MediumEstimate	Up to 150 members, ~20,000 documents, 10–20 people editing at once, up to 20 GB of attachments.	2.25 vCPU · 3.25 GiB RAM · 28.5 GiB disk	2.82 vCPU · 5.4 GiB RAM · 42.32 GiB disk
HeavyEstimate	Up to 500 members, ~100,000 documents, dozens editing at once, up to 50 GB of attachments; beyond this, scale out with a separate collaboration service.	3.75 vCPU · 7.5 GiB RAM · 103.75 GiB disk	4.62 vCPU · 10.5 GiB RAM · 128.858 GiB disk

Recommended = app requirements + system baseline + safety headroom, under sizing policy 2026.10.0. Options stay at their defaults. “Estimate” means the sources give no number for that case, so it is worked out from them by the method stated under Components. How the numbers are built

Size it in the Stack Sizer

Ready-to-run files

Support level Supported

Compose template from the official sources; not yet verified by a run.

Create docker-compose

Components

What each component needs at each load level, before baseline and headroom.

vCPU / GiB RAM / GiB disk
Component	Light	Medium	Heavy	Sources
Outline (web, API, collaboration, worker) (app)	0.5 / 1 / 6.5	1 / 2 / 21.5	1.5 / 3 / 51.5	[3][15][21][26][31][32][36][38]
PostgreSQL (database)	1 / 1 / 6.5	1 / 1 / 6.5	2 / 4 / 51.5	[10][27][43][44][45][46][47][48][49]
Redis (queues, cache, rate limiter) (cache)	0.25 / 0.25 / 0.5	0.25 / 0.25 / 0.5	0.25 / 0.5 / 0.75	[17][21][39]

How the estimates are worked out

Outline (web, API, collaboration, worker) · Light: RAM: the documented recommendation of 1 GB (minimum 512 MB), GB taken as GiB. Outline runs one Node process here (collaboration without REDIS_COLLABORATION_URL), so .env.sample's 512 MB-per-process rule gives the same. vCPU: no upstream figure; a few concurrent editors keep one process well under a core. Disk: Image 303,766,972 B compressed (0.283 GiB) + 1,154,121,728 B unpacked (1.075 GiB), both kept by the containerd store = 1.358 GiB. + 5 GiB of attachments (ANAROQ assumption) = 6.358, rounded up to 6.5.
Outline (web, API, collaboration, worker) · Medium: RAM: twice the documented 1 GB recommendation, which grows with the number of users; Outline sets its V8 heap to ~80% of a container limit. vCPU: one full core for the single Node process that serves web, API, WebSockets, collaboration and jobs (ANAROQ estimate). Disk: Image 303,766,972 B compressed (0.283 GiB) + 1,154,121,728 B unpacked (1.075 GiB), both kept by the containerd store = 1.358 GiB. + 20 GiB of attachments (assumption) = 21.358, rounded up to 21.5.
Outline (web, API, collaboration, worker) · Heavy: One Node process (collaboration without REDIS_COLLABORATION_URL), which the docs say fits teams under ~1000 active users. vCPU: 1.5, one busy event loop plus GC and I/O threads; a single process can't use much more. RAM: 3 × the documented 1 GB recommendation for more open documents and WebSockets (ANAROQ estimate). Disk: Image 303,766,972 B compressed (0.283 GiB) + 1,154,121,728 B unpacked (1.075 GiB), both kept by the containerd store = 1.358 GiB. + 50 GiB of attachments (assumption) = 51.358, rounded up to 51.5.
PostgreSQL · Light: Embedded metadata DB with the image's default config: equals the PostgreSQL profile's light preset (≤ 5 GB data, ≤ 20 concurrent connections) at every load level. Light preset method: shared_buffers 25% of RAM, worst-case work_mem/maintenance_work_mem budget, 0.5 GiB image + 5 GiB data + 1 GiB WAL.
PostgreSQL · Medium: Documents, revisions and the search index live in PostgreSQL: 20,000 documents × an assumed 100 KB each with revisions ≈ 2 GB, inside the light envelope (≤ 5 GB). The pool is 5 connections per process (one process), under its 20. Light method: shared_buffers 25% of RAM, worst-case work_mem budget, 0.5 GiB image + 5 GiB data + 1 GiB WAL.
PostgreSQL · Heavy: 100,000 documents × an assumed 100 KB each with revisions and search vectors ≈ 10 GB, beyond the 5 GB sidecar envelope, so the PostgreSQL profile's medium preset (≤ 50 GB). Medium method: shared_buffers 1 GiB = 25%, worst-case work_mem budget for 100 connections, 0.5 GiB image + 50 GiB data + 1 GiB WAL.
Redis (queues, cache, rate limiter) · Light: No upstream figure: the docs ask only for a single Redis 4+ server. It holds job queues, cache and rate-limiter counters, so a quarter core and 0.25 GiB RAM (ANAROQ assumption). Disk: 43.8 MiB compressed image × 3 (131 MiB) + an RDB snapshot up to the 0.25 GiB dataset, rounded up to 0.5 GiB.
Redis (queues, cache, rate limiter) · Medium: As light: queues, cache and rate-limiter counters stay small; 0.25 vCPU, 0.25 GiB RAM and 0.5 GiB disk (131 MiB image + RDB snapshot). ANAROQ assumption, no upstream figure.
Redis (queues, cache, rate limiter) · Heavy: Twice the light RAM for more queued jobs, cached data and per-IP rate-limiter keys: 0.5 GiB. Disk: 131 MiB image (43.8 MiB compressed × 3) + an RDB snapshot up to the 0.5 GiB dataset, rounded up to 0.75 GiB. ANAROQ assumption, no upstream figure.

Ports

Public ports are meant to be reached from outside the stack, usually through a reverse proxy; internal ones stay on the stack's own network.

Component	Port	Exposure	Purpose	Sources
Outline (web, API, collaboration, worker)	3000/tcp	Public, through a proxy	Web UI, API and WebSockets (collaboration); HTTP, put behind TLS	[2][3][5]
PostgreSQL	5432/tcp	Internal only	PostgreSQL connections from Outline	[2][4]
Redis (queues, cache, rate limiter)	6379/tcp	Internal only	Redis for Outline's queues, cache and rate limiter	[17][20]

Every port in the catalog, with conflicts between apps

User and permissions (UID/GID)

The user each container's process runs as, and the paths it writes to. A bind mount for one of these paths must be writable by that UID:GID.

Component	UID:GID	User	Starts as root	Writes to	Sources
Outline (web, API, collaboration, worker)	1001:1001	`nodejs`	No	`/var/lib/outline/data`	[5][15]
PostgreSQL	999:999	`postgres`	Yes, prepares its directories, then drops to this user	`/var/lib/postgresql/var/run/postgresql`	[41][42][48]
Redis (queues, cache, rate limiter)	999:999	`redis`	Yes, prepares its directories, then drops to this user	`/data`	[20][40]

Storage growth

How much each component's data grows per month at each load level, on top of the disk in the profile. A value marked Assumption is ANAROQ's stated assumption, not a figure from the sources; the notes say what it rests on.

GiB per month
Component	Light	Medium	Heavy	Sources
Outline (web, API, collaboration, worker)Assumption	0.25	1	3	[3][15]
PostgreSQLAssumption	0.05	0.2	0.5	[27][35]

What the growth figures rest on

Outline (web, API, collaboration, worker): Attachments and imports on the local volume: nothing expires them except deleting the documents they belong to (one file can be up to 250 MB with the template's FILE_STORAGE_UPLOAD_MAX_SIZE). Outline gives no growth figure; ANAROQ assumes a modest flow of images and files per active member.
PostgreSQL: Documents, their revision history, comments and events accumulate; only the trash is emptied, after 30 days (by the cron service the template enables). Outline gives no growth figure; this is an ANAROQ assumption.

Upgrade and rollback

How to move to a new version safely, and how to go back if it fails.

Back up first

pg_dump of the outline database, a copy of the attachments volume (/var/lib/outline/data), and the .env with SECRET_KEY. [15][27]

Upgrade steps

Back up the database (and the attachments volume) before every upgrade. [2][27]
Set the new pinned tag of outlinewiki/outline in docker-compose.yml, then run docker compose pull and docker compose up -d. [2]DerivedThe docs say to point docker-compose.yml at the new version and run the container; pull and up -d is how Compose applies a new tag.
Database migrations run automatically when the new container starts; watch the logs until /_health answers OK. [2][6]

Roll back

Migrations are not always backwards compatible, so going back means stopping the stack, restoring the database dump taken before the upgrade, and starting the old tag again. [27]DerivedThe backups guide warns that release migrations are not always backwards compatible; Outline documents no down-migration path for Docker, so the restore is the rollback.

Limits

There is no password sign-in: everyone signs in through an external provider. The template wires a generic OIDC provider (Keycloak, Authentik, Authelia, GitLab and others); Google, Slack, Microsoft or Discord need their own variables, and email magic links need SMTP (the smtp option). [3][13][24][25]
Licensed under the Business Source License 1.1, not an open-source license. Its Additional Use Grant allows any use, including production use for your own team, except offering a commercial "Document Service" in which third parties create their own teams and documents. Each version becomes Apache 2.0 four years after release (1.11.0 on 2030-10-12). SAML, the audit log and other features need a paid license. [22][23][29]
One Node process serves everything: without REDIS_COLLABORATION_URL, collaboration limits Outline to a single process, which the docs say suits teams under ~1000 active users. Scaling out needs a separate collaboration service, which this template doesn't add. [26][31]
Attachments are stored on the local volume (no S3), up to 250 MB per file as set in the template. Outline blocks requests to private network addresses by default, so a self-hosted OIDC provider on your LAN needs its IP in ALLOWED_PRIVATE_IP_ADDRESSES. [3][15][19]

Security

Serve Outline only over HTTPS, through a reverse proxy that forwards WebSockets: without them documents can't be edited. Behind the proxy the template sets URL to https://<domain> and keeps FORCE_HTTPS on. [12][16][19]
The first person to sign in creates the workspace and becomes its admin, and afterwards anyone your OIDC provider lets in can join as a member. Sign in right after the first start, then restrict access in Settings (allowed email domains, or require invites), or limit who may use the client in the provider. [33][34]
SECRET_KEY encrypts data in the database. Losing or changing it makes that data unreadable; the only recovery is a script that wipes encrypted data such as sessions, access tokens and integrations. [4][19][27]
A rate limiter is on by default (1000 requests per IP per minute, stricter on sensitive endpoints); keep it on when Outline faces the internet. [3][28]

Backup

Back up PostgreSQL daily and keep a month of backups, as the docs recommend, plus a dump before every upgrade: documents, revisions, users and settings live there. [27]
Back up the attachments volume (/var/lib/outline/data) together with the database: images and files are stored there, not in PostgreSQL. [2][15]
Keep the .env (SECRET_KEY above all) in a password manager or another encrypted store after every change; without SECRET_KEY, encrypted data in a restored database is lost. Settings → Export gives an extra copy in Markdown, HTML or JSON. [19][27]