Self-Hosted Research Paper Database

Deploy a searchable document database with Docker and Paperless-ngx.

Introduction

30 Second Summary

You have dozens of research papers scattered across your Downloads folder, Desktop, and random subfolders. Finding that one study you read last month means opening file after file until you stumble on it.

In this project, you will deploy a self-hosted document management system called Paperless-ngx using Docker on your Windows machine. It automatically processes, OCRs, and indexes every PDF you drop into a folder, making your entire research library searchable in seconds.

What You'll Build

A local research paper database powered by Paperless-ngx that runs inside Docker containers on your machine and is accessible from any device on your home network.

By the end of this project, you'll have:

  • A running Paperless-ngx instance with a PostgreSQL database and Redis message broker deployed via Docker Compose.
  • A configured consume folder where dropping a PDF triggers automatic OCR, text extraction, and indexing.
  • An organized library with document types, tags, and saved views for filtering and browsing your research from any device.
  • Secret Mission: Set up automatic matching rules so newly ingested papers get categorized by topic without manual intervention.

Are there any prerequisites?

You need a computer running Windows 11 with at least 8 GB of RAM. No prior Docker or command-line experience is required. This guide walks you through installing everything from scratch.

Install Docker Desktop and Enable WSL 2

Paperless-ngx runs inside Docker containers. Docker lets you run pre-packaged applications in isolated environments without installing their dependencies directly on your machine.

To run Docker containers on Windows, you need two things: WSL 2 (Windows Subsystem for Linux) as the backend, and Docker Desktop as the management tool. In this step, you will enable WSL 2, install Docker Desktop, and verify everything works.

In this step, get ready to:
  • Enable WSL 2 on your Windows machine.
  • Install Docker Desktop with the WSL 2 backend.
  • Verify Docker is ready to run containers.
Enable WSL 2

WSL 2 gives Windows a full Linux kernel. Docker Desktop uses this kernel to run Linux-based containers natively on your machine.

  • Press the Windows key to open your search bar.
  • Type PowerShell and look for Windows PowerShell in the results.
  • Right-click it and select Run as administrator.
  • Click Yes on the User Account Control prompt that appears.
  • Install WSL 2 by running this command:
wsl --install

What does this command do?

This single command enables the Virtual Machine Platform and Windows Subsystem for Linux features, then installs the default Ubuntu distribution. It handles all the setup that used to require multiple manual steps.

  • When the command finishes, restart your computer as prompted.
  • After your computer restarts, open PowerShell again (a regular window is fine this time, no need for Administrator).

Seeing an Ubuntu setup window?

After restarting, an Ubuntu terminal window may appear asking you to create a Linux username and password. Follow the prompts to set these up. This is your Linux user account inside WSL, not your Windows account.

  • Confirm WSL 2 is installed by running this command in PowerShell:
wsl --version

Look at the first line of the output. It shows your WSL version number.

✔️ I see version 2.1.5 or later

Your WSL 2 installation is ready. Move on to the next substep to install Docker Desktop.

ⓧ I see an older version

Your WSL is installed but needs an update. Run this command to update it:

wsl --update
  • After the update completes, restart your computer.
  • Open PowerShell and run wsl --version again to confirm the version is now 2.1.5 or later.

ⓧ Command not found or error

The installation did not complete successfully. Try these fixes:

  • Make sure you restarted your computer after running wsl --install. The installation only finishes after a restart.
  • If you already restarted, open PowerShell as Administrator again and run wsl --install a second time.
  • Confirm your Windows 11 is fully updated by going to Settings, then Windows Update, and installing any pending updates.
Install Docker Desktop

Docker Desktop provides the graphical interface and engine that runs containers on your machine. It uses the WSL 2 backend you just enabled.

  • Open your browser and navigate to the Docker Desktop download page:

https://docs.docker.com/desktop/setup/install/windows-install/

  • Click the download button for Docker Desktop for Windows.
  • Run the downloaded installer.
  • In the installer, ensure the Use WSL 2 instead of Hyper-V option is checked.
  • Click Ok and wait for the installation to complete.
  • When installation finishes, click Close and restart if prompted, or close the installer.

What is Hyper-V?

