As a German living with the country’s infamous love for paperwork, I built a streamlined Qt-based tool called DocMan to manage my scanned documents efficiently. This post explains how it works and why I created it several years ago—and why it’s still my go-to solution today without requiring any maintenance.

intro

The Problem

My document workflow starts with my scanner, which connects to my network via Samba and deposits scanned PDFs into an INBOX folder. I needed a lightweight but effective way to:

  1. Navigate through my organized document folders
  2. View and examine PDF documents clearly
  3. Name files consistently (I prefer the YYmmdd_description format)
  4. Move files to their permanent location quickly

After trying several alternatives like ecoDMS, Paperwork, and Paperless-ngx, I found they didn’t quite match my specific workflow needs or added complexity I didn’t want.

DocMan: The Solution

docman

DocMan is a focused Qt application that serves a single purpose extremely well - helping me move documents from my scanner’s output folder to their proper home in my directory structure. The interface is clean and divided into three primary functional areas:

1. Directory Navigation

On the left side, there’s a hierarchical tree view of my document directories. This component:

  • Uses a customized file system model that shows only folders (no files)
  • Automatically expands folders when directories are loaded
  • Displays only the directory name column, keeping the interface clean
  • Has my document root folder hardcoded to /home/mh/mnt/user/mh/private/Haushalt
fsModel->setFilter(QDir::AllDirs | QDir::NoDotAndDotDot);
fsModel->setRootPath("/home/mh/mnt/user/mh/private/Haushalt");

2. PDF Viewer

The central component is a PDF viewer built on Poppler-Qt5, offering:

  • Clear, high-quality rendering of PDF documents
  • Adjustable zoom level via a slider control
  • Support for multi-page PDFs with pagination controls
  • Quick rendering of each page as you navigate
  • Persistence of zoom level when switching between documents
void PdfViewer::renderPage()
{
    scene->clear();
    QImage image = currentDocument->page(currentPage)->renderToImage(currentZoom, currentZoom);
    auto pixmap = new QGraphicsPixmapItem(QPixmap::fromImage(image));
    scene->addItem(pixmap);
}

3. Filename Input

At the top, a simple input field allows me to quickly name each document:

  • I enter my preferred YYmmdd_description format
  • Pressing Enter commits the name and moves the file
  • The field clears automatically, ready for the next document
void MainWindow::moveFile(const QString& name)
{
    if (targetPath != "")
    {
        QDir().rename(currentFilename, targetPath + name + ".pdf");
        nextFile();
    }
}

The Workflow in Action

When I need to process documents (which happens every now and then rather than daily), my routine follows these simple steps:

  1. Paper documents go through my scanner, which saves them as PDFs to my INBOX directory on my Samba share
  2. I launch DocMan from within the same network
  3. The application automatically loads the first document from my INBOX
  4. I examine the document using the viewer (zooming or paging through it as needed)
  5. I navigate to the appropriate destination folder in the directory tree
  6. I type a descriptive filename in my preferred format (e.g., “250508_electric_bill”)
  7. Pressing Enter moves the file to the selected location and loads the next document

The efficiency comes from the tight integration of these components. I can process a stack of documents in minutes without context switching between applications.

Technical Implementation

DocMan is quite lean, implemented in C++ with Qt5. Here are some notable technical aspects:

  • Uses Poppler-Qt5 for high-quality PDF rendering
  • Employs a custom QFileSystemModel to show only directories
  • Includes a specialized QLineEdit that captures Enter key presses
  • Utilizes signals and slots for component communication
  • The file list class automatically populates from my INBOX directory:
PdfList::PdfList(QObject *parent) : QObject(parent)
{
    files = QDir("/home/mh/mnt/user/mh/private/INBOX").entryList(QDir::Files);
}

Why Qt?

I chose Qt for a few practical reasons:

  • I was already familiar with the framework, reducing the development time
  • Poppler-Qt5 offered the best PDF rendering capabilities I could find
  • Qt’s signal/slot mechanism made component communication straightforward
  • The cross-platform nature meant I could run it on different systems if needed

Who Needs OCR Anyway?

One notable feature I deliberately omitted was OCR (Optical Character Recognition). While many document management systems emphasize searchable text, I’ve found that my simpler approach works perfectly for my needs. By using consistent naming conventions with dates and brief descriptions, I can easily locate documents later by browsing the logical folder structure or using basic file search tools.

For example, I know roughly when I received a particular utility bill and in which folder it should be, so finding “2504_electric_bill.pdf” is straightforward without needing to search through the document content itself.

Why Build a Custom Tool?

I could have used existing solutions, but creating DocMan gave me several advantages:

  1. Perfect workflow fit - It does exactly what I need with no extra features
  2. Speed - The dedicated interface makes document processing extremely efficient
  3. Control - I can modify it whenever my requirements change
  4. Simplicity - No complex setup, cloud dependencies, or maintenance headaches

Conclusion

Sometimes the best tool is one you build yourself. DocMan demonstrates that a focused application solving a specific workflow problem can be more effective than generic solutions. While it’s admittedly simple, it saves me time whenever I need it by streamlining an occasional but necessary task.

What’s been most surprising is its longevity—I built this tool several years ago, and it continues to serve me perfectly without requiring any maintenance or updates. In a world of constantly changing software, there’s something deeply satisfying about a purpose-built tool that just keeps working.

The greatest productivity gains often come not from complex systems but from reducing friction in common workflows. By transforming document management from a chore into a quick, smooth process, DocMan helps me focus on the content of my documents rather than the mechanics of organizing them—which is especially valuable when dealing with the mountain of paperwork that seems to be Germany’s national hobby!

A Final Note on Physical Document Storage

What happens to all those physical papers after scanning? My approach is refreshingly straightforward: they go into cardboard boxes and get archived away. No complex filing cabinets, no elaborate categorization systems—just simple storage.

If I ever need the original paper document, I know roughly where to find it based on when I scanned it. But here’s the thing: I’ve rarely had to retrieve the physical copies. The digital system works so well that the originals become just a backup, safely tucked away without needing to be meticulously organized.

outro

This pragmatic approach speaks to an important principle: optimize the parts of your workflow that matter most. For me, that’s quick processing and reliable digital retrieval—not creating a perfect physical filing system that I’ll rarely use. Sometimes the best solution isn’t the most elaborate one, but the one that solves your actual problems with minimal overhead.