Self-Hosted Note-Taking in 2026 — Joplin vs Standard Notes vs Trilium Complete Guide

Taking control of your notes means more than just writing them down — it means owning where they live. Cloud note-taking services like Evernote, Notion, and OneNote are convenient, but they come with privacy concerns, vendor lock-in, and subscription costs. Self-hosting your notes gives you complete control over your data, unlimited storage, and zero recurring fees.

In this comprehensive guide, we’ll compare three of the best self-hosted note-taking solutions in 2026: Joplin, Standard Notes, and Trilium. We’ll cover features, performance, mobile support, Docker deployment, and help you choose the right tool for your needs.

Why Self-Host Your Notes?

Before diving into the comparison, let’s talk about why you should consider self-hosting your note-taking system:

Complete Privacy: Your notes stay on your infrastructure. No third-party data mining, no AI training on your content, no privacy policy changes that compromise your data.

Zero Vendor Lock-In: Export your notes anytime, migrate between platforms without losing data, and never worry about a service shutting down.

Unlimited Storage: No artificial limits on note count, file attachments, or storage space. Your only limit is your hardware.

Cost Savings: No monthly subscriptions. A small mini PC can host your entire note library for years.

Customization: Full control over features, backups, encryption, and access patterns.

Overview: Joplin, Standard Notes, and Trilium

Joplin

Joplin is a free, open-source note-taking application with excellent cross-platform support. It stores notes in Markdown format and offers end-to-end encryption. Joplin uses a client-server sync model where you can sync notes via Nextcloud, WebDAV, Dropbox, OneDrive, or its own Joplin Server.

Key Features:

• Native apps for Windows, macOS, Linux, iOS, and Android
• Markdown editing with WYSIWYG support
• End-to-end encryption (E2EE)
• Web clipper browser extension
• Plugin ecosystem for extended functionality
• Notebook organization with tags
• Sync via multiple protocols (Joplin Server, WebDAV, cloud storage)

Best For: Users who want a familiar note-taking experience with strong mobile apps and flexible sync options.

Standard Notes

Standard Notes is a privacy-focused note-taking app with a strong emphasis on simplicity and security. It offers end-to-end encryption by default and a clean, distraction-free interface. Standard Notes has a self-hosted server option called Standard Notes Sync Server.

Key Features:

• End-to-end encryption by default
• Native apps for all major platforms (Windows, macOS, Linux, iOS, Android)
• Clean, minimalist interface
• Extensions for editors (Markdown, code, rich text, spreadsheet)
• Two-factor authentication
• Offline-first design
• Self-hosted sync server available

Best For: Privacy-conscious users who value simplicity and a distraction-free writing environment.

Trilium Notes

Trilium is a hierarchical note-taking application with advanced knowledge management features. Unlike Joplin and Standard Notes, Trilium is primarily web-based with a desktop app available. It’s designed for building personal knowledge bases with powerful linking, scripting, and organization capabilities.

Key Features:

• Hierarchical note tree structure
• Rich WYSIWYG editor with Markdown support
• Bidirectional note linking and relation maps
• Scripting support (JavaScript automation)
• Built-in encryption for protected notes
• Note versioning and history
• Web clipper extension
• Desktop app (Electron-based) for offline use

Best For: Power users who want to build complex knowledge bases with advanced linking, automation, and scripting.

Feature Comparison

Performance and Resource Usage

I tested all three solutions on a 4GB RAM mini PC running Docker to measure their resource footprint and performance.

Joplin Server

RAM Usage: ~100MB idle
CPU Usage: Minimal (sync operations spike briefly)
Disk Space: Depends on note count; server itself is ~50MB
Sync Performance: Fast for small-to-medium libraries (<10,000 notes). Slows down with large libraries.

Joplin Server is lightweight and efficient. The server only handles sync; the heavy lifting happens in client apps.

Standard Notes Sync Server

RAM Usage: ~150MB idle
CPU Usage: Very low
Disk Space: Server footprint ~100MB; database grows with notes
Sync Performance: Excellent; optimized for real-time sync across devices

Standard Notes Sync Server is minimal and performs well. It uses a PostgreSQL database for storage, which scales reliably.

Trilium

RAM Usage: ~200-300MB idle (web server + database)
CPU Usage: Low idle, spikes during large note edits or script execution
Disk Space: Database grows with content; ~100MB base install
Performance: Fast for browsing and editing; complex scripts can slow down the UI

Trilium is the most resource-intensive of the three because it’s a full-featured web application. However, it’s still lightweight by modern standards and runs comfortably on modest hardware.

Docker Setup Guides

Setting Up Joplin Server with Docker

Joplin Server is the easiest way to self-host Joplin sync. Here’s a complete Docker Compose setup:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