Hyper-V is an older Windows virtualization technology. WSL 2 is lighter and faster for running Docker containers. The installer defaults to WSL 2 on Windows 11, which is what you want.

  • Press the Windows key to open your search bar.
  • Type Docker Desktop and press Enter to open it.
  • Wait for the Docker engine to start. The whale icon in the system tray will stop animating once the engine is ready.

Skip the Docker Desktop tutorial

Docker Desktop may show a welcome wizard or tutorial on first launch. You can skip or close it. You will not need the Docker Desktop GUI for this project.

Docker engine not starting?

If the whale icon keeps animating or you see an error about the Docker engine:

  • Make sure WSL 2 is fully installed by running wsl --version in PowerShell. If it fails, revisit the Enable WSL 2 substep above.
  • Try restarting your computer and launching Docker Desktop again.
  • Check that hardware virtualization is enabled in your BIOS settings. This is required for Docker to function.

Still stuck? Help me troubleshoot Docker Desktop not starting on Windows 11 with WSL 2

Verify Docker is working

With Docker Desktop running, you can now confirm that the docker command line tool is available in PowerShell.

  • Open PowerShell and check your Docker installation by running this command:
docker --version
  • Check that Docker Compose is also available by running:
docker compose version

✔️ I see version numbers for both commands

Both tools are installed and ready. Move on to the final verification below.

ⓧ Command not found or error

If either command fails:

  • Make sure Docker Desktop is running. Look for the whale icon in the system tray.
  • Close and reopen your PowerShell window. Docker adds itself to your system path during installation, but existing terminals do not pick this up automatically.
  • If you just finished installing Docker Desktop, try restarting your computer.
  • Run the hello-world container to test that Docker can pull and run images:
docker run hello-world

What does this command do?

This command downloads a tiny test image from Docker Hub and runs it as a container. The container prints a confirmation message and exits. It proves that Docker can download images, create containers, and run them successfully.

You should see a message that includes Hello from Docker! in the output. This confirms your entire Docker setup is working.

Seeing a connection error?

If the command fails with a connection or permission error:

  • Confirm Docker Desktop is fully started (whale icon in the system tray is not animating).
  • Make sure you are connected to the internet. Docker needs to download the hello-world image the first time.
  • Try closing Docker Desktop completely and reopening it, then wait for the engine to start before running the command again.

Need more help? Help me fix a docker run hello-world failure on Windows 11

Docker is installed and working. Next up, you will create the configuration files that tell Docker exactly which containers to run for your research paper database.

Deploy Paperless-ngx with Docker Compose

You have Docker running on your machine. Now it is time to put it to work.

In this step, you will create the configuration files that tell Docker Compose exactly which containers to spin up. Paperless-ngx needs three services working together: a web server, a PostgreSQL database, and a Redis message broker.

In this step, get ready to:
  • Create the project directory and configuration files.
  • Configure environment settings for Paperless-ngx.
  • Pull Docker images and start all three services.
Create the project directory and configuration files

Docker Compose reads a docker-compose.yml file to know which containers to create and how to connect them. You need a dedicated folder to hold this file and its companions.

  • Open PowerShell by pressing the Windows key, typing PowerShell, and pressing Enter.
  • Create the project directory and move into it by running these commands:
mkdir C:\paperless-ngx
cd C:\paperless-ngx
  • Create the consume and export subdirectories by running:
mkdir consume, export

What are these folders for?

The consume folder is where you drop new documents. Paperless-ngx watches this folder and automatically ingests anything you place inside it.

The export folder is where Paperless-ngx places exported documents and metadata if you ever need to back up or migrate your library.

  • Confirm the directories exist by running:
ls

You should see consume and export listed in the output.

Now you need three configuration files. The first is the main Docker Compose file that defines all three services.

  • Create the docker-compose.yml file by running:
New-Item docker-compose.yml
  • Open this file in VS Code by running:
code docker-compose.yml
  • Paste the following content into docker-compose.yml:
