How to Self-Host Outline: Notion Alternative for Team Wikis 2026

TL;DR

Outline is a modern team wiki and knowledge base — BSL license (free for self-hosting), ~29K GitHub stars, built with Node.js and React. It has a Notion-like block editor, real-time collaboration, search, SSO via OIDC/Slack/Google, and S3 document storage. Replace Notion ($8–15/user/month) with your own instance. Requires Node.js, PostgreSQL, Redis, and S3-compatible storage.

Key Takeaways

Outline: BSL (Business Source License) — free for self-hosting under 3 years old, then converts to Apache 2.0
~29K stars, Node.js + React, real-time collaborative editing
SSO: OIDC (connects to Authentik, Keycloak, Google, Slack, GitHub)
Storage: S3-compatible required (MinIO for self-hosted, or Backblaze B2, AWS S3)
Requirements: 1GB RAM, PostgreSQL, Redis, S3 storage
vs Notion: No per-user pricing, data stays on your server, same editing UX

Outline vs Notion vs BookStack vs Wiki.js

Feature	Outline	Notion	BookStack	Wiki.js
License	BSL (free self-host)	Proprietary	MIT	AGPL 3.0
Editor	Block-based	Block-based	WYSIWYG	Markdown + visual
Real-time collab	✅	✅	❌	❌
Self-hostable	✅	❌	✅	✅
SSO	✅ OIDC	✅	✅ LDAP	✅ Many
API	✅ REST	✅	✅	✅
Monthly cost	~$10–15 VPS	$8–15/user	~$6/month	~$6/month
GitHub Stars	~29K	—	~15K	~24K

BookStack: Better for structured documentation (books/chapters/pages hierarchy). Simpler to self-host. Wiki.js: Stores content as Markdown in Git — great for developer documentation. Outline: Best for team knowledge bases with Notion-like UX.

Prerequisites

Outline requires an S3-compatible storage bucket for file attachments and images. Set up MinIO first (or use Backblaze B2/AWS S3):

Option A: MinIO (fully self-hosted S3)

# Add to docker-compose.yml:
  minio:
    image: quay.io/minio/minio:latest
    command: server /data --console-address ":9001"
    ports:
      - "9000:9000"    # S3 API
      - "9001:9001"    # Console UI
    environment:
      MINIO_ROOT_USER: "${MINIO_ROOT_USER}"
      MINIO_ROOT_PASSWORD: "${MINIO_ROOT_PASSWORD}"
    volumes:
      - minio_data:/data

Create a bucket outline in MinIO console after startup.

Option B: Backblaze B2 (cheapest managed)

Create a B2 bucket and Application Key — use those credentials in Outline's config.

Part 1: Docker Compose Setup

# docker-compose.yml
version: '3.8'

services:
  outline:
    image: outlinewiki/outline:latest
    container_name: outline
    restart: unless-stopped
    ports:
      - "3000:3000"
    env_file:
      - .env
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started

  postgres:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_DB: outline
      POSTGRES_USER: outline
      POSTGRES_PASSWORD: "${POSTGRES_PASSWORD}"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U outline"]
      interval: 10s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7-alpine
    restart: unless-stopped

volumes:
  postgres_data:

Environment Configuration

# .env — Outline configuration

# Core
SECRET_KEY=$(openssl rand -hex 32)
UTILS_SECRET=$(openssl rand -hex 32)
URL=https://wiki.yourdomain.com
PORT=3000
NODE_ENV=production

# Database
DATABASE_URL=postgres://outline:${POSTGRES_PASSWORD}@postgres:5432/outline
REDIS_URL=redis://redis:6379

# S3 Storage (MinIO example)
AWS_ACCESS_KEY_ID=your-minio-access-key
AWS_SECRET_ACCESS_KEY=your-minio-secret-key
AWS_REGION=us-east-1
AWS_S3_UPLOAD_BUCKET_URL=https://minio.yourdomain.com
AWS_S3_UPLOAD_BUCKET_NAME=outline
AWS_S3_FORCE_PATH_STYLE=true
AWS_S3_ACL=private

# S3 Storage (Backblaze B2 example)
# AWS_ACCESS_KEY_ID=your-b2-key-id
# AWS_SECRET_ACCESS_KEY=your-b2-application-key
# AWS_REGION=us-west-004
# AWS_S3_UPLOAD_BUCKET_URL=https://s3.us-west-004.backblazeb2.com
# AWS_S3_UPLOAD_BUCKET_NAME=outline-documents
# AWS_S3_FORCE_PATH_STYLE=true

