HedgeDoc: Collaborative Markdown Editor

Introduction

HedgeDoc (formerly known as CodiMD) is the best-in-class, self-hosted platform for collaborative markdown editing. It combines the simplicity of markdown with powerful real-time collaboration features, making it perfect for technical documentation, meeting notes, knowledge bases, and even presentations.

What is HedgeDoc?

HedgeDoc is an open-source, web-based markdown editor that allows multiple users to work on the same document simultaneously. It features a split-pane interface with markdown on the left and a live preview on the right, syntax highlighting for code blocks, diagram support (Mermaid, PlantUML), mathematical equations (KaTeX), and presentation mode (reveal.js).

Why Choose HedgeDoc?

Markdown-First Philosophy

Unlike WYSIWYG editors that hide complexity behind formatting buttons, HedgeDoc embraces markdown’s simplicity and power. Write documentation the way developers prefer - in plain text with semantic markup. Everything is version-controlled and future-proof.

Real-Time Collaboration

Multiple users can edit the same document simultaneously with changes appearing instantly. Each user gets a colored cursor indicator, and changes are synchronized through WebSockets with operational transformation to prevent conflicts.

Rich Feature Set

HedgeDoc goes beyond basic markdown:

Syntax highlighting for 100+ programming languages
Mermaid diagrams (flowcharts, sequence diagrams, Gantt charts)
PlantUML support for UML diagrams
KaTeX for mathematical notation
Embedded content (YouTube, Vimeo, SlideShare, PDFs)
Table of contents auto-generation
Presentation mode with reveal.js
Task lists with checkboxes
Import/Export (Markdown, HTML, PDF)

Privacy and Data Ownership

Your documentation lives on your infrastructure. No vendor access, no data mining, no surprise ToS changes. Perfect for sensitive technical documentation, internal wikis, or personal knowledge management.

Developer-Friendly

HedgeDoc is built by developers for developers. It understands code, supports technical diagrams, integrates with authentication systems (OAuth, LDAP, SAML), and provides API access for automation.

HedgeDoc vs Alternatives

Feature	HedgeDoc	Etherpad	Notion	Obsidian
Markdown Native	Yes	Plugin	Partial	Yes
Real-time Collab	Excellent	Excellent	Good	Sync-based
Code Highlighting	100+ langs	Basic	Limited	Yes
Diagrams	Mermaid/PlantUML	Plugin	Database	Plugin
Math Equations	KaTeX	No	KaTeX	MathJax
Presentation Mode	Yes	No	No	Plugin
Self-Hosted	Yes	Yes	No	Local-first
API Access	Yes	Yes	Limited	No
Best For	Tech Docs	Quick Notes	All-in-one	PKM

Architecture Overview

Understanding HedgeDoc’s architecture:

┌────────────────────────────────────────┐
│       Users (Web Browsers)             │
└──────────┬──────────────┬──────────────┘
           │              │
    ┌──────▼──────┐  ┌───▼──────┐
    │  WebSocket  │  │   HTTP   │
    └──────┬──────┘  └───┬──────┘
           │             │
    ┌──────▼─────────────▼──────┐
    │   Reverse Proxy + SSL     │
    └──────────┬────────────────┘
               │
    ┌──────────▼────────────┐
    │  HedgeDoc (Node.js)   │
    │  - Express Server     │
    │  - Socket.io          │
    │  - Sequelize ORM      │
    └──────────┬────────────┘
               │
    ┌──────────▼────────────┐
    │     Database          │
    │  PostgreSQL/MySQL     │
    │  MariaDB/SQLite       │
    └───────────────────────┘
               │
    ┌──────────▼────────────┐
    │   Optional Services   │
    │  - MinIO (uploads)    │
    │  - LDAP/OAuth         │
    └───────────────────────┘

Key Components:

Node.js Application: Core HedgeDoc server
Database: Stores notes, revisions, users
WebSocket Server: Real-time synchronization
Reverse Proxy: HTTPS termination
Storage Backend: Local filesystem or S3-compatible for uploads

Prerequisites

Before deploying HedgeDoc:

Docker and Docker Compose installed
1GB RAM minimum (2GB recommended)
2 CPU cores
10GB storage space
Domain name with DNS configured
PostgreSQL or MariaDB (SQLite for testing only)
Reverse proxy for HTTPS
Basic understanding of markdown

Basic Deployment: PostgreSQL Backend

Let’s deploy HedgeDoc with PostgreSQL for production use.

Step 1: Environment Configuration

# Create directory
mkdir -p ~/hedgedoc && cd ~/hedgedoc

# Create environment file
cat > .env <<EOF
# HedgeDoc Configuration
CMD_DOMAIN=docs.yourdomain.com
CMD_URL_ADDPORT=false
CMD_PROTOCOL_USESSL=true

# Database Configuration
POSTGRES_DB=hedgedoc
POSTGRES_USER=hedgedoc
POSTGRES_PASSWORD=your-secure-postgres-password

# Database connection for HedgeDoc
CMD_DB_URL=postgres://hedgedoc:your-secure-postgres-password@postgres:5432/hedgedoc

# Session secret (generate with: openssl rand -hex 32)
CMD_SESSION_SECRET=$(openssl rand -hex 32)

# Allow anonymous access
CMD_ALLOW_ANONYMOUS=true
CMD_ALLOW_ANONYMOUS_EDITS=true

# Allow free URL
CMD_ALLOW_FREEURL=true

# Image upload
CMD_IMAGE_UPLOAD_TYPE=filesystem

# Email (optional)
CMD_EMAIL=false

# Domain
DOMAIN=docs.yourdomain.com
EOF

chmod 600 .env

Step 2: Docker Compose Configuration

Create docker-compose.yml:

version: '3.8'