# Docker Compose file for running Paperless-ngx with PostgreSQL.
# Three services: webserver, database, and message broker.
services:
  broker:
    image: docker.io/library/redis:8
    restart: unless-stopped
    volumes:
      - redisdata:/data

  db:
    image: docker.io/library/postgres:18
    restart: unless-stopped
    volumes:
      - pgdata:/var/lib/postgresql
    environment:
      POSTGRES_DB: paperless
      POSTGRES_USER: paperless
      POSTGRES_PASSWORD: paperless

  webserver:
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    restart: unless-stopped
    depends_on:
      - db
      - broker
    ports:
      - "0.0.0.0:8000:8000"
    volumes:
      - data:/usr/src/paperless/data
      - media:/usr/src/paperless/media
      - ./export:/usr/src/paperless/export
      - ./consume:/usr/src/paperless/consume
    env_file: docker-compose.env
    environment:
      PAPERLESS_REDIS: redis://broker:6379
      PAPERLESS_DBHOST: db

volumes:
  data:
  media:
  pgdata:
  redisdata:

What does this file do?

This file defines three services that work together. The broker service runs Redis, which handles background task queuing. The db service runs PostgreSQL, which stores all your document metadata and search indexes.

The webserver service is Paperless-ngx itself. It depends on both db and broker, so Docker starts those first.

The ports line "0.0.0.0:8000:8000" makes the service accessible from other devices on your network, not just your own computer.

  • Save docker-compose.yml by pressing Ctrl+S.

Next, create the environment file that holds Paperless-ngx settings.

  • Switch back to PowerShell and create the docker-compose.env file by running:
New-Item docker-compose.env
  • Open it in VS Code by running:
code docker-compose.env
  • Paste the following content into docker-compose.env:
# Paperless-ngx environment settings

# A long random string used for session security
PAPERLESS_SECRET_KEY=your-secret-key-here-replace-with-random-characters

# The default language for OCR text recognition
PAPERLESS_OCR_LANGUAGE=eng

# Your local timezone
PAPERLESS_TIME_ZONE=America/New_York

What are these settings?

PAPERLESS_SECRET_KEY is a random string that Paperless-ngx uses to secure browser sessions. Replace the placeholder with any long sequence of random characters. You do not need to remember it.

PAPERLESS_OCR_LANGUAGE tells the OCR engine which language your documents are written in. The value eng means English.

PAPERLESS_TIME_ZONE sets the timezone for document timestamps. Replace America/New_York with your own timezone (e.g. Europe/London, Asia/Tokyo, Australia/Sydney).

  • Save docker-compose.env by pressing Ctrl+S.

Finally, create the base .env file that Docker Compose uses for the project name.

  • Switch back to PowerShell and create the .env file by running:
New-Item .env
  • Open it in VS Code by running:
code .env
  • Paste the following content into .env:
COMPOSE_PROJECT_NAME=paperless

What does this do?

This gives your Docker Compose project a consistent name. Without it, Docker uses the folder name, which can cause issues if you ever move the folder. Setting COMPOSE_PROJECT_NAME=paperless keeps container names predictable.

  • Save .env by pressing Ctrl+S.

Files not opening in VS Code?

If the code command is not recognized, VS Code may not be in your system PATH. Open VS Code manually, click File then Open File, and navigate to C:\paperless-ngx to open each file.

help me open files in VS Code from PowerShell

Configure your secret key and timezone

The docker-compose.env file has two placeholder values you need to personalize before starting the containers.

  • In docker-compose.env, replace your-secret-key-here-replace-with-random-characters with any long random string (e.g. mash your keyboard for 30+ characters).
  • Replace America/New_York with your own timezone if you are not in the US Eastern timezone.
  • Save the file by pressing Ctrl+S.

Finding your timezone

Timezones use the format Region/City. Common examples: America/Chicago, America/Los_Angeles, Europe/London, Asia/Singapore. Search "TZ database timezone" online to find yours.

Pull images and start the services

Docker needs to download the container images for Redis, PostgreSQL, and Paperless-ngx before it can run them. This is a one-time download that takes a few minutes depending on your internet speed.

  • Switch back to PowerShell. Make sure you are in the C:\paperless-ngx directory.
  • Pull all the Docker images by running:
docker compose pull

This downloads three images: Redis, PostgreSQL, and Paperless-ngx. You will see download progress bars for each layer.

Seeing connection errors?

Make sure Docker Desktop is running. Check the system tray for the whale icon. If the icon is not there or shows an error, open Docker Desktop from the Start menu and wait for the engine to start.

help me fix Docker connection errors when pulling images

  • Start all three services in the background by running:
docker compose up -d

What does the -d flag do?

