Outline

advanced

Modern team knowledge base and wiki.

Overview

Outline is an open-source team wiki and knowledge base platform built by the team behind Figma, designed to help organizations create, organize, and share documentation in real-time. Unlike traditional wiki software, Outline emphasizes collaborative editing with a modern interface that supports real-time collaboration, structured content organization through collections, and powerful search capabilities across all documentation. This Docker stack combines Outline with PostgreSQL for robust document and user data storage, Redis for session management and real-time features, and MinIO for S3-compatible file storage, creating a self-hosted alternative to services like Notion or Confluence. The architecture leverages PostgreSQL's full-text search capabilities for document indexing, Redis for caching frequently accessed content and managing WebSocket connections for live collaboration, while MinIO handles document attachments, images, and exported content with S3 API compatibility. This combination is ideal for development teams, startups, and organizations that need complete control over their knowledge base infrastructure while maintaining the modern collaborative features expected from cloud-based documentation platforms. The stack provides enterprise-grade document management without vendor lock-in, making it particularly valuable for teams with security requirements or those operating in air-gapped environments.

Key Features

Real-time collaborative markdown editing with conflict resolution powered by Redis WebSocket management
Full-text search across all documents using PostgreSQL's advanced text search with ranking and highlighting
S3-compatible file attachment handling through MinIO with automatic image optimization and CDN-like delivery
Collection-based document organization with nested structures stored efficiently in PostgreSQL
Document version history and audit trails leveraging PostgreSQL's MVCC transaction system
OAuth/OIDC/SAML authentication integration with session state managed through Redis
Slack integration for document notifications and slash commands with Redis-backed message queuing
Public document sharing with configurable permissions and Redis-cached access control

Common Use Cases

1Engineering teams maintaining technical documentation, API specs, and runbooks with real-time collaboration
2Startup knowledge bases requiring rapid content creation without per-user licensing costs
3Educational institutions hosting course materials and collaborative research documentation
4Open source projects providing contributor guides, architecture docs, and community wikis
5Consulting firms managing client documentation with granular access controls and audit trails
6Remote teams building company handbooks, processes, and institutional knowledge repositories
7Development teams integrating documentation workflows with Slack and GitHub for automated updates

Prerequisites

Minimum 4GB RAM (Outline: 1GB, PostgreSQL: 1GB, Redis: 512MB, MinIO: 2GB recommended)
Available ports 3000 (Outline web interface) and ensure no conflicts with existing services
OpenSSL or equivalent for generating SECRET_KEY and UTILS_SECRET (32-byte hex values required)
OAuth provider configured (Google, Slack, Azure AD, or custom OIDC) as Outline requires external authentication
Understanding of environment variable management for sensitive credentials and database passwords
MinIO administration knowledge for bucket creation and S3 access policy configuration

For development & testing. Review security settings, change default credentials, and test thoroughly before production use. See Terms

docker-compose.yml

1services: 
2  outline: 
3    image: outlinewiki/outline:latest
4    container_name: outline
5    restart: unless-stopped
6    environment: 
7      SECRET_KEY: ${SECRET_KEY}
8      UTILS_SECRET: ${UTILS_SECRET}
9      DATABASE_URL: postgres://outline:${DB_PASSWORD}@postgres:5432/outline
10      REDIS_URL: redis://redis:6379
11      URL: http://localhost:3000
12      PORT: 3000
13      AWS_ACCESS_KEY_ID: minio
14      AWS_SECRET_ACCESS_KEY: ${MINIO_PASSWORD}
15      AWS_REGION: us-east-1
16      AWS_S3_UPLOAD_BUCKET_URL: http://minio:9000
17      AWS_S3_UPLOAD_BUCKET_NAME: outline
18      AWS_S3_FORCE_PATH_STYLE: "true"
19      AWS_S3_ACL: private
20    ports: 
21      - "3000:3000"
22    depends_on: 
23      - postgres
24      - redis
25      - minio
26
27  postgres: 
28    image: postgres:15-alpine
29    container_name: outline-db
30    environment: 
31      POSTGRES_USER: outline
32      POSTGRES_PASSWORD: ${DB_PASSWORD}
33      POSTGRES_DB: outline
34    volumes: 
35      - outline_db:/var/lib/postgresql/data
36
37  redis: 
38    image: redis:7-alpine
39    container_name: outline-redis
40
41  minio: 
42    image: minio/minio:latest
43    container_name: outline-minio
44    command: server /data --console-address ":9001"
45    environment: 
46      MINIO_ROOT_USER: minio
47      MINIO_ROOT_PASSWORD: ${MINIO_PASSWORD}
48    volumes: 
49      - outline_minio:/data
50
51volumes: 
52  outline_db: 
53  outline_minio:

.env Template

.env

1SECRET_KEY=generate-a-32-byte-key-here
2UTILS_SECRET=generate-another-key-here
3DB_PASSWORD=changeme
4MINIO_PASSWORD=changeme123

Usage Notes

1Docs: https://docs.getoutline.com/
2Access at http://localhost:3000 - requires OIDC/SAML/Slack/Google auth
3Generate secrets: openssl rand -hex 32
4Create MinIO bucket before first use
5Real-time collaborative editing with markdown
6Integrations: Slack, Figma, Diagrams.net, GitHub