services:
  # PostgreSQL Database
  postgres:
    image: postgres:15-alpine
    container_name: hedgedoc-postgres
    restart: unless-stopped

    environment:
      - POSTGRES_DB=${POSTGRES_DB}
      - POSTGRES_USER=${POSTGRES_USER}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}

    volumes:
      - postgres_data:/var/lib/postgresql/data

    networks:
      - hedgedoc-net

    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER}"]
      interval: 10s
      timeout: 5s
      retries: 5

  # HedgeDoc Application
  hedgedoc:
    image: quay.io/hedgedoc/hedgedoc:latest
    container_name: hedgedoc
    restart: unless-stopped

    depends_on:
      postgres:
        condition: service_healthy

    environment:
      - CMD_DOMAIN=${CMD_DOMAIN}
      - CMD_URL_ADDPORT=${CMD_URL_ADDPORT}
      - CMD_PROTOCOL_USESSL=${CMD_PROTOCOL_USESSL}
      - CMD_DB_URL=${CMD_DB_URL}
      - CMD_SESSION_SECRET=${CMD_SESSION_SECRET}
      - CMD_ALLOW_ANONYMOUS=${CMD_ALLOW_ANONYMOUS}
      - CMD_ALLOW_ANONYMOUS_EDITS=${CMD_ALLOW_ANONYMOUS_EDITS}
      - CMD_ALLOW_FREEURL=${CMD_ALLOW_FREEURL}
      - CMD_IMAGE_UPLOAD_TYPE=${CMD_IMAGE_UPLOAD_TYPE}

    ports:
      - "3000:3000"

    volumes:
      # Persistent uploads
      - hedgedoc_uploads:/hedgedoc/public/uploads

    networks:
      - hedgedoc-net

    healthcheck:
      test: ["CMD", "wget", "-q", "--spider", "http://localhost:3000/"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s

volumes:
  postgres_data:
  hedgedoc_uploads:

networks:
  hedgedoc-net:
    driver: bridge

Step 3: Launch HedgeDoc

# Start services
docker-compose up -d

# Watch logs
docker-compose logs -f hedgedoc

# Wait for "HTTP Server listening at port 3000"

Access HedgeDoc at http://localhost:3000

Production Deployment with Advanced Features

Enhanced configuration with authentication and storage options:

version: '3.8'

services:
  # PostgreSQL Database
  postgres:
    image: postgres:15-alpine
    container_name: hedgedoc-postgres
    restart: unless-stopped
    environment:
      - POSTGRES_DB=${POSTGRES_DB}
      - POSTGRES_USER=${POSTGRES_USER}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - hedgedoc-net
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER}"]
      interval: 10s
      timeout: 5s
      retries: 5

  # MinIO for S3-compatible storage (optional)
  minio:
    image: minio/minio:latest
    container_name: hedgedoc-minio
    restart: unless-stopped
    command: server /data --console-address ":9001"
    environment:
      - MINIO_ROOT_USER=minioadmin
      - MINIO_ROOT_PASSWORD=minioadmin-secret
    volumes:
      - minio_data:/data
    ports:
      - "9000:9000"
      - "9001:9001"
    networks:
      - hedgedoc-net

  # HedgeDoc Application
  hedgedoc:
    image: quay.io/hedgedoc/hedgedoc:latest
    container_name: hedgedoc
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy

    environment:
      # Domain Configuration
      - CMD_DOMAIN=${CMD_DOMAIN}
      - CMD_URL_ADDPORT=false
      - CMD_PROTOCOL_USESSL=true

      # Database
      - CMD_DB_URL=${CMD_DB_URL}

      # Security
      - CMD_SESSION_SECRET=${CMD_SESSION_SECRET}
      - CMD_SESSION_LIFE=1209600000  # 14 days in milliseconds
      - CMD_HSTS_ENABLE=true
      - CMD_CSP_ENABLE=true

      # Access Control
      - CMD_ALLOW_ANONYMOUS=true
      - CMD_ALLOW_ANONYMOUS_EDITS=true
      - CMD_ALLOW_FREEURL=true
      - CMD_REQUIRE_FREEURL_AUTHENTICATION=false
      - CMD_DEFAULT_PERMISSION=editable  # freely, editable, limited, locked, protected, private

      # Features
      - CMD_ALLOW_EMAIL_REGISTER=true
      - CMD_ALLOW_PDF_EXPORT=true
      - CMD_ALLOW_GRAVATAR=true

      # Image Upload - S3
      - CMD_IMAGE_UPLOAD_TYPE=s3
      - CMD_S3_ENDPOINT=http://minio:9000
      - CMD_S3_BUCKET=hedgedoc
      - CMD_S3_ACCESS_KEY_ID=minioadmin
      - CMD_S3_SECRET_ACCESS_KEY=minioadmin-secret

      # Or use filesystem
      # - CMD_IMAGE_UPLOAD_TYPE=filesystem

      # Performance
      - CMD_WORKERS=auto

      # Optional: LDAP Authentication
      # - CMD_LDAP_URL=ldap://ldap.yourdomain.com
      # - CMD_LDAP_BINDDN=cn=admin,dc=yourdomain,dc=com
      # - CMD_LDAP_BINDCREDENTIALS=admin-password
      # - CMD_LDAP_SEARCHBASE=ou=users,dc=yourdomain,dc=com
      # - CMD_LDAP_SEARCHFILTER=(&(uid={{username}})(objectClass=person))
      # - CMD_LDAP_USERIDFIELD=uid

      # Optional: OAuth2 (example with GitHub)
      # - CMD_OAUTH2_CLIENT_ID=your-github-client-id
      # - CMD_OAUTH2_CLIENT_SECRET=your-github-client-secret
      # - CMD_OAUTH2_AUTHORIZATION_URL=https://github.com/login/oauth/authorize
      # - CMD_OAUTH2_TOKEN_URL=https://github.com/login/oauth/access_token
      # - CMD_OAUTH2_USER_PROFILE_URL=https://api.github.com/user
      # - CMD_OAUTH2_USER_PROFILE_USERNAME_ATTR=login
      # - CMD_OAUTH2_USER_PROFILE_DISPLAY_NAME_ATTR=name
      # - CMD_OAUTH2_USER_PROFILE_EMAIL_ATTR=email

    ports:
      - "3000:3000"

    volumes:
      - hedgedoc_uploads:/hedgedoc/public/uploads

    networks:
      - hedgedoc-net

    deploy:
      resources:
        limits:
          memory: 2G
        reservations:
          memory: 512M

volumes:
  postgres_data:
  hedgedoc_uploads:
  minio_data:

networks:
  hedgedoc-net:
    driver: bridge

Authentication Configuration

HedgeDoc supports multiple authentication methods.