The -d flag stands for "detached" mode. It starts the containers in the background so you get your terminal back. Without it, the terminal would show live logs and you could not type other commands.

  • Verify all three containers are running by running:
docker compose ps

You should see three services listed: broker, db, and webserver. All three should show a status of Up.

A container shows 'Exited' or is missing?

If the webserver shows as exited, check its logs by running docker compose logs webserver in PowerShell. A common cause is a typo in docker-compose.env or docker-compose.yml. Double check your files match the content above.

help me debug a Docker container that keeps exiting

✔️ Awesome, I've got everything!

Great. Double check you have saved all three files in C:\paperless-ngx and that docker compose ps shows all services as Up.

ⓧ I'd like to double check the full code

Here are the three configuration files in full. Compare yours against these:

# Docker Compose file for running Paperless-ngx with PostgreSQL.
# Three services: webserver, database, and message broker.
services:
  broker:
    image: docker.io/library/redis:8
    restart: unless-stopped
    volumes:
      - redisdata:/data

  db:
    image: docker.io/library/postgres:18
    restart: unless-stopped
    volumes:
      - pgdata:/var/lib/postgresql
    environment:
      POSTGRES_DB: paperless
      POSTGRES_USER: paperless
      POSTGRES_PASSWORD: paperless

  webserver:
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    restart: unless-stopped
    depends_on:
      - db
      - broker
    ports:
      - "0.0.0.0:8000:8000"
    volumes:
      - data:/usr/src/paperless/data
      - media:/usr/src/paperless/media
      - ./export:/usr/src/paperless/export
      - ./consume:/usr/src/paperless/consume
    env_file: docker-compose.env
    environment:
      PAPERLESS_REDIS: redis://broker:6379
      PAPERLESS_DBHOST: db

volumes:
  data:
  media:
  pgdata:
  redisdata:
# Paperless-ngx environment settings

# A long random string used for session security
PAPERLESS_SECRET_KEY=your-secret-key-here-replace-with-random-characters

# The default language for OCR text recognition
PAPERLESS_OCR_LANGUAGE=eng

# Your local timezone
PAPERLESS_TIME_ZONE=America/New_York
COMPOSE_PROJECT_NAME=paperless

Your Paperless-ngx instance is alive and running. Next up, you will create your admin account and access the web interface from your browser.

Create Your Admin Account and Access the Web Interface

Your three containers are up and running. Paperless-ngx, PostgreSQL, and Redis are all working together behind the scenes.

A running system is no good without a way to log in. In this step, you will create an admin account, open the web dashboard in your browser, and confirm you can reach it from any device on your home network.

In this step, get ready to:
  • Create a superuser account for Paperless-ngx.
  • Log into the web dashboard from your desktop browser.
  • Access the dashboard from a second device on your network.
Create the admin account

Paperless-ngx does not come with a default login. You need to create a superuser before you can access the web interface.

  • In your PowerShell window, make sure you are still in the C:\paperless-ngx directory.
  • Create your admin account by running this command:
docker compose exec webserver python3 manage.py createsuperuser

What will this command ask me?

This command opens an interactive prompt inside the Paperless-ngx container. It asks for four things in sequence:

  • Username — type a name you will remember (e.g. admin).
  • Email address — optional. Press Enter to skip.
  • Password — type a password. Characters will not appear as you type.
  • Password (again) — confirm by retyping the same password.
  • Follow the prompts to enter your username, email (optional), and password.

You should see Superuser created successfully. printed in the terminal.

Seeing a TTY error or no prompts appearing?

If the command fails with a message about not running in a TTY, make sure you are using PowerShell directly and not running the command inside a script or piped input.

If nothing happens for a long time, the webserver container might still be starting up. Run docker compose ps and confirm the webserver status shows "Up" before trying again.

Help me troubleshoot the createsuperuser command

Access the dashboard from your desktop

Your admin account is ready. Now you can open the Paperless-ngx web interface and confirm everything is working.

  • Open your web browser (Edge, Chrome, Firefox, or any browser you prefer).
  • Navigate to http://localhost:8000 in the address bar.
  • Enter the username and password you just created.
  • Click Login.

You should see the empty Paperless-ngx dashboard with no documents listed yet.

Page not loading at localhost:8000?

Return to PowerShell and run docker compose ps. Check that the webserver container shows status "Up" and has port 0.0.0.0:8000->8000/tcp listed.

