Deploy and Host self hosted Paperless-ngx Storage Paths (Open-Source Document Archive) on Railway

This template runs Paperless-ngx on Railway with Postgres, Redis and one volume. Storage paths and PAPERLESS_FILENAME_FORMAT decide the folders and names your PDFs get, so a year and correspondent tree stays browsable for tax season.

About Hosting Paperless-ngx Storage Paths open-source software on Railway (self hosted Paperless-ngx storage paths template)

You own the archive. Every original, archived PDF/A copy and OCR text file sits on your Railway volume, so the folder tree your storage paths build is yours to copy, back up or walk away with.

Why Deploy Paperless-ngx Storage Paths, the Google Drive alternative on Railway (Railway Free Trial)

Google Drive decides nothing about your folder names or file names beyond what you type, and its index is search. Here the volume is yours: readable year and correspondent folders, no per-seat maths, and the $5 Railway trial covers a first archive.

Railway is a singular platform to deploy your infrastructure stack. Railway will host your infrastructure so you don't have to deal with configuration, while allowing you to vertically and horizontally scale it.

By deploying Paperless-ngx Storage Paths on Railway, you are one step closer to supporting a complete full-stack application with minimal burden. Host your servers, databases, AI agents, and more on Railway.

Railway vs Other Hosting Providers and VPS for Paperless-ngx Storage Paths self hosting

Railway attaches the volume and manages Postgres and Redis, so your folder tree is what a backup captures.

Provider	What You Get with Railway	What You Get with the Other Provider
DigitalOcean	Volume, managed Postgres, Redis, public domain.	Droplet and block storage; you run Docker and TLS.
AWS	One deploy, generated secrets, media on the same volume.	ECS or EC2 with EBS, RDS and ElastiCache; you add IAM and alarms.
Hetzner	Billed by usage, nothing to administer.	Cheap CPU that OCR likes, but you own OS, firewall, backups.

Storage paths travel with the volume, so a host move is a copy plus document_renamer.

Common Use Cases for hosted Paperless-ngx Storage Paths

Year and correspondent folders for taxes: {{ created_year }}/{{ correspondent }}/{{ title }} turns a shoebox of receipts into 2025/Accountant/Receipt-0042.pdf, no manual renaming.
Per-person folders in a family archive: one storage path per person, assigned by a workflow, keeps medical letters, school reports and insurance paperwork apart.
Document-type folders for an office: {{ created_year }}/{{ document_type }}/{{ correspondent }} routes invoices, contracts and payslips into predictable drawers.
Readable filenames for an offsite backup: a copy of the media folder keeps the same readable tree, so a NAS backup stays browsable even without the database.
Invoice numbers in the name: a custom field like invoice_id gives 2025/Acme/INV-2025-118.pdf, so you find an invoice by its printed number.

Dependencies for Paperless-ngx Storage Paths Docker hosted on Railway

This stack is three Railway services plus one volume, and storage paths only work when all of them agree. Paperless-ngx writes originals, archived PDFs and the consume folder under /usr/src/paperless/data, so the tree you design is the tree a backup contains.

Deployment Dependencies for Managed Paperless-ngx Storage Paths Service (Document Management)

Run ghcr.io/paperless-ngx/paperless-ngx:3.3.0 on port 8000 with the volume at /usr/src/paperless/data. Postgres holds metadata and paths; Redis is the Celery broker.

Implementation Details for Paperless-ngx Storage Paths (Using Paperless-ngx official docker image)

Templates like {{ created_year }}/{{ correspondent }}/{{ title }} keep originals and PDF/A copies. Never edit files on the volume.

How does Paperless-ngx Storage Paths compare against other document archives and file organizers

Paperless-ngx vs Google Drive (Google Drive Alternative)

Naming control: Templates build year and correspondent folders on ingest; Drive folders are manual.
Metadata drives paths: Rename a correspondent and files move; in Drive you drag them yourself.
Changing formats later: Run document_renamer to apply a new template to existing files instead of re-uploading.
Where Drive wins: Sync clients, shared editing and phone backup are easier.

Paperless-ngx vs Nextcloud (Nextcloud Alternative)

Purpose: Nextcloud is file sync plus groupware; Paperless is a DMS with OCR and naming rules.
Path handling: Nextcloud keeps your upload path; Paperless rewrites it from metadata.
Where Nextcloud wins: Desktop sync, calendars and external sharing.

Paperless-ngx vs Mayan EDMS (Mayan EDMS Alternative)

Weight: Mayan is a heavier EDMS with cabinets and approval chains; Paperless is simpler.
Folder trees: Mayan uses cabinet trees; Paperless derives the tree from placeholders.
Where Mayan wins: Retention policies and formal multi-step workflows.

Paperless-ngx vs Docspell (Docspell Alternative)

Stack: Docspell runs on Scala; Paperless is Django, Celery and Postgres.
Templates: Both file by metadata; Paperless paths are readable templates that fall back to none.
Where Docspell wins: Stronger batch automation, though its community is smaller.

How to use Paperless-ngx Storage Paths (the OSS document management system)?

Sign in at /accounts/login/ as PAPERLESS_ADMIN_USER (admin) with the generated password from Railway variables.
Open Storage Paths in the sidebar, create one, and paste a template:
```
{{ created_year }}/{{ correspondent }}/{{ title }}
```
Give it a matching rule (Any, All, Exact, Regex, Fuzzy) or assign it from a workflow action.
Upload a document or reprocess an existing one, then check the media tree where it landed.
For leftovers without a path, set PAPERLESS_FILENAME_FORMAT on the paperless-ngx service to the same template and redeploy.
Apply it to existing files in the service shell:
```
python3 manage.py document_renamer
```

The PDFs themselves stay unchanged.

How to self host Paperless-ngx Storage Paths on other VPS Services (Paperless-ngx self hosting guide)

Clone the Repository

Keep media, data and consume on a persistent disk.

git clone https://github.com/paperless-ngx/paperless-ngx.git
cd paperless-ngx/docker/compose
cp docker-compose.postgres.yml docker-compose.yml

Install Dependencies

Install Docker Engine and Compose, then confirm both work.

docker --version
docker compose version

Configure Environment Variables

Edit docker-compose.env in the same folder. Set PAPERLESS_URL=https://your-domain, admin credentials, Postgres and Redis values, plus PAPERLESS_FILENAME_FORMAT={{ created_year }}/{{ correspondent }}/{{ title }}.

Start the Paperless-ngx Storage Paths Application

Start the stack, log in, and create Storage Paths with matching rules.

docker compose up -d

Check https://your-domain/accounts/login/ loads, upload a document, and confirm it lands in the folders you set.

Railway handles Postgres, Redis, the volume mount and HTTPS domain for you.

Official Pricing of Paperless-ngx Storage Paths (Paperless-ngx pricing)

Paperless-ngx itself is GPL-3.0, fully free, and has no official paid cloud tier, so storage paths and the document_renamer command cost nothing in license terms.

Paperless-ngx Storage Paths cloud vs self hosted comparison (Pricing, features, costs, and more)

Cloud and self hosted Paperless-ngx run the same code, so naming behavior is identical. The difference is who pays for the disk under your folder tree. The project has no official paid cloud; third-party hosts exist, and I won't quote their prices.

Monthly cost of self hosting Paperless-ngx Storage Paths on Railway

A small personal archive usually lands around $5-15/mo on Railway, and volume storage grows with your documents. A $5 trial covers the first experiments. The software itself is GPL-3.0 and free.

System Requirements for Hosting Paperless-ngx Storage Paths on a VPS

Give it 2 GB RAM minimum for comfort, and more for large OCR batches. Docker Compose is the documented path. Disk scales with media, so a deep year and correspondent tree costs the same bytes as numbered files.

Frequently Asked Questions (FAQs)

Why are my files still numbered?

Either no storage path matched the document, or PAPERLESS_FILENAME_FORMAT is unset, so Paperless falls back to the numeric id. Assign a storage path or set the variable, then run document_renamer for anything already imported.

Can I change the format later?

Yes. Edit the storage path template or the environment variable whenever you like. After changing PAPERLESS_FILENAME_FORMAT, run document_renamer so existing files pick up the new names; the database updates paths as files move.

What happens with duplicate names?

Paperless appends _01, _02 and so on, so two invoices titled the same still coexist. Missing values become none instead, which is why a correspondent of none in a path is a hint your matching rule missed.

Can I use custom fields in a path?

Yes, through the custom_fields mapping and the get_cf_value filter, so {{ custom_fields|get_cf_value('Invoice Number') }} works in a filename. Create the custom field and fill it on the document first.

Should I edit files on the volume?

No. The database tracks paths and checksums, so hand edits break links and reprocessing. Use the document exporter for copies and let Paperless move files when metadata changes.

Does this change the PDF itself?

No. Naming only affects where files sit on the volume. The original stays as uploaded, and the archived PDF/A copy gets the same name under the archive folder.