Paperless-ngx vs Papermerge vs Mayan EDMS: Self-Hosted Document Management on VPS in 2026

Six months ago I migrated a Photography Studio Manager client's 11-year contract archive — about 18,400 scanned PDFs, model releases, invoices, and shoot briefs — off a creaking on-prem Synology and onto a self-hosted document management system on a $14/month VPS. The client was paying $190/month to a SaaS DMS that kept renaming their files and silently lost two folders during a 2025 migration. They wanted out, but they didn't want to trust another cloud vendor. So I tested all three of the serious open-source contenders side by side on the same Hetzner CX22 box, with the same exact dataset, for 90 days.

This article is the long-form result of that bake-off, updated with what I'm seeing in production now in May 2026. If you're choosing between Paperless-ngx, Papermerge, and Mayan EDMS for a self-hosted document management deployment on a VPS, here's everything I wish someone had told me before I started.

Why Self-Host a DMS in 2026 At All?

The reasons most of my clients ask about self-hosted document management in 2026 are not the ones I expected three years ago. It's no longer just "we want to avoid SaaS lock-in." It's three concrete pressures:

• Per-document SaaS pricing has crossed a pain threshold. DocuWare, M-Files Cloud, and PaperSave now sit between $35-$95 per user/month with document storage caps that bite hard once you ingest your back catalog.
• EU AI Act + US state privacy laws make data residency non-trivial. Several of my client projects (in legal, HR payroll, and healthcare) cannot legally ship documents to a vendor's training-eligible cloud anymore.
• OCR has gotten genuinely good open-source. Tesseract 5.4 with PaddleOCR fallback is honest-to-god competitive with commercial OCR for typed Latin-script docs, and runs fine on a 2-vCPU VPS if you tune the queue depth.

Across my 50+ projects shipped at wardigi.com, the systems that have needed real document workflows — Photography Studio Manager (contracts, releases, invoices), Smart HR Payroll (employment records, signed agreements), Helpdesk Ticketing (customer attachments), and the Hotel Management Suite (booking confirmations, ID scans) — every one ended up wanting a DMS, not just file storage. There's a real difference between "I can find the PDF in 8 seconds" and "I open Dropbox and lose 40 minutes."

The Three Contenders at a Glance

Before the deep dives, here's the comparison table I keep open in a tmux pane when scoping new DMS deployments. The numbers come from my Hetzner CX22 (2 vCPU, 4 GB RAM, 40 GB NVMe, Ubuntu 24.04) test deployment with the 18,400-doc Photography Studio archive.

I want to be specific about what those OCR numbers mean: I batched 100 PDFs ranging from clean digital invoices to 600-DPI scans of handwritten model releases with poor contrast. Same input set, same machine, same Tesseract version. The spread isn't huge — but if you're ingesting 50,000 documents in a backfill, that 50% difference between Paperless-ngx and Mayan EDMS becomes 90 minutes versus 140 minutes of CPU time. On a VPS that's billed per hour for burst CPU, that matters.

Paperless-ngx: The Default Pick for a Reason

Paperless-ngx is the fork of the original Paperless that the community took over when development stalled in 2020. In May 2026 it's at v2.21, ships under GPL-3.0, and has the most active GitHub repo of the three by a wide margin (around 21,000 stars as of this writing, vs ~3,400 for Papermerge and ~6,800 for Mayan EDMS).

What works in production:

• The "consume" folder is genius for VPS deployments. Mount it via SFTP or a Nextcloud sync, drop a PDF in, walk away — OCR, classification, tagging, and storage all happen async. I have a Hostinger VPS client whose accountant scans straight to the consume folder via a Brother scanner. Zero clicks per document.
• Storage paths are deceptively powerful. You can template the on-disk filename like {correspondent}/{created_year}/{title}, which means even if Paperless goes down, your raw PDFs are still browsable in a sane structure. I cannot overstate how much this matters for a 10-year contract archive.
• Auto-classification by ML is actually useful in 2026. After tagging the first ~50 documents manually, the built-in classifier (scikit-learn + TF-IDF, nothing fancy) correctly auto-assigns correspondent and document type on roughly 78-82% of new ingests for my Photography Studio client. Not magic, but it's pulling its weight.

What hurts:

• There's no true multi-tenancy. You can use groups and per-document permissions, but if you have three departments who absolutely must not see each other's documents, the right answer is three Paperless instances behind one reverse proxy — not one Paperless with clever ACLs.
• The intentionally flat structure (tags + correspondents + types instead of folders) is the right call for personal/SMB use but actively wrong for some workflows. Law firms with case-folder thinking hit this wall hard.
• Workflow automation is limited compared to Mayan EDMS. You get consumption rules and storage paths; you don't get "if approval=yes then move to cabinet X and notify role Y."

My recommendation: Paperless-ngx is the default DMS I deploy in 2026 for SMB clients, freelancers, and any team under ~15 users with mostly personal-archive workflows. On a 2 vCPU / 4 GB VPS with NVMe storage (think Hetzner CX22 at €4.51/mo or Contabo VPS S at $7/mo), it'll comfortably index 100k+ documents and stay responsive.

Papermerge: The Underrated Multi-Tenant Choice

Papermerge is the quiet one in this comparison. It runs lighter than Paperless-ngx (about 410 MB RAM idle versus Paperless's 540 MB), has true multi-tenant workspace separation built into the core data model, and ships with a clean React UI that is — I'll just say it — the most pleasant of the three on a phone screen.

Papermerge v3.x reorganized the architecture around "Documents-as-Records" and added a proper API-first design. The result is that if you're building anything custom on top — a portal where customers can view only their own files, a partner-facing document drop, a multi-client setup like an accounting practice — Papermerge is the only one of these three that doesn't require you to fight the data model.

What works in production:

• Real workspaces. Each "user space" is genuinely isolated at the data layer. I deployed Papermerge for a small accounting firm with 14 clients in March 2026, and each client gets their own login + folder tree that's invisible to others. Zero custom code.
• Nested folders + tags. Unlike Paperless's tag-only design, Papermerge supports nested folders, which my Hotel Management Suite client absolutely required for their season/property/guest-folder structure.
• Lighter footprint. I have it running on a $4/month Hetzner CX11-tier instance with 700+ documents and it doesn't even sweat. The lower memory makes it the obvious pick if you're consolidating multiple light-use deployments onto one VPS.

What hurts:

• Smaller community = slower bug fixes. I hit an OCR job hang in February 2026 (PaddleOCR fallback didn't release the worker properly) and the upstream fix took 19 days. With Paperless-ngx that would have been a 48-hour turnaround.
• No built-in document classifier. You tag manually or via API. For a personal-archive use case where Paperless's auto-classifier saves real minutes per day, this is a meaningful gap.
• Documentation lags behind the code. As of May 2026 the docs reference v2.x in several places while the current release is v3.4. You will find yourself reading source code.

My recommendation: Pick Papermerge when you need multi-tenancy, when nested folders are non-negotiable, or when you want to build something custom against a clean API. I would not pick it for a single-user personal archive — Paperless-ngx's classifier earns its keep there.

Mayan EDMS: The Heavyweight for Compliance Workflows

Mayan EDMS is what you reach for when "document management" actually means "regulated workflow with audit trails, electronic signatures, retention policies, role-based ACLs at the metadata-field level, and a workflow engine that lets you model multi-step approval chains."

It's also the heaviest of the three by a wide margin. The Docker image is 3.87 GB. Idle RAM with 1,000 indexed documents is 1.6 GB. The web UI is functional but visibly older than the other two. None of this is a dealbreaker for the use cases Mayan is meant for — it's a dealbreaker if you're trying to run it on a $4/month VPS to organize your tax receipts.

What works in production:

• The workflow engine is the real star. Document states, transitions, role-gated actions — you can model genuine business processes (invoice approval, contract sign-off, document retention review) without writing code. I built an HR onboarding workflow for a Smart HR Payroll client in about 4 hours that would have taken a week of Django glue in either of the other two.
• Cabinets + tags + smart links + metadata. The taxonomic surface is the widest of the three. Cabinets behave like virtual folders (one document can live in many), smart links auto-relate documents that share metadata values, and metadata fields can themselves be ACL-gated.
• Audit trail is comprehensive. Every view, edit, download, comment, and version change is logged with user, IP, and timestamp. For any client I've had subject to SOC 2 or HIPAA-adjacent requirements, this alone has been worth Mayan's weight.

What hurts:

• Operational complexity is real. Mayan EDMS uses RabbitMQ instead of Redis for the task queue and ships more separate worker processes (slow/fast/medium queues). On a 2 vCPU VPS this is fine; on a 1 vCPU shared instance it becomes a noisy neighbor problem.
• The UI feels like a 2018 Django admin in 2026. It works, but it's visually striking compared to Paperless-ngx's recent Angular rewrite.
• Upgrades require care. The migration path between major versions has historically broken people who don't read release notes. I've never personally lost data, but I've spent more time on Mayan upgrades than the other two combined.

My recommendation: Mayan EDMS is the right call when you have compliance obligations, formal workflows, multi-role approval chains, or document retention policies. It's the wrong call when you just want a tidy archive — the overhead won't pay off.

Performance Benchmarks I Actually Ran

Across the 90 days of the bake-off, I logged metrics with Beszel (a tool I covered in my VPS monitoring comparison) and pulled query-time numbers from each DMS's own admin panel. Here's what I saw on the same hardware, same dataset (18,400 documents, ~62 GB on disk after OCR):

A few things worth calling out from those numbers. First, Paperless-ngx's search latency advantage is mostly the Whoosh-to-Postgres-FTS migration that landed in v2.18 — earlier versions were notably slower. Second, Mayan EDMS's disk overhead comes from its more aggressive version-tracking and the extra metadata it stores per document. That overhead is the price you pay for the audit trail. Third, the OCR CPU numbers are similar because all three are wrapping the same underlying Tesseract — the wall-clock spread is mostly queue management efficiency, not raw OCR speed.

VPS Specs and Real Monthly Cost

One mistake I see often in self-hosted DMS discussions is people quoting a "minimum spec" that's actually a "barely-boots spec." Here's what I actually run in production for each tool, with the monthly cost from the providers I've tested most:

• Paperless-ngx, single user / family / freelancer (under ~10k docs): Hetzner CX22 (2 vCPU, 4 GB, 40 GB NVMe) at €4.51/mo. Comfortable headroom. Add 20 GB SSD volume for €0.80/mo when you outgrow it.
• Paperless-ngx, SMB (10k-100k docs, ~10 users): Hetzner CX32 (2 shared vCPU, 8 GB, 80 GB NVMe) at €7.55/mo or Contabo VPS M at $14/mo. The extra RAM is for the search index, not the app server.
• Papermerge, multi-tenant (under ~5 tenants, light use each): Hetzner CX11-tier (1 vCPU, 2 GB) is genuinely fine at around €3.29/mo. This is the cheapest of the three at small scale.
• Mayan EDMS, compliance use case: Hetzner CX32 minimum (€7.55/mo) or ideally CX42 at €11.40/mo. The RabbitMQ + multiple worker processes eat RAM, and the workflow engine is CPU-hungry during state transitions. Do not try to run this on a $4 VPS.

For context, my client who was paying $190/month to a SaaS DMS now runs Paperless-ngx on a €7.55/mo Hetzner CX32 with a 200 GB volume attached at €8/mo. Total monthly cost: about €15.55, or roughly $17. That's a 91% cost reduction with full data ownership. The migration paid for itself in the first month.

Migration Considerations

If you're coming from another system, the migration paths matter as much as the destination feature set. From my notes:

• From a SaaS DMS (DocuWare, M-Files, etc.): Use their export API to pull PDFs + metadata, then bulk-import. Paperless-ngx handles this best because of the consume folder — you can script it. Mayan's bulk import via the API is workable but slower.
• From a Synology/QNAP file share: Paperless-ngx wins decisively. Point the consume folder at the share, let it churn for a few days, done.
• From one of these three to another: Paperless-ngx and Papermerge both expose REST APIs that make scripted migration feasible. Mayan EDMS exports are doable but require more glue code. Budget a weekend of scripting if you're moving >5,000 documents.

One genuine warning from my own ops experience: do not skip the metadata migration plan. I once migrated a Helpdesk Ticketing customer's 3,200-document archive from a homebrew Laravel attachments table into Paperless-ngx and forgot to map the original ticket IDs into custom fields. The documents arrived intact; the link back to the originating tickets did not. Three days of cleanup followed.

The Verdict by Use Case

After 90 days of side-by-side production testing and another six months running the winner in production, here's how I decide in May 2026:

• Single user / freelancer / family archive → Paperless-ngx. The auto-classifier alone justifies it, and the resource footprint is friendly to the cheapest VPS tier.
• SMB with 5-25 users, mixed document types → Paperless-ngx still wins. Groups and per-document permissions cover most realistic ACL needs.
• Multi-tenant deployment (accounting firm, agency, partner portal) → Papermerge. The workspace model is the right tool, and the lighter footprint lets you consolidate.
• Regulated environment (HR, healthcare-adjacent, legal) → Mayan EDMS. The audit trail and workflow engine pay for the operational overhead.
• You want nested folders specifically → Papermerge or Mayan EDMS. Paperless-ngx will fight you.
• You're on a 1 vCPU / 2 GB VPS and can't upgrade → Papermerge. It's the only one that runs comfortably at that tier.

I have not regretted Paperless-ngx as my default choice for SMB and personal deployments. I have not regretted Papermerge for the multi-tenant deployments. I have absolutely regretted picking Mayan EDMS once for a use case that didn't actually need its workflow engine — the operational tax was real, and the client would have been happier with Paperless-ngx and a tagging convention.

Frequently Asked Questions

Can I run any of these on shared hosting like Hostinger?

No — none of these three run on shared hosting. They all need Docker (or systemd services) and persistent worker processes. You need a VPS at minimum. Hostinger's KVM VPS tier (starting around $4.99/mo) is fine for Paperless-ngx or Papermerge; you'll want their VPS 4 tier for Mayan EDMS.

Is OCR quality good enough to skip commercial alternatives?

For typed Latin-script documents (invoices, contracts, receipts), Tesseract 5.4 is genuinely competitive with ABBYY FineReader for searchability. For handwritten text, complex tables, or non-Latin scripts, you'll still want to layer PaddleOCR or pay for commercial OCR. All three tools support that handoff via OCRmyPDF.

How do I back up a self-hosted DMS?

Three components to back up: the Postgres database (use pg_dump nightly), the document storage directory (use Borg or Restic — I compared them in my backup tool roundup), and the Redis/RabbitMQ task state (less critical, can be rebuilt). My standard setup is nightly Borg snapshots to Hetzner Storage Box for $4/mo for 1 TB.

What about encryption at rest?

None of these three encrypt documents at rest by default. The right place to add encryption is at the filesystem layer (LUKS on the volume) or the object storage layer (S3-compatible with server-side encryption). I default to LUKS-encrypted attached volumes on Hetzner for any DMS deployment holding regulated data.

Will any of these scale past a single VPS?

All three can be scaled horizontally with separate workers and a managed Postgres, but realistically: if you're past one VPS for a DMS, you have either a very large archive (millions of documents) or unusual concurrency requirements, and at that point you should be talking to a consultant about a proper architecture review rather than picking from this list.

What happens if the project gets abandoned?

All three projects store documents as regular files on disk, with metadata in Postgres. Even if the project disappeared overnight, your data is in formats you can move elsewhere. This is, frankly, the biggest single argument for self-hosting over SaaS in this category — you're never locked in.

Closing Thoughts

The self-hosted DMS space in 2026 is in a genuinely better place than it was three years ago. The OCR is good enough. The web UIs (especially Paperless-ngx's recent rewrite) are competitive with commercial tools. Hardware is cheap. The data ownership story is no longer a tradeoff — it's an upgrade.

If you take one thing from this comparison, take this: start with Paperless-ngx unless you have a specific reason not to. That reason will most likely be multi-tenancy (go Papermerge) or compliance workflows (go Mayan EDMS). For everything else, Paperless-ngx is the boring correct answer, and the boring correct answer is usually the right one when you're running infrastructure you'd rather not babysit.

And if you're moving off an expensive SaaS DMS this year, do the math on Hetzner CX22 + a 100 GB volume + Borg backups to a Storage Box. I've done that math for four clients in the last six months and the result has been the same every time: pays for itself before the next SaaS renewal hits.