If the container restarted, wait 30 seconds and try refreshing the page. Paperless-ngx takes a moment to initialize on first boot.

Help me get Paperless-ngx loading in my browser

Access from other devices on your network

The real power of a self-hosted system is accessing it from any device in your home. Your phone, tablet, or laptop can all reach the same dashboard as long as they are on the same Wi-Fi network.

  • Find your PC's local IP address by running this command in PowerShell:
ipconfig

What am I looking for?

Look for the section labeled Wireless LAN adapter Wi-Fi (or Ethernet adapter if you use a wired connection). Find the line labeled IPv4 Address. It will look something like 192.168.1.105. This is the address other devices use to reach your PC.

  • Note down your IPv4 address.
  • On a second device (your phone, tablet, or laptop) connected to the same Wi-Fi network, open a browser.
  • Navigate to http:// followed by your IPv4 address, then :8000 (for example, http://192.168.1.105:8000).
  • Log in with the same username and password you created earlier.

You should see the same empty Paperless-ngx dashboard on your second device.

What if Windows Firewall asks me something?

Windows may show a firewall prompt asking if you want to allow connections on this port. Click Allow access to let other devices on your network reach Paperless-ngx.

If no prompt appeared and your second device cannot connect, you may need to manually add an inbound firewall rule for port 8000. Open Windows Defender Firewall with Advanced Security, click Inbound Rules, then New Rule. Select Port, enter 8000, and allow the connection.

Second device still cannot connect?

Make sure both devices are on the same Wi-Fi network. A phone on mobile data cannot reach your PC's local IP.

Double-check that you typed the IP address correctly. A single wrong digit will fail silently with no error page.

Help me connect to Paperless-ngx from another device

Your document database is live and reachable from anywhere in your home. Next up, you will drop research papers into the system and watch Paperless-ngx automatically process and index them for full-text search.

Ingest Research Papers and Explore Full-Text Search

Your research paper database is live and accessible from multiple devices. Now it is time to put it to work.

In this step, you will drop research PDFs into your consume folder and watch Paperless-ngx automatically detect, OCR, and index them. Then you will use full-text search to find specific content buried inside your papers.

In this step, get ready to:
  • Add research PDFs to the consume folder for automatic ingestion.
  • Verify documents are processed and explore their metadata.
  • Use full-text search to find content inside your papers.
Add papers to the consume folder

Paperless-ngx monitors your consume folder for new files. Any PDF you drop in there gets picked up automatically within 1-2 minutes.

  • Find 3-5 research PDFs on your computer. These can be any academic papers, journal articles, or whitepapers you have downloaded.
  • Open File Explorer and navigate to C:\paperless-ngx\consume.
  • Copy your PDFs into the consume folder.

No research papers handy?

Search Google Scholar or arXiv for any topic that interests you and download a few PDFs. Any document with text content works for testing.

After copying the files, wait 1-2 minutes. Paperless-ngx detects new files, runs OCR to extract text from the pages, and indexes everything for search.

What is OCR?

OCR (Optical Character Recognition) converts images of text into actual searchable text. Even if a PDF is a scanned image rather than native digital text, Paperless-ngx can read its contents.

Verify processing and explore the dashboard
  • Return to the Paperless-ngx web interface at http://localhost:8000.
  • Refresh the page. Your documents should appear in the document list.
  • Click on any document to see its details page.

The details page shows the extracted text, metadata (date added, file size, correspondent), and a preview of the original PDF.

What should I see?

Each document card in the list shows the document title (usually extracted from the filename), the date it was added, and any assigned metadata. Clicking a document opens its full detail view with the extracted text content on the left and a PDF preview on the right.

Documents not appearing after 2 minutes?

Make sure your PDFs are in C:\paperless-ngx\consume and not in a subfolder within it.

Check that all three containers are still running by opening PowerShell and running docker compose ps from the C:\paperless-ngx directory. All three should show status "Up".

If containers restarted, try running docker compose up -d again and wait a couple of minutes.

Help me troubleshoot why Paperless-ngx is not detecting my PDFs in the consume folder.

Use full-text search to find content across all papers

