DEV Community

Elder Fernandes
Elder Fernandes

Posted on Originally published at selfhoststack-8z4.pages.dev

Self-Hosted Document Management in 2026: Paperless-ngx vs Docspell vs Mayan EDMS

#devops #selfhosted #opensource #docker

Self-Hosted Document Management & OCR in 2026: Paperless-ngx vs Docspell vs Mayan EDMS

Businesses and individuals generate an endless stream of digital and physical paper: tax invoices, contracts, receipts, bank statements, warranties, medical records, and legal correspondence.

Relying on commercial document storage SaaS (such as Evernote, Adobe Acrobat Cloud, Google Drive OCR, or Dropbox Doc Scanner) comes with severe trade-offs:

  1. Privacy & Data Snooping: Your most sensitive financial and legal records are processed on third-party cloud servers and potentially mined for machine learning training.
  2. Subscription Fatigue & Storage Tiers: Pricing scales aggressively as file counts grow ($10–$25/user/month), with strict API rate limits for automated bulk ingestion.
  3. Proprietary Metadata Lock-in: Categorization tags, document hierarchies, and custom fields cannot be seamlessly exported without losing structured search metadata.

In 2026, self-hosted Electronic Document Management Systems (EDMS) have matured into enterprise-grade powerhouses capable of automated document scanning, multi-language Optical Character Recognition (OCR), automated tagging via machine learning, full-text Elasticsearch/Whoosh indexing, and S3-compatible archival.

In this guide, we compare Paperless-ngx, Docspell, and Mayan EDMS, and provide a battle-tested Docker Compose deployment of Paperless-ngx configured with Redis, Gotenberg, Apache Tika, and automated backups.

1. Architectural Comparison: Paperless-ngx vs Docspell vs Mayan EDMS

Feature / Metric Paperless-ngx (Latest 2026) Docspell Mayan EDMS
Primary Target Homelabs, Freelancers, SMBs Home offices, Multi-user Teams Enterprise, Regulated Industries
Backend Stack Python (Django, Celery), Redis, PostgreSQL Scala, Solr, PostgreSQL Python (Django, Celery), RabbitMQ, PostgreSQL
OCR Engine Tesseract 5 + Gotenberg + Tika Tesseract OCR Tesseract OCR + Custom Pipelines
Machine Learning Tagging Built-in Scikit-learn Classifier Built-in NLP Classifier Custom Pipeline Stages
RAM Footprint (Idle) ~500 MB – 800 MB ~750 MB – 1.2 GB ~1.5 GB – 3.0 GB
Ingestion Methods Network Share (Consume dir), IMAP Email, REST API, Mobile Apps Web, IMAP, Android App, CLI REST API, Watch Folders, IMAP, SANE Scanner
PDF Office Rendering Native via Gotenberg (DOCX, ODT, XLSX to PDF) Native converters LibreOffice subprocesses
Storage Architecture File system + S3 / NFS mount support PostgreSQL / S3 object store S3, Local Disk, GridFS
User Interface UX Modern Vue.js/Bootstrap 5 SPA, Fast Filters Modern Web UI Traditional Enterprise Django UI

2. Deep Dive: Choosing Your Document Engine

1. Paperless-ngx (The Gold Standard for 95% of Users)

Paperless-ngx is by far the most popular and actively maintained open-source document management system.

  • Automated Workflow Routing: Automatically assigns tags, correspondents, document types, and custom fields based on sender matching or ML pattern recognition.
  • Gotenberg & Tika Integration: Converts Word documents (.docx), Excel spreadsheets (.xlsx), and rich emails (.eml) into standardized PDF/A documents for permanent archival.
  • Mobile Ecosystem: First-class third-party Android and iOS scanner companion apps (e.g., Paperless Mobile, QuickScan) allow point-and-shoot scanner ingestion directly to your server via TLS.

2. Docspell (Heavyweight Multi-User Categorization)

Docspell is built in Scala and uses Apache Solr for lightning-fast search indexing. It excels in multi-tenant family or team setups where distinct user accounts require granular separation of document vaults with automated item matching.

3. Mayan EDMS (Complex Enterprise Governance)

Mayan EDMS is designed for organizations requiring strict legal compliance, multi-stage approval workflows, document versioning revisions, electronic signatures, and granular role-based access control (RBAC). It has a steep learning curve and higher resource footprint, making it ideal for enterprise compliance teams rather than single operators.

3. Production Docker Compose Architecture for Paperless-ngx

To ensure maximum performance and document ingestion reliability, we run Paperless-ngx with a dedicated PostgreSQL database, Redis task queue, Gotenberg (for office document conversion), and Apache Tika (for rich document text extraction).

Create your docker-compose.yml:

version: "3.8"

networks:
  internal_net:
    driver: bridge
  proxy_net:
    external: true