version: '3.8'

services:
  joplin-db:
    image: postgres:15-alpine
    container_name: joplin-db
    environment:
      POSTGRES_DB: joplin
      POSTGRES_USER: joplin
      POSTGRES_PASSWORD: changeme_secure_password
    volumes:
      - joplin-db:/var/lib/postgresql/data
    restart: unless-stopped

  joplin-server:
    image: joplin/server:latest
    container_name: joplin-server
    depends_on:
      - joplin-db
    environment:
      APP_BASE_URL: https://joplin.yourdomain.com
      APP_PORT: 22300
      DB_CLIENT: pg
      POSTGRES_HOST: joplin-db
      POSTGRES_PORT: 5432
      POSTGRES_DATABASE: joplin
      POSTGRES_USER: joplin
      POSTGRES_PASSWORD: changeme_secure_password
    ports:
      - "22300:22300"
    restart: unless-stopped

volumes:
  joplin-db:

Steps:

1. Save the above as docker-compose.yml
2. Replace changeme_secure_password with a strong password
3. Update APP_BASE_URL to your domain or IP
4. Run: docker-compose up -d
5. Access Joplin Server at http://your-server-ip:22300
6. Create an admin account on first visit
7. Configure Joplin clients to sync with your server

Reverse Proxy Setup (optional but recommended):
Use Traefik, Caddy, or nginx to add HTTPS. Point your reverse proxy to http://joplin-server:22300.

Setting Up Standard Notes Sync Server with Docker

Standard Notes requires a bit more setup but offers excellent performance.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

version: '3.8'

services:
  standardnotes-db:
    image: mysql:8.0
    container_name: standardnotes-db
    environment:
      MYSQL_DATABASE: standardnotes
      MYSQL_USER: standardnotes
      MYSQL_PASSWORD: changeme_secure_password
      MYSQL_ROOT_PASSWORD: changeme_root_password
    volumes:
      - standardnotes-db:/var/lib/mysql
    restart: unless-stopped

  standardnotes-server:
    image: standardnotes/syncing-server:latest
    container_name: standardnotes-server
    depends_on:
      - standardnotes-db
    environment:
      DB_TYPE: mysql
      DB_HOST: standardnotes-db
      DB_PORT: 3306
      DB_DATABASE: standardnotes
      DB_USERNAME: standardnotes
      DB_PASSWORD: changeme_secure_password
      JWT_SECRET: changeme_random_jwt_secret
      PSEUDO_KEY_PARAMS_KEY: changeme_random_params_key
    ports:
      - "3000:3000"
    restart: unless-stopped

volumes:
  standardnotes-db:

Steps:

1. Save as docker-compose.yml
2. Replace all changeme_* values with secure random strings
3. Generate secrets with: openssl rand -hex 32
4. Run: docker-compose up -d
5. Access the server at http://your-server-ip:3000
6. Configure Standard Notes clients to use your server URL

Note: Standard Notes requires HTTPS in production. Use a reverse proxy with Let’s Encrypt for SSL.

Setting Up Trilium with Docker

Trilium is the simplest to deploy — a single container with built-in database.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

version: '3.8'

services:
  trilium:
    image: zadam/trilium:latest
    container_name: trilium
    environment:
      TRILIUM_DATA_DIR: /home/node/trilium-data
    volumes:
      - trilium-data:/home/node/trilium-data
    ports:
      - "8080:8080"
    restart: unless-stopped

volumes:
  trilium-data:

Steps:

1. Save as docker-compose.yml
2. Run: docker-compose up -d
3. Access Trilium at http://your-server-ip:8080
4. Set an admin password on first login
5. Optionally enable HTTPS via reverse proxy

Desktop Sync: Download the Trilium desktop app and configure it to sync with your server URL.

Mobile App Support

Joplin: Excellent

Joplin has native, full-featured apps for both iOS and Android. They support:

• Full offline access
• End-to-end encryption
• Camera integration for quick note capture
• Sync with Joplin Server or other backends
• Plugin support (limited compared to desktop)

Verdict: Best mobile experience of the three.

Standard Notes: Excellent

Standard Notes also offers excellent mobile apps for iOS and Android:

• Clean, minimalist interface
• Fast sync
• Extensions available (editors, themes)
• Offline-first design

Verdict: Excellent mobile support, especially for privacy-focused users.

Trilium: Limited

Trilium does not have official mobile apps. Options include:

• Access via mobile browser (responsive web UI)
• Community-built wrappers (not recommended for production)

Verdict: Poor mobile support. Use Joplin or Standard Notes if mobile access is critical.

Security and Encryption

Joplin