The real power of Paperless-ngx is full-text search. Instead of searching only filenames, it searches the entire extracted text of every document in your library.

  • Think of a word or phrase that you know appears inside the body text of one of your papers. Not in the title, but in the content itself.
  • Click the search bar at the top of the Paperless-ngx dashboard.
  • Type your search term and press Enter.

Paperless-ngx returns matching documents with the search term highlighted in context. This is the same paper you thought of, found by searching its internal content rather than its filename.

Why is this better than searching filenames?

Research papers often have unhelpful filenames like paper_final_v3.pdf. Full-text search means you can find a paper by any concept, author name, or phrase that appears anywhere in the document.

Your scattered PDF collection just became a searchable knowledge base.

Search returning no results?

Make sure the document has finished processing. Freshly ingested documents may take an extra minute to become fully searchable after they appear in the list.

Try a simpler, single-word search term first. If your PDF was a scanned image, OCR quality depends on the scan resolution.

Help me figure out why my full-text search is not finding content I know is in my document.

Your research papers are now indexed and searchable. Next up, you will organize them into categories with document types, tags, and saved views so you can slice your library in useful ways.

Organize with Document Types, Tags, and Correspondents

In the last step, you ingested research papers and proved that full-text search works across all of them.

Finding papers by keyword is powerful, but a real research library needs structure. You need to classify papers by what they are (journal article, whitepaper, report) and label them by topic so you can pull up exactly the subset you need in seconds.

In this step, get ready to:
  • Create document types to classify your papers by format.
  • Create tags to label papers by research topic.
  • Build saved views for instant access to filtered subsets of your library.
Create document types

Document types classify papers by what they are. Think of them as labels on the spine of a binder.

  • Return to the Paperless-ngx dashboard in your browser at http://localhost:8000.
  • In the left sidebar, click Document Types.
  • Click the Create button in the top right corner.
  • In the Name field, type Journal Article.
  • Click Save.
  • Repeat the process to create at least one more document type. Good options include Conference Paper, Whitepaper, or Technical Report.

What are document types?

Document types let you classify papers by their format or purpose. A journal article has a different structure than a whitepaper or conference paper.

Once you assign types, you can filter your entire library to show only journal articles, only whitepapers, or any combination. This mirrors how physical research libraries organize materials by format.

  • Click Documents in the left sidebar to return to the document list.
  • Select the documents you want to assign the same type to by clicking the checkboxes next to them.
  • In the bulk edit bar that appears at the top, click the Document Type dropdown.
  • Select the appropriate type (e.g., Journal Article) and confirm the change.
  • Repeat for your remaining documents, assigning the type that best matches each one.

Not sure which type to pick?

If a paper has an abstract, methodology section, and references list, it is likely a Journal Article. If it describes a product or architecture without formal peer review, Whitepaper is a better fit.

Create tags for research topics

Tags let you label papers by topic. Unlike document types (one per document), you can assign multiple tags to a single paper.

  • In the left sidebar, click Tags.
  • Click the Create button.
  • In the Name field, type your first research topic tag. For example: machine-learning.
  • Click Save.
  • Create at least 2 more tags for other research areas you cover. Good options include security, networking, or databases.

Why use tags instead of folders?

A paper about "machine learning for network security" belongs in two categories. With folders, you would need to pick one. With tags, you apply both machine-learning and security to the same document.

Tags give you the flexibility to organize papers by multiple dimensions at once without duplicating files.

  • Click Documents in the left sidebar.
  • Select the documents that share a common topic by clicking their checkboxes.
  • In the bulk edit bar, click the Tags dropdown.
  • Select the appropriate tag and confirm.
  • Repeat for each topic tag, selecting the relevant documents each time. A single document can receive multiple tags.

Tags not appearing in the dropdown?

Make sure you clicked Save after creating each tag. If you navigated away before saving, the tag was not created. Return to Tags in the sidebar and check your list.

Help me fix my tags in Paperless-ngx

Test filtering and create a saved view

Filters let you narrow your library down to exactly the papers you need. Saved views remember your filter settings so you can access them from the dashboard with one click.

  • Click Documents in the left sidebar to see your full document list.
  • In the filter bar above the document list, click the Document Type filter.
  • Select Journal Article to see only documents of that type.
  • Add a tag filter by clicking Tags in the filter bar and selecting one of your tags.

