Paperless Archive: How to Build One That Stays Readable and Findable
← All posts
GuideNov 11, 2026· 8 min read

Paperless Archive: How to Build One That Stays Readable and Findable

A paperless archive is a store of digital documents that you can still open, search, and trust years after the paper is gone. Scanning gets the pages in. What makes it an archive is everything after that: a file format that will still render, a text layer that makes the content searchable, metadata that lets you find a document without remembering its filename, a retention rule per document type, and backups you have actually restored from. Most failed “paperless” projects have the scans and skip the rest.

This guide covers those parts in the order they tend to break, with notes on how Paperless-ngx handles them and where an OCR API such as OCRskill helps.

What separates a paperless archive from a folder of scans

A shared drive full of PDFs named scan_0042.pdf holds the same pixels as a good archive. The difference shows up the first time someone needs a document under time pressure, such as an auditor asking for every 2023 contract with one supplier. A working paperless archive answers that in a minute because of five properties:

  1. Durable format. Files are in a format with an open specification and many independent readers.
  2. Searchable text. Every page has a text layer, so a phrase on the page is enough to find it.
  3. Structured metadata. Each document carries a type, a document date, and a correspondent at minimum, stored as fields rather than hidden in a filename.
  4. Retention. You know how long each document type must be kept and when it may be deleted.
  5. Verified copies. There is more than one copy, at least one is off site, and you have checked that the copies are intact.

If any of these is missing, you have a backlog that happens to be digital.

Choose formats that will still open in twenty years

For page-based business documents, PDF/A is the default answer. It is a family of ISO 19005 standards that restrict ordinary PDF to features that suit long-term preservation: fonts are embedded, the document cannot depend on external content, and encryption is not allowed. The Library of Congress keeps a detailed PDF/A format description covering the parts and their differences.

In practice:

  • PDF/A-2b is a sensible target for scanned pages. The “b” level guarantees reliable visual reproduction, which is what a scan needs.
  • PDF/A-3 allows embedded files of any type. That is useful for e-invoices that carry an XML payload, but it also means the attachment itself is not guaranteed to be preservable.
  • Keep the original if it came in as something else, such as a born-digital PDF with signatures or a TIFF from a production scanner. Conversion can change a file, and the original is your evidence of what you received.

A converted file is only PDF/A if it passes validation. The open-source veraPDF validator checks files against the standard, which is worth running on a sample after any change to your scanning or conversion settings.

Photos from phones are the usual weak spot. A JPEG of a receipt taken at an angle in poor light will survive as a file and fail as a record. Set a capture rule (flat, full page in frame, readable at 100% zoom) before people start sending photos, because no format choice fixes an unreadable image later.

Originals and archive copies are not the same file

Good archive software keeps two versions of each scanned document. Paperless-ngx is a clear example: it stores the original file exactly as consumed, and it also produces an archived version with an OCR text layer. The configuration reference documents PAPERLESS_OCR_OUTPUT_TYPE, which defaults to pdfa and produces PDF/A-2b, and notes that the original is kept alongside the archived version.

That split matters for three reasons:

  • The archive copy can be regenerated. If a better OCR engine comes along, you can rebuild text layers from the originals without rescanning paper you may already have shredded.
  • The original is the evidence. In a dispute, the file you received is more defensible than a file your system rewrote.
  • Backups need both, or a plan for one. If you only back up archive copies, you lose the ability to redo OCR. If you only back up originals, you need a working pipeline to recreate the searchable versions after a restore.

Under the hood Paperless-ngx uses OCRmyPDF to add the text layer, so its documentation is the place to look when a scan comes out with a missing or garbled layer.

Metadata is how people actually find things

Full-text search works for “find the letter that mentions the roof repair.” It does not work well for “every invoice from this supplier dated in Q2,” because the page contains several dates and the supplier name may appear in five forms. That second kind of question needs fields.

Start with a small, fixed set that every document gets:

Field Why it matters
Document type Drives retention, permissions, and routing
Document date The date printed on the page, not the scan date
Correspondent The sender or counterparty, normalized to one spelling
Reference number Invoice, contract, case, or account number people search by
Retention class Links the document to a rule in your schedule