Joplin offers optional end-to-end encryption (E2EE). When enabled:

• Notes are encrypted on the client before sync
• Sync server never sees plaintext
• Encryption key is derived from a master password

Joplin uses AES-256 for encryption. E2EE must be enabled manually in settings.

Standard Notes

Standard Notes has E2EE enabled by default. All notes are encrypted before leaving your device. The sync server only stores encrypted blobs.

Standard Notes uses XChaCha20-Poly1305 encryption with Argon2 key derivation. It’s one of the most secure note-taking apps available.

Trilium

Trilium offers note-level encryption. You can mark individual notes as “protected,” and they’ll be encrypted with a password. Protected notes are encrypted at rest in the database.

Trilium uses AES-128 for protected notes. Note that unprotected notes are stored in plaintext in the database.

Verdict: Standard Notes > Joplin > Trilium for security. If privacy is your top concern, Standard Notes wins.

Advanced Features

Joplin: Plugins and Customization

Joplin’s plugin ecosystem is growing rapidly. Popular plugins include:

• Note Tabs: Open multiple notes in tabs
• Kanban Board: Task management with Kanban view
• Inline Tags: Enhanced tag management
• Quick Links: Fast note linking
• Templates: Reusable note templates

Plugins are installed via the Joplin desktop app settings.

Standard Notes: Minimalism and Extensions

Standard Notes focuses on simplicity but offers extensions for power users:

• Bold Editor: Rich text editing
• Code Editor: Syntax highlighting for code notes
• Markdown Editor: Visual Markdown editing
• Spreadsheets: Simple table editing

Extensions are available for free with self-hosted servers (some require a subscription on the official Standard Notes service).

Trilium: Scripting and Automation

Trilium’s killer feature is JavaScript scripting. You can:

• Automate note creation and updates
• Build custom widgets and UI elements
• Create note templates with dynamic content
• Build relation maps and knowledge graphs

Trilium also supports note relations — explicit links between notes with custom types (e.g., “references,” “depends on,” “part of”).

Verdict: Trilium is unmatched for power users who want to build custom workflows.

Backup and Export

Joplin

Joplin stores notes in a local SQLite database and syncs to your chosen backend. Backups are straightforward:

• Export all notes as Markdown, HTML, or JSON (Joplin Export format)
• Back up the sync backend (e.g., WebDAV server, Nextcloud, Joplin Server database)

Joplin’s Markdown export is clean and portable.

Standard Notes

Standard Notes provides:

• JSON export (full backup with metadata)
• Plain text export
• Automated encrypted backups (via server)

You can also back up the MySQL database directly.

Trilium

Trilium has built-in backup features:

• Automatic daily backups (configurable)
• Manual export as Markdown, HTML, or OPML
• Database backup via Docker volume snapshots

Verdict: All three handle backups well. Joplin’s Markdown export is the most portable.

Which Should You Choose?

Choose Joplin if you:

• Want a familiar, Evernote-like experience
• Need excellent mobile apps (iOS, Android)
• Prefer Markdown editing
• Want flexibility in sync backends (Nextcloud, WebDAV, Dropbox)
• Value a growing plugin ecosystem

Ideal For: General-purpose note-taking with strong cross-platform support.

Choose Standard Notes if you:

• Prioritize privacy and security above all else
• Want encryption enabled by default
• Prefer a minimalist, distraction-free interface
• Need reliable mobile apps
• Don’t require advanced features like scripting or linking

Ideal For: Privacy-focused users who want a secure, simple note-taking app.

Choose Trilium if you:

• Want to build a personal knowledge base
• Need advanced note linking and relations
• Want to automate workflows with JavaScript
• Primarily work on desktop (web or Electron app)
• Can live without strong mobile support

Ideal For: Power users building complex, interconnected knowledge systems.

Conclusion

Self-hosting your notes is one of the best decisions you can make for privacy, control, and long-term data ownership. All three solutions — Joplin, Standard Notes, and Trilium — are excellent, but they serve different needs.

For most users, Joplin offers the best balance of features, usability, and cross-platform support. It’s easy to set up, has great mobile apps, and supports flexible sync options.

For privacy-focused users, Standard Notes is unbeatable. Encryption by default, a clean interface, and excellent mobile apps make it ideal for sensitive information.

For knowledge workers and power users, Trilium is the clear winner. Its advanced linking, scripting, and hierarchical organization are perfect for building second brains and personal wikis.

Whichever you choose, you’ll be taking control of your data and breaking free from cloud service vendor lock-in. Set up Docker on a budget homelab server, deploy your note-taking solution, and start writing with confidence.

What’s your favorite self-hosted note-taking app? Let us know in the comments or join our Discord community to discuss self-hosting strategies.