The document list updates to show only papers matching both filters. You should see a reduced list compared to your full library.

  • With your filters active, click Save (or the save icon) above the document list to create a saved view.
  • Give the view a descriptive name like ML Papers and confirm.
  • Check the option to show this view on the dashboard if prompted.
  • Navigate back to the dashboard. Your saved view now appears as a quick-access section.

What is a saved view?

A saved view is a bookmark for a specific set of filters. Instead of re-applying filters every time you want to see your machine learning papers, you click the saved view name and the filtered list appears instantly.

You can create as many saved views as you like and pin them to your dashboard or sidebar for one-click access.

Saved view not showing on the dashboard?

When creating the saved view, make sure you enabled the option to display it on the dashboard. You can edit the view later by going to the saved views management section in the sidebar and toggling the dashboard visibility.

Help me show my saved view on the dashboard

Your research library now has real structure. You can find papers by format, by topic, or by any combination of both. Next up, you will take this even further in the Secret Mission by configuring automatic matching rules.

Secret mission

Set Up Automatic Matching Rules

Right now you manually assign tags and document types to every paper. What if Paperless-ngx could do that for you? In this secret mission, configure automatic matching rules so newly ingested papers get categorized by topic without lifting a finger.

Clean Up Your Resources

Clean Up Your Resources

Decide whether to keep your resources running, pause them to come back later, or delete them entirely. This project runs entirely locally, so there are no ongoing costs beyond the RAM your Docker containers use while running.

Resources you used:

  • 3 Docker containers (webserver, db, broker) consuming approximately 500MB-1GB of RAM while running.
  • 4 Docker volumes storing your database, documents, and configuration.
  • Project directory at C:\paperless-ngx with configuration files and ingested papers.
  • Docker Desktop application.
  • Windows Firewall inbound rule for port 8000.

Keep everything running

No action needed. Choose this if you are still actively building your research library and want Paperless-ngx to stay accessible.

  • Leave Docker Desktop running and Paperless-ngx stays available at http://localhost:8000.
  • Docker Desktop can be configured to start on login, making your research database always available whenever your PC is on.
  • Any device on your network can continue accessing your library at your PC's local IP address on port 8000.

Pause - I'll come back to this later

Shut down running containers to free up memory while keeping all your data intact. Your documents, tags, matching rules, and saved views are preserved in Docker volumes.

  • Open PowerShell and navigate to your project directory by running:
cd C:\paperless-ngx
  • Stop all containers without deleting data by running:
docker compose stop
  • When you are ready to resume, start the containers again by running:
docker compose start

Your research library will be exactly as you left it, with all documents, tags, and matching rules intact.

Delete - I don't want to use this again

Remove all project resources and start fresh. This permanently deletes your database, stored documents, and all configuration.

  • Open PowerShell and navigate to the project directory by running:
cd C:\paperless-ngx
  • Stop all containers and delete all Docker volumes by running:
docker compose down -v

This is permanent

The -v flag removes all Docker volumes. This permanently deletes your PostgreSQL database, all ingested documents, and your Paperless-ngx configuration. Make sure you have backed up any important papers before running this command.

  • Move up one directory and delete the project folder by running:
cd ..
Remove-Item -Recurse -Force C:\paperless-ngx
  • Remove the Windows Firewall inbound rule for port 8000. Press the Windows key, type wf.msc, and press Enter to open Windows Defender Firewall with Advanced Security.
  • Select Inbound Rules in the left panel.
  • Find the rule for port 8000, right-click it, and select Delete.
  • To uninstall Docker Desktop (optional), open Settings from the Start menu.
  • Select Apps, then Installed apps.
  • Find Docker Desktop in the list, click the three-dot menu, and select Uninstall.

Nice Work!

Nice Work!

You just built a fully functional, self-hosted research paper database running entirely on your local machine. Every PDF you drop into a folder now gets automatically processed, OCR'd, and made searchable from any device on your network.

Here's what you learned:

  • Deployed a multi-container application using Docker Compose with Paperless-ngx, PostgreSQL, and Redis on Windows 11 with WSL 2.
  • Configured a network-accessible research paper database reachable from your desktop, laptop, tablet, and phone on the same network.
  • Ingested research papers with automatic OCR and organized them using document types, tags, full-text search, and saved views.
  • Secret Mission: Configured automatic matching rules for hands-free document categorization on newly ingested papers.

Ready to quiz yourself?