# Authentication — pick one or more:

# Option 1: Slack OAuth
SLACK_CLIENT_ID=your-slack-client-id
SLACK_CLIENT_SECRET=your-slack-client-secret

# Option 2: Google OAuth
GOOGLE_CLIENT_ID=your-google-client-id
GOOGLE_CLIENT_SECRET=your-google-client-secret

# Option 3: OIDC (Authentik, Keycloak, etc.)
OIDC_CLIENT_ID=outline
OIDC_CLIENT_SECRET=your-oidc-secret
OIDC_AUTH_URI=https://auth.yourdomain.com/application/o/authorize/
OIDC_TOKEN_URI=https://auth.yourdomain.com/application/o/token/
OIDC_USERINFO_URI=https://auth.yourdomain.com/application/o/userinfo/
OIDC_USERNAME_CLAIM=preferred_username
OIDC_DISPLAY_NAME=Authentik
OIDC_SCOPES=openid profile email

# Email (for invite emails, optional but recommended)
SMTP_HOST=smtp.yourdomain.com
SMTP_PORT=587
SMTP_USERNAME=outline@yourdomain.com
SMTP_PASSWORD=smtp-password
SMTP_FROM_EMAIL=outline@yourdomain.com
SMTP_SECURE=false

# Feature flags
ENABLE_UPDATES=false   # Disable update checks

docker compose up -d

Visit https://wiki.yourdomain.com → log in via SSO → create your first workspace.

Part 2: HTTPS with Caddy

wiki.yourdomain.com {
    reverse_proxy localhost:3000
}

Part 3: Set Up OIDC with Authentik

If you're using Authentik (covered in our Authentik guide):

Authentik → Applications → Create Application
- Name: Outline
- Slug: outline
Create Provider (OAuth2/OIDC):
- Redirect URIs: https://wiki.yourdomain.com/auth/oidc.callback
- Scopes: openid, email, profile
- Copy Client ID and Secret
Update .env with the OIDC credentials
Restart: docker compose up -d

Users log in with their Authentik account — no separate Outline user creation needed.

Part 4: Creating and Organizing Content

Document Structure

Outline organizes content as:

Workspace
  └── Collections (e.g., "Engineering", "Product", "HR")
        └── Documents (with nesting)
              └── Sub-documents

Creating Documents

New document → type / to see block commands
Available blocks:
- /heading1, /heading2, /heading3
- /bullet-list, /numbered-list
- /code — code block with syntax highlighting
- /callout — highlighted info box
- /image — upload or embed
- /table — spreadsheet-style table
- /mention — @ mention a team member

Templates

Create reusable templates:

Document → "Convert to template"
Templates appear in new document dialog
Great for meeting notes, incident reports, project briefs

Settings → Integrations → Slack
Authorize Slack workspace
Set channel for notifications

Share documents publicly (no login required):

Document → Share → Create public link
Share the URL with anyone
Revoke access anytime from the share settings

API Access

# List documents:
curl https://wiki.yourdomain.com/api/documents.list \
  -H "Authorization: Bearer your-api-token" \
  -H "Content-Type: application/json" \
  -d '{"collectionId": "collection-id"}'

# Create a document:
curl -X POST https://wiki.yourdomain.com/api/documents.create \
  -H "Authorization: Bearer your-api-token" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "New Document",
    "text": "# Hello World\n\nThis is a document.",
    "collectionId": "collection-id",
    "publish": true
  }'

Generate API tokens in Settings → API Tokens.

Part 6: Import from Notion

Outline has a built-in Notion importer:

Settings → Import
Select Notion
Export your Notion workspace as HTML (Notion → Settings → Export → HTML)
Upload the ZIP to Outline
Outline creates collections matching your Notion databases

Maintenance

# Update Outline:
docker compose pull
docker compose up -d

# Backup database:
docker exec outline-postgres-1 pg_dump -U outline outline | \
  gzip > outline-db-$(date +%Y%m%d).sql.gz

# S3/MinIO data is stored separately — back up via rclone/Restic

# Check Outline logs:
docker compose logs -f outline

Cost Comparison

Option	Monthly Cost (10 users)
Notion Plus	$10/user = $100/month
Confluence	$5.75/user = $57.50/month
Notion Business	$15/user = $150/month
Outline self-hosted	~$10–15/month (VPS + B2 storage)

At 10 users, Outline self-hosted pays for itself vs Notion in the first month.

See all open source Notion alternatives at OSSAlt.com/alternatives/notion.