Email Registration

environment:
  - CMD_ALLOW_EMAIL_REGISTER=true
  - CMD_EMAIL=true
  - [email protected]
  - CMD_EMAIL_TRANSPORT=smtp
  - CMD_EMAIL_SMTP_HOST=smtp.gmail.com
  - CMD_EMAIL_SMTP_PORT=587
  - CMD_EMAIL_SMTP_SECURE=false
  - CMD_EMAIL_SMTP_USER=your-[email protected]
  - CMD_EMAIL_SMTP_PASSWORD=your-app-password

LDAP Authentication

environment:
  - CMD_LDAP_URL=ldap://ldap.yourdomain.com
  - CMD_LDAP_BINDDN=cn=admin,dc=yourdomain,dc=com
  - CMD_LDAP_BINDCREDENTIALS=admin-password
  - CMD_LDAP_SEARCHBASE=ou=users,dc=yourdomain,dc=com
  - CMD_LDAP_SEARCHFILTER=(uid={{username}})
  - CMD_LDAP_USERIDFIELD=uid
  - CMD_LDAP_USERNAMEFIELD=uid
  - CMD_LDAP_TLS_CA=/path/to/ca.crt

OAuth2 with GitHub

environment:
  - CMD_OAUTH2_PROVIDERNAME=GitHub
  - CMD_OAUTH2_CLIENT_ID=your-github-oauth-client-id
  - CMD_OAUTH2_CLIENT_SECRET=your-github-oauth-secret
  - CMD_OAUTH2_AUTHORIZATION_URL=https://github.com/login/oauth/authorize
  - CMD_OAUTH2_TOKEN_URL=https://github.com/login/oauth/access_token
  - CMD_OAUTH2_USER_PROFILE_URL=https://api.github.com/user
  - CMD_OAUTH2_USER_PROFILE_USERNAME_ATTR=login
  - CMD_OAUTH2_USER_PROFILE_DISPLAY_NAME_ATTR=name
  - CMD_OAUTH2_USER_PROFILE_EMAIL_ATTR=email

Create GitHub OAuth App:

Go to GitHub Settings → Developer settings → OAuth Apps
New OAuth App
Homepage URL: https://docs.yourdomain.com
Authorization callback URL: https://docs.yourdomain.com/auth/oauth2/callback
Copy Client ID and Secret

SAML with Authentik

environment:
  - CMD_SAML_IDPSSOURL=https://auth.yourdomain.com/application/saml/hedgedoc/sso/binding/redirect/
  - CMD_SAML_IDPCERT=/hedgedoc/idp_cert.pem
  - CMD_SAML_ISSUER=hedgedoc
  - CMD_SAML_IDENTIFIERFORMAT=urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress
  - CMD_SAML_ATTRIBUTE_ID=id
  - CMD_SAML_ATTRIBUTE_USERNAME=username
  - CMD_SAML_ATTRIBUTE_EMAIL=email

Reverse Proxy Configuration

Nginx Configuration

# /etc/nginx/sites-available/hedgedoc.conf

upstream hedgedoc {
    server localhost:3000;
}

server {
    listen 80;
    server_name docs.yourdomain.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name docs.yourdomain.com;

    # SSL Configuration
    ssl_certificate /etc/letsencrypt/live/docs.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/docs.yourdomain.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;

    # Security headers
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-XSS-Protection "1; mode=block" always;

    # Increase upload size for images
    client_max_body_size 100M;

    location / {
        proxy_pass http://hedgedoc;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # WebSocket support
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";

        # Timeouts
        proxy_connect_timeout 600s;
        proxy_send_timeout 600s;
        proxy_read_timeout 600s;
    }
}

Traefik Configuration

services:
  hedgedoc:
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.hedgedoc.rule=Host(`docs.yourdomain.com`)"
      - "traefik.http.routers.hedgedoc.entrypoints=websecure"
      - "traefik.http.routers.hedgedoc.tls.certresolver=letsencrypt"
      - "traefik.http.services.hedgedoc.loadbalancer.server.port=3000"

      # Headers middleware
      - "traefik.http.middlewares.hedgedoc-headers.headers.customrequestheaders.X-Forwarded-Proto=https"
      - "traefik.http.middlewares.hedgedoc-headers.headers.sslredirect=true"
      - "traefik.http.routers.hedgedoc.middlewares=hedgedoc-headers"