Individual Services(4 services)

Copy individual services to mix and match with your existing compose files.

outline

outline:
  image: outlinewiki/outline:latest
  container_name: outline
  restart: unless-stopped
  environment:
    SECRET_KEY: ${SECRET_KEY}
    UTILS_SECRET: ${UTILS_SECRET}
    DATABASE_URL: postgres://outline:${DB_PASSWORD}@postgres:5432/outline
    REDIS_URL: redis://redis:6379
    URL: http://localhost:3000
    PORT: 3000
    AWS_ACCESS_KEY_ID: minio
    AWS_SECRET_ACCESS_KEY: ${MINIO_PASSWORD}
    AWS_REGION: us-east-1
    AWS_S3_UPLOAD_BUCKET_URL: http://minio:9000
    AWS_S3_UPLOAD_BUCKET_NAME: outline
    AWS_S3_FORCE_PATH_STYLE: "true"
    AWS_S3_ACL: private
  ports:
    - "3000:3000"
  depends_on:
    - postgres
    - redis
    - minio

postgres

postgres:
  image: postgres:15-alpine
  container_name: outline-db
  environment:
    POSTGRES_USER: outline
    POSTGRES_PASSWORD: ${DB_PASSWORD}
    POSTGRES_DB: outline
  volumes:
    - outline_db:/var/lib/postgresql/data

redis

redis:
  image: redis:7-alpine
  container_name: outline-redis

minio

minio:
  image: minio/minio:latest
  container_name: outline-minio
  command: server /data --console-address ":9001"
  environment:
    MINIO_ROOT_USER: minio
    MINIO_ROOT_PASSWORD: ${MINIO_PASSWORD}
  volumes:
    - outline_minio:/data

Quick Start

terminal

1# 1. Create the compose file
2cat > docker-compose.yml << 'EOF'
3services:
4  outline:
5    image: outlinewiki/outline:latest
6    container_name: outline
7    restart: unless-stopped
8    environment:
9      SECRET_KEY: ${SECRET_KEY}
10      UTILS_SECRET: ${UTILS_SECRET}
11      DATABASE_URL: postgres://outline:${DB_PASSWORD}@postgres:5432/outline
12      REDIS_URL: redis://redis:6379
13      URL: http://localhost:3000
14      PORT: 3000
15      AWS_ACCESS_KEY_ID: minio
16      AWS_SECRET_ACCESS_KEY: ${MINIO_PASSWORD}
17      AWS_REGION: us-east-1
18      AWS_S3_UPLOAD_BUCKET_URL: http://minio:9000
19      AWS_S3_UPLOAD_BUCKET_NAME: outline
20      AWS_S3_FORCE_PATH_STYLE: "true"
21      AWS_S3_ACL: private
22    ports:
23      - "3000:3000"
24    depends_on:
25      - postgres
26      - redis
27      - minio
28
29  postgres:
30    image: postgres:15-alpine
31    container_name: outline-db
32    environment:
33      POSTGRES_USER: outline
34      POSTGRES_PASSWORD: ${DB_PASSWORD}
35      POSTGRES_DB: outline
36    volumes:
37      - outline_db:/var/lib/postgresql/data
38
39  redis:
40    image: redis:7-alpine
41    container_name: outline-redis
42
43  minio:
44    image: minio/minio:latest
45    container_name: outline-minio
46    command: server /data --console-address ":9001"
47    environment:
48      MINIO_ROOT_USER: minio
49      MINIO_ROOT_PASSWORD: ${MINIO_PASSWORD}
50    volumes:
51      - outline_minio:/data
52
53volumes:
54  outline_db:
55  outline_minio:
56EOF
57
58# 2. Create the .env file
59cat > .env << 'EOF'
60SECRET_KEY=generate-a-32-byte-key-here
61UTILS_SECRET=generate-another-key-here
62DB_PASSWORD=changeme
63MINIO_PASSWORD=changeme123
64EOF
65
66# 3. Start the services
67docker compose up -d
68
69# 4. View logs
70docker compose logs -f

One-Liner

Run this command to download and set up the recipe in one step:

terminal

1curl -fsSL https://docker.recipes/api/recipes/outline-wiki/run | bash

Troubleshooting

Authentication redirect loops: Verify URL environment variable matches your actual domain and OAuth provider redirect URIs
File upload failures with 'AccessDenied' errors: Create the outline bucket in MinIO and set proper S3 bucket policies through MinIO console
Slow document loading and search: Increase PostgreSQL shared_buffers and work_mem, ensure adequate RAM allocation to database container
Real-time collaboration not working: Check Redis connectivity and ensure WebSocket connections aren't blocked by reverse proxy configuration
Database migration failures on startup: Ensure PostgreSQL container fully initializes before Outline starts using depends_on and health checks
MinIO connection refused errors: Verify MINIO_ROOT_PASSWORD matches AWS_SECRET_ACCESS_KEY and MinIO container is accessible on port 9000

Community Notes

Loading notes...

Download Recipe Kit

Get all files in a ready-to-deploy package

Includes docker-compose.yml, .env template, README, and license

Components

outlinepostgresredisminio

Related Recipes

Ad Space

Shortcuts: C CopyF FavoriteD Download