services:
  broker:
    image: docker.io/library/redis:7-alpine
    container_name: paperless-redis
    restart: unless-stopped
    volumes:
      - redis_data:/data
    networks:
      - internal_net
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

  db:
    image: docker.io/library/postgres:16-alpine
    container_name: paperless-postgres
    restart: unless-stopped
    environment:
      POSTGRES_DB: paperless
      POSTGRES_USER: paperless
      POSTGRES_PASSWORD: ${DB_PASS:-ChangeThisSuperSecurePass}
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - internal_net
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U paperless"]
      interval: 10s
      timeout: 5s
      retries: 5

  gotenberg:
    image: docker.io/gotenberg/gotenberg:8
    container_name: paperless-gotenberg
    restart: unless-stopped
    command:
      - "gotenberg"
      - "--chromium-disable-javascript=true"
      - "--chromium-allow-list=file:///tmp/.*"
    networks:
      - internal_net

  tika:
    image: docker.io/apache/tika:latest
    container_name: paperless-tika
    restart: unless-stopped
    networks:
      - internal_net

  webserver:
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    container_name: paperless-web
    restart: unless-stopped
    depends_on:
      db:
        condition: service_healthy
      broker:
        condition: service_healthy
      gotenberg:
        condition: service_started
      tika:
        condition: service_started
    environment:
      PAPERLESS_REDIS: redis://broker:6379
      PAPERLESS_DBENGINE: postgresql
      PAPERLESS_DBHOST: db
      PAPERLESS_DBPORT: 5432
      PAPERLESS_DBNAME: paperless
      PAPERLESS_DBUSER: paperless
      PAPERLESS_DBPASS: ${DB_PASS:-ChangeThisSuperSecurePass}
      PAPERLESS_URL: https://docs.yourdomain.com
      PAPERLESS_SECRET_KEY: ${PAPERLESS_SECRET:-GenerateRandom32CharString}
      PAPERLESS_TIME_ZONE: "UTC"
      PAPERLESS_OCR_LANGUAGE: "eng,deu,por,spa,fra"
      PAPERLESS_TIKA_ENABLED: 1
      PAPERLESS_TIKA_GOTENBERG_ENDPOINT: http://gotenberg:3000
      PAPERLESS_TIKA_ENDPOINT: http://tika:9998
      PAPERLESS_TASK_WORKERS: 2
      PAPERLESS_CONSUMER_POLLING: 10
      PAPERLESS_ENABLE_HTTP_REMOTE_USER: "false"
    volumes:
      - paperless_data:/usr/src/paperless/data
      - paperless_media:/usr/src/paperless/media
      - paperless_export:/usr/src/paperless/export
      - ./consume:/usr/src/paperless/consume
    networks:
      - internal_net
      - proxy_net
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.paperless.rule=Host(`docs.yourdomain.com`)"
      - "traefik.http.routers.paperless.entrypoints=websecure"
      - "traefik.http.routers.paperless.tls.certresolver=letsencrypt"
      - "traefik.http.services.paperless.loadbalancer.serverport=8000"

volumes:
  redis_data:
  db_data:
  paperless_data:
  paperless_media:
  paperless_export:
Enter fullscreen mode Exit fullscreen mode

4. Initial Setup & Superuser Creation

Once the containers are deployed, initialize the administrative user:

docker compose exec webserver python3 manage.py createsuperuser
Enter fullscreen mode Exit fullscreen mode

Enter your administrative username, email, and secure password. Access the dashboard at https://docs.yourdomain.com.

Enabling Automated Ingestion Channels:

  1. Network Scanner Folder (Samba/NFS): Point your home/office multi-function physical printer to drop scans directly into the ./consume folder. Paperless automatically detects new files, runs OCR, rotates orientation, saves the original PDF/A, and deletes the raw file from the consume directory.
  2. IMAP Email Scraping: Configure Mail Accounts inside the Paperless UI to periodically poll an inbox (e.g., invoices@yourdomain.com). It extracts attached PDFs and receipts automatically, discarding spam.

5. Automated Disaster Recovery & Offsite Backups

Never risk losing indexed tax and legal documents. Implement an automated backup cron job using Paperless's built-in exporter:

#!/bin/bash
set -eo pipefail
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_DIR="/data/backups/paperless"
mkdir -p "$BACKUP_DIR"

# 1. Export documents and metadata index into decrypted export volume
docker compose exec -T webserver document_exporter ../export

# 2. Archive and encrypt
tar -czf "$BACKUP_DIR/paperless_$TIMESTAMP.tar.gz" -C ./export .
docker compose exec -T db pg_dump -U paperless paperless | gzip > "$BACKUP_DIR/db_$TIMESTAMP.sql.gz"

# 3. Ship to offsite S3 / Backblaze B2 / Rclone storage
rclone copy "$BACKUP_DIR/" remote_backup:secure-docs-vault/paperless/ --include "*$TIMESTAMP*"

# 4. Clean local files older than 14 days
find "$BACKUP_DIR" -name "paperless_*.tar.gz" -mtime +14 -delete
find "$BACKUP_DIR" -name "db_*.sql.gz" -mtime +14 -delete
Enter fullscreen mode Exit fullscreen mode

6. Conclusion & Savings Summary

By deploying Paperless-ngx on an economical €5.50/mo VPS (or home server), you eliminate:

  • Evernote / Dropbox Document Hubs: Savings of ~$180/year per user.
  • Adobe Acrobat Pro Cloud: Savings of ~$240/year per user.
  • Snooping & Cloud Exposure: 100% data sovereignty under your cryptographic control.

For complete curated guides, infrastructure benchmarks, and production Docker configurations, explore SelfHostStack.

Top comments (0)