Caddy Configuration

docs.yourdomain.com {
    reverse_proxy hedgedoc:3000 {
        header_up X-Forwarded-Proto {scheme}
    }
}

Performance Optimization

Database Performance

# PostgreSQL tuning for HedgeDoc
postgres:
  command:
    - postgres
    - -c
    - shared_buffers=256MB
    - -c
    - max_connections=200
    - -c
    - effective_cache_size=1GB

Worker Processes

environment:
  # Auto-detect CPU cores
  - CMD_WORKERS=auto

  # Or set manually (recommended: CPU cores - 1)
  # - CMD_WORKERS=3

Caching Headers

In Nginx configuration:

location ~* .(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$ {
    proxy_pass http://hedgedoc;
    proxy_cache_valid 200 30d;
    add_header Cache-Control "public, immutable";
    expires 30d;
}

Advanced Features and Usage

Presentation Mode

Create presentations using markdown with reveal.js:

---
title: My Presentation
slideOptions:
  theme: night
  transition: 'fade'
---

# Slide 1

Content here

---

# Slide 2

More content

---

## Sub-slide

- Bullet point 1
- Bullet point 2

View in presentation mode by appending /slide to the URL.

Diagrams with Mermaid

# System Architecture

```mermaid
graph TD
    A[Client] -->|HTTPS| B[Nginx]
    B --> C[HedgeDoc]
    C --> D[PostgreSQL]
    C --> E[MinIO]


### Mathematical Equations

```markdown
Inline equation: $E = mc^2$

Block equation:
$$
int_{-infty}^{infty} e^{-x^2} dx = sqrt{pi}
$$

Task Lists

# Project TODO

- [x] Setup HedgeDoc
- [x] Configure authentication
- [ ] Write documentation
- [ ] Deploy to production

Embedding Content

# Embedded Video

{%youtube VIDEO_ID %}

# Embedded PDF

{%pdf https://example.com/document.pdf %}

# Embedded Gist

{%gist USERNAME/GIST_ID %}

Monitoring and Maintenance

Health Checks

# Check HedgeDoc health
curl https://docs.yourdomain.com/status

# Monitor logs
docker-compose logs -f hedgedoc

# Resource monitoring
docker stats hedgedoc

Database Maintenance

# Vacuum PostgreSQL
docker exec hedgedoc-postgres vacuumdb -U hedgedoc -d hedgedoc -v -f -z

# Check database size
docker exec hedgedoc-postgres psql -U hedgedoc -d hedgedoc -c "SELECT pg_size_pretty(pg_database_size('hedgedoc'));"

# Backup database
docker exec hedgedoc-postgres pg_dump -U hedgedoc hedgedoc > hedgedoc-backup-$(date +%Y%m%d).sql

Log Management

# View logs
docker-compose logs hedgedoc

# Follow logs
docker-compose logs -f hedgedoc

# Export logs
docker-compose logs hedgedoc > hedgedoc-logs-$(date +%Y%m%d).log

Backup and Recovery

Automated Backup Script

# Create backup script
cat > ~/hedgedoc-backup.sh <<'EOF'
#!/bin/bash
BACKUP_DIR="/mnt/backups/hedgedoc"
DATE=$(date +%Y%m%d_%H%M%S)

# Backup database
docker exec hedgedoc-postgres pg_dump -U hedgedoc hedgedoc > $BACKUP_DIR/hedgedoc-db-$DATE.sql

# Backup uploads
docker run --rm   -v hedgedoc_hedgedoc_uploads:/uploads:ro   -v $BACKUP_DIR:/backup   alpine tar czf /backup/hedgedoc-uploads-$DATE.tar.gz -C /uploads .

# Remove backups older than 30 days
find $BACKUP_DIR -name "hedgedoc-db-*.sql" -mtime +30 -delete
find $BACKUP_DIR -name "hedgedoc-uploads-*.tar.gz" -mtime +30 -delete

echo "Backup completed: $DATE"
EOF

chmod +x ~/hedgedoc-backup.sh

# Schedule daily backups
crontab -e
# Add: 0 2 * * * /home/user/hedgedoc-backup.sh

Restore from Backup

# Restore database
cat hedgedoc-db-20250115.sql | docker exec -i hedgedoc-postgres psql -U hedgedoc -d hedgedoc

# Restore uploads
docker run --rm   -v hedgedoc_hedgedoc_uploads:/uploads   -v /path/to/backups:/backup   alpine tar xzf /backup/hedgedoc-uploads-20250115.tar.gz -C /uploads

# Restart HedgeDoc
docker-compose restart hedgedoc

Troubleshooting

Issue: Cannot Connect to Database

# Check database is running
docker-compose ps postgres

# Check database logs
docker-compose logs postgres

# Verify connection string
docker exec hedgedoc env | grep CMD_DB_URL

# Test connection manually
docker exec hedgedoc-postgres psql -U hedgedoc -d hedgedoc -c "SELECT 1;"

Issue: WebSocket Connection Failed

# Check browser console for errors
# Should see successful WebSocket upgrade (status 101)

# Verify reverse proxy WebSocket configuration
# Nginx: ensure Upgrade and Connection headers are set
# Traefik: check that middleware allows WebSocket

# Test direct connection
curl -i -N -H "Connection: Upgrade" -H "Upgrade: websocket" http://localhost:3000/socket.io/

Issue: Images Not Uploading

# Check upload configuration
docker exec hedgedoc env | grep CMD_IMAGE_UPLOAD_TYPE

# For filesystem uploads, check permissions
docker exec hedgedoc ls -la /hedgedoc/public/uploads

# For S3, verify MinIO access
docker exec hedgedoc curl http://minio:9000

# Check upload size limits in reverse proxy
# Nginx: client_max_body_size

Issue: Authentication Not Working

# Check authentication configuration
docker exec hedgedoc env | grep -E 'CMD_(LDAP|OAUTH|SAML)'

# View authentication logs
docker-compose logs hedgedoc | grep -i auth

# Test LDAP connection
docker exec hedgedoc ldapsearch -H ldap://ldap.yourdomain.com -D "cn=admin,dc=yourdomain,dc=com" -w password -b "ou=users,dc=yourdomain,dc=com"

Issue: High Memory Usage

# Check current memory usage
docker stats hedgedoc

# Reduce workers
# In docker-compose.yml:
environment:
  - CMD_WORKERS=2

# Set memory limits
deploy:
  resources:
    limits:
      memory: 1G

# Restart HedgeDoc
docker-compose restart hedgedoc

Security Best Practices

Enable CSP and HSTS

environment:
  - CMD_CSP_ENABLE=true
  - CMD_HSTS_ENABLE=true
  - CMD_CSP_REPORTURI=https://docs.yourdomain.com/csp-report

Disable Anonymous Edits

For private documentation:

environment:
  - CMD_ALLOW_ANONYMOUS=false
  - CMD_ALLOW_ANONYMOUS_EDITS=false
  - CMD_DEFAULT_PERMISSION=private

Regular Updates

# Check current version
docker exec hedgedoc cat package.json | grep version

# Update to latest
docker-compose pull hedgedoc
docker-compose up -d hedgedoc

# Verify new version
docker exec hedgedoc cat package.json | grep version

Use Cases

Technical Documentation

API documentation
Architecture diagrams with Mermaid
Code snippets with syntax highlighting
Changelogs and release notes

Meeting Notes

Real-time collaborative note-taking
Task lists for action items
Embedded presentations for reviews
Version history for accountability

Knowledge Base

Internal wiki
Troubleshooting guides
How-to articles
Team playbooks

Education

Lecture notes with math equations
Programming tutorials with code
Study guides with diagrams
Collaborative student projects

Conclusion

You now have a fully functional HedgeDoc deployment providing:

Powerful markdown-based collaborative editing
Real-time synchronization
Rich feature set (diagrams, math, presentations)
Multiple authentication options
Production-ready performance

Next Steps

Configure authentication for your team
Create documentation templates
Set up automated backups
Explore presentation mode
Integrate with CI/CD pipelines

Resources

Your collaborative documentation platform is ready for production use!