I have started over with Paperless-ngx multiple times now.

Every time I think: this time I will finally organize my documents properly instead of keeping everything in folders and searching for them later.

I install Paperless, upload documents, create some tags, try to build a structure around it... and eventually I stop using it again.

Which is frustrating, because I really want to like Paperless. It is self-hosted, open source, fast, actively developed and basically exactly the kind of software I want to use.

But for me it always feels like Paperless only becomes useful after I already did most of the organizing work myself.

I am not running a company processing hundreds of documents every day. I just want to manage normal personal documents: invoices, contracts, insurance, taxes, employment stuff, vehicle documents, government letters, medical documents, etc.

And my problem is not OCR. OCR actually works really well for me.

The problem is what happens afterwards.

If Paperless successfully extracted all the text from a document, I would expect it to do more with that information.

Take dates. A document might contain three different dates. Paperless often chooses one automatically, but quite often it is not the one I actually want.

Why not detect the possible dates and show me three suggestions?

And this does not require an LLM.

Date extraction, named entity recognition, text classification, keyword extraction, similarity matching and so on existed long before current LLMs.

The same applies to correspondents, document types and tags.

An LLM can massively improve the quality and handle ambiguous cases, but I do not understand why the baseline seems to start so low.

Tags were probably my first major frustration

You start with an empty system and immediately have to design your own taxonomy.

Should I use Insurance, Insurance Document, Contract, Insurance Contract?

Should tags represent topics, document types, people, status, categories?

Sure, there is documentation, but there is a difference between documenting how a tag works and giving new users a sensible starting point.

Why not have completely optional presets?

Something like:

• Personal Documents
• Family Documents
• Small Business
• General Administrative Documents

Give me 20 or 30 common tags/document types and let me modify them. Most document collections probably overlap a lot anyway.

Then there is automatic learning, which gave me an even stranger problem

Imagine I import my existing collection and first organize one category. I manually apply one tag to all matching documents and enable auto matching.

At this point the classifier has basically only learned:

>Documents look like this → apply this tag.

It has not yet seen the rest of my collection.

Then I start importing unrelated documents and suddenly many of them get that same tag as well.

Which makes complete sense technically. That is basically the only thing the classifier has seen.

But this is a terrible cold-start problem.

When you organize an existing collection, you naturally go through one category after another. Your first training data is therefore heavily biased.

This is why I do not really understand why there isn't some generic pretrained classifier underneath it, which then learns my personal taxonomy over time.

Again, text classification existed before LLMs.

What I would expect is:

Upload → Paperless makes a reasonable guess → I correct it → Paperless adapts.

Instead it can feel more like:

Upload → manually classify a bunch of documents → classifier learns your first biased subset → fix the resulting mistakes later.

I expected AI to improve this, not replace everything

When Paperless-ngx 3 and more AI functionality arrived, I got interested again.

I already run a local 9B LLM, and I thought AI could greatly improve the quality.

Not replace everything.

I was expecting something more like:

• OCR extracts the text.
• Traditional NLP finds dates, organizations and other obvious information.
• A classifier estimates the document type.
• Embeddings find similar documents.
• Existing matching rules add context.
• An LLM helps with the difficult or ambiguous parts.

For example, NLP can find three dates. The LLM can then determine that one is probably the actual document date, another is a deadline and the third refers to an older event.

That is where I see the value of AI: improving an already decent pipeline.

So this time I went pretty far trying to build this myself

I used Claude Code together with the Paperless API to create a general-purpose setup.

Claude Code created my taxonomy, tags and workflows. It helped me separate metadata that could be handled automatically from things I should review manually.

Then I integrated Paperless-GPT with my local model so it could analyze documents and apply metadata based on that structure.

And technically, quite a lot of that worked.

But I still did not end up with the workflow I actually wanted.

Paperless workflows are powerful, but I constantly found myself thinking about how Paperless internally processes documents rather than what I wanted to achieve.

Which trigger should run this?

During consumption or afterwards?

What happens when metadata changes?

Does another workflow run?

What happens when Paperless-GPT modifies something?

I understand why these concepts exist, but what I actually want is much simpler:

>A new document arrives. Analyze it. Apply what you are confident about. Show me the uncertain parts. Done.

Instead I ended up building a pipeline around Paperless to make that happen.

Paperless-GPT helps, but it also shows what I feel is missing

Paperless-GPT can do a lot of what I want. It can suggest titles, tags, correspondents and document types.

But it is another application.

Another container, another configuration, another API user, another thing connected through workflows.

That is not really criticism of Paperless-GPT. It is solving a real problem.

But for me, one of the main jobs of a modern DMS should simply be:

Understand the document well enough that I do not have to manually enter all the metadata.

The workflow I want is basically:

Upload → OCR → classify → suggest metadata → review uncertain fields → done.

Paperless also makes surprisingly little use of information users already have

Most people do not install Paperless before they have documents.

Their files might already look something like:

Documents/
├── Insurance/
│   ├── Provider 1/
│   └── Provider 2/
├── Vehicle/
├── Taxes/
├── Work/
└── Invoices/

There is useful information there.

If something comes from Insurance/Provider 1/, then Insurance is already useful context and Provider 1 may be a correspondent candidate.

Paperless does not have to blindly trust the folder structure. Just preserve it and use it as another signal.

Otherwise moving to Paperless means throwing away part of the organization you already created and rebuilding it again as Paperless metadata.

And finally, I really wish Paperless had a proper plugin system

I fully understand that the maintainers cannot implement every possible feature.

But that is exactly why plugins would be useful.

Imagine plugins for:

• better classifiers
• AI metadata extraction
• date extraction
• document presets
• import helpers
• specialized OCR
• different dashboards
• better correspondent detection

Instead, the Paperless ecosystem seems to solve many of these problems by building things next to Paperless:

another container, another API integration, another script, another workflow.

There are lots of cool projects around Paperless, but many of them feel like sidecars instead of actual extensions of Paperless.

I think my main problem is the "zero to useful" experience

Paperless is extremely configurable, but a fresh installation does not immediately feel like it is helping me.

First I have to build my Paperless instance:

tags, document types, correspondents, matching rules, workflows, maybe Paperless-GPT, maybe scripts, maybe prompts.

Only then does Paperless start becoming the thing that saves me work.

And this time I really tried.

I used Claude Code and the API to build the taxonomy and workflows, connected Paperless-GPT to a local LLM and tried to automate as much as possible.

And I still ended up feeling like I was building a lot of infrastructure around Paperless just to make Paperless organize my documents.

That is the part I find frustrating.

Because I really do like the project, and I want exactly this kind of open-source, self-hosted software.

Maybe I am approaching it completely wrong.

So I am genuinely curious:

How are other personal/home-lab users handling this?

Did you manually build everything and eventually get auto matching working reliably?

How did you deal with the biased cold-start problem?

Do you use Paperless-GPT, Paperless-AI or your own scripts?

Or do other people also feel that Paperless could do much more with the information it already has before asking the user to build the whole system around it?