Add more fields only per document type and only when someone will search or report on them. Each extra field is one more value to check when the automated pass gets it wrong.

This is where OCR alone stops. Generic OCR gives you all the text on the page. Deciding which of the dates is the invoice date, or which company is the sender rather than the recipient, is an extraction task. OCRskill’s ocr.json endpoint takes the field names you want and returns typed JSON, and it returns 400 with the extracted text when a required field is missing, so the document can go to a review queue instead of being filed with a blank date:

curl "https://api.ocrskill.com/ocr.json?fields=company_name,invoice_date?,invoice_number?" \
  -H "Authorization: Bearer $API_KEY" \
  -F "file=@incoming-scan.pdf"

A trailing ? marks a field as optional. The OCR JSON API reference lists the supported fields, and the electronic archive tutorial shows how the values flow back into Paperless-ngx as document type, date, and correspondent.

Write a retention schedule before the archive gets large

An archive that never deletes anything grows into a liability: more storage, more data to protect, and more material to search through in a legal request. An archive that deletes too early breaks a legal obligation. Both are avoided by a written schedule that maps each document type to a retention period and a trigger, for example “seven years after the end of the financial year” or “until the contract ends plus six years.”

The actual periods depend on your country, sector, and document type, so the schedule should come from your accountant, legal advisor, or records owner, not from a blog post. What the archive needs from you is simpler:

  • Every document type maps to exactly one retention class.
  • The trigger date is a field you can query, not a fact buried in the page.
  • Someone reviews the list of documents past retention before anything is deleted.
  • Legal holds override the schedule, and the system can mark a document as held.

Self-hosted tools like Paperless-ngx do not enforce retention on their own. You can model it with document types, custom fields, and saved views that list documents past their date, but the decision and the deletion stay manual. If your sector has strict records obligations, that gap may be the reason to buy a managed records platform. The paperless ECM services guide covers what to ask such a provider.

Back up, verify, and rehearse the exit

Backups are the part nobody tests until it is too late. CISA’s guidance on data backup options summarizes the 3-2-1 rule: three copies of important files, on two different media types, with one copy off site. For a document archive that translates to the live system, a local backup on separate hardware, and an encrypted copy somewhere outside the building.

Copies only help if they are intact. Two checks are worth scheduling:

  • Integrity. Paperless-ngx has a document_sanity_checker command that compares stored files against the checksums in its database and reports missing or corrupted originals and archive files. Run it on a schedule and read the output.
  • Restore. Use the document_exporter command to produce a full export with originals, archive versions, and a manifest of metadata, then import it into a scratch instance. The administration docs cover both commands and their options.

The export also answers the exit question. Your archive will outlive at least one piece of software, so you should be able to get every file and every metadata value out in an open form. A manifest in JSON plus PDF/A files in a predictable folder layout is a good test. If you cannot produce that from your current system in an afternoon, fix it before the archive doubles in size.

A rollout that does not stall

  1. Pick one document family, such as supplier invoices, and run it end to end: capture, OCR, metadata, storage path, retention class, backup.
  2. Measure misses. Count how many documents land in review because a field was missing or wrong, and adjust capture rules or field definitions before adding the next family.
  3. Add families one at a time. Each new type gets its fields and retention class before its first document arrives.
  4. Handle the paper backlog separately. Old boxes are a project with a deadline. New intake is a daily process. Mixing them floods the review queue.
  5. Schedule the checks. Put the sanity check, the export, and a test restore on a calendar with an owner.

For worked examples of document types and intake channels by sector, see the accounting and healthcare workflow guides, and the Paperless-ngx tips post for storage paths and matching rules.

Conclusion

The scan is the cheapest part of a paperless archive and the easiest to get right. What decides whether the archive is still useful in ten years is the boring layer around it: PDF/A copies plus untouched originals, a short and enforced set of metadata fields, a retention schedule someone signed off on, and backups that have been checked and restored at least once. If you are deciding where to spend effort first, start with the metadata model and the restore test. Those two are the hardest to add later, and they are the ones an auditor or a hardware failure will find.