Your Notes Are Everywhere and That’s the Problem
You’ve got six devices, four note apps, and a dozen tabs open right now with things you “definitely don’t want to forget.” Some of it’s in Google Keep. Some is a shared doc. Your actual important notes? Probably in Notion, where a company you’ve never met stores them on servers you’ll never see.
Notes are personal. More personal than most people treat them. Passwords, SSH keys, project ideas, that one bash one-liner you found at 2 AM, you don’t want any of that floating through someone else’s cloud. Self-hosting your notes app is one of those things that sounds complicated until you’ve done it once, and then you wonder why you waited.
Three apps dominate the self-hosted notes space: Joplin Server, Trilium (specifically the actively maintained TriliumNext fork), and Standard Notes. They’re all self-hostable, all privacy-focused, and all genuinely good, but they’re solving different problems. This comparison will save you from setting up the wrong one and regretting it.
The Contenders at a Glance
| Feature | Joplin Server | TriliumNext | Standard Notes |
|---|---|---|---|
| Data model | Flat markdown notes + notebooks | Hierarchical tree | Flat blocks/notes |
| E2EE | Yes (AES-256 + RSA) | Protected notes only | Yes (end-to-end) |
| Web clipper | Yes | Partial | No |
| Mobile app | Polished (iOS + Android) | Android sender only | Polished (iOS + Android) |
| Rich linking | Limited (note links) | Full (attributes, relations, backlinks) | No |
| Plugin story | Plugin ecosystem, JS API | Server-side JS scripting | Extension server |
| Docker complexity | Medium | Low | High |
| Self-host vibe | ”Just works” | Power user heaven | ”Why are there 8 containers?” |
Joplin Server, The Familiar One That Just Works
Joplin has been around long enough that you’ve probably tried the desktop app already. What most people don’t know is there’s an official sync server (not just Joplin Cloud) that you can run yourself. Joplin Server is that companion server, it handles sync, user accounts, and note sharing across all your Joplin clients.
The data model is classic markdown: notebooks → notes, with optional subnotebooks. It’s flat-ish by design. If you’ve used Bear, Obsidian in basic mode, or literally any note app from the last decade, you already know how it works. Joplin reads and writes standard CommonMark markdown with YAML frontmatter for metadata. Your notes are portable.
E2EE is the real deal here. When you enable encryption in Joplin, the server never sees plaintext. Not the note content, not the attachments, nothing. The keys stay on your devices. This is proper client-side encryption, if you lose the master key, the notes are gone. Treat that master key like a root password.
The web clipper is excellent, probably the best of the three. The browser extension (Chrome, Firefox) saves full pages, simplified articles, or selections directly into your notebooks. If you’re building a research workflow or saving documentation, this matters more than you think.
Mobile parity is solid. The iOS and Android apps are feature-complete: editing, notebooks, sync, tags, search, attachments. They’re not going to win a design award, but they work reliably, which is the actual bar.
Joplin Server Docker Compose
services: joplin-db: image: postgres:16-alpine container_name: joplin-db restart: unless-stopped environment: POSTGRES_DB: joplin POSTGRES_USER: joplin POSTGRES_PASSWORD: changeme_db_password volumes: - joplin_db_data:/var/lib/postgresql/data healthcheck: test: ["CMD-SHELL", "pg_isready -U joplin"] interval: 10s timeout: 5s retries: 5
joplin-server: image: joplin/server:3.7.1 container_name: joplin-server restart: unless-stopped depends_on: joplin-db: condition: service_healthy ports: - "22300:22300" environment: APP_BASE_URL: "https://notes.yourdomain.com" APP_PORT: 22300 DB_CLIENT: pg POSTGRES_HOST: joplin-db POSTGRES_PORT: 5432 POSTGRES_DATABASE: joplin POSTGRES_USER: joplin POSTGRES_PASSWORD: changeme_db_password MAILER_ENABLED: 0
volumes: joplin_db_data:Caddy reverse proxy block for this:
notes.yourdomain.com { reverse_proxy joplin-server:22300}After deploying, navigate to https://notes.yourdomain.com/login and log in with [email protected] / admin, change that immediately. Then in your Joplin desktop app, go to Tools → Options → Synchronisation, select Joplin Server, and point it at your URL with your credentials. That’s genuinely it. Five minutes and you’re syncing.
TriliumNext, For People Who Think in Trees
Trilium is a fundamentally different thing. It’s not “Evernote but self-hosted.” It’s closer to a personal knowledge database, a hierarchical note tree where every note can be a child of multiple parents, every note can have attributes and relations, and the whole thing is scriptable with server-side JavaScript.
If you’ve ever wanted your notes to be more like a wiki crossed with a database crossed with a mind map, Trilium is what you’ve been looking for. The data model is a tree. Notes have parents, children, and clones (one note appearing in multiple places without duplication). Attributes let you tag notes with key-value pairs that become queryable, #type=recipe, #status=active, #project=homelab. Relations link notes to each other with named relationship types.
The scripting is genuinely powerful and also genuinely “here be dragons.” You can write server-side JS that runs on note events, generates content automatically, builds dashboards, queries your note tree, and more. It’s the feature that makes Trilium irreplaceable for power users and slightly terrifying for everyone else.
E2EE is partial, “protected notes” encrypt individual notes client-side, but the database at rest isn’t fully encrypted. If someone gets your database file, unprotected notes are readable. For most self-hosting setups where your server is already secured, this is fine. If you need every byte encrypted, Joplin or Standard Notes is a better fit.
Honestly, the biggest caveat in 2026 is mobile. The official Trilium mobile story is still a work in progress. There’s Trilium Sender (Android only), which lets you quickly capture text and send it to your Trilium instance, it’s not a full client, just a quick-capture widget. A proper mobile UI has been in development, but as of mid-2026 it’s still incomplete and not something you’d rely on for daily use. If mobile access matters, factor this in heavily.
Web interface is excellent, this is where Trilium shines. The full desktop-class web UI is what most people use even on their own machines. It’s fast, keyboard-navigable, and the tree panel on the left makes finding anything intuitive once your hierarchy is set up.
TriliumNext Docker Compose
services: trilium: image: triliumnext/notes:0.92.6 container_name: trilium restart: unless-stopped ports: - "8080:8080" environment: TRILIUM_DATA_DIR: /home/node/trilium-data volumes: - trilium_data:/home/node/trilium-data
volumes: trilium_data:That’s the entire stack. One container, one volume. Caddy:
trilium.yourdomain.com { reverse_proxy trilium:8080}On first launch you’ll go through a setup wizard, choose “new instance” unless you’re restoring a backup. Set a strong password. The data lives in the volume as a SQLite database. Back that up. Trilium has a built-in ETAPI (REST API) if you want to automate exports or hook it into other tools.
Standard Notes, The Encryption-First Minimalist
Standard Notes is philosophically different from the other two. The whole point of the app is that it does less on purpose so it can guarantee more. The core principle: notes are encrypted with your password before they leave your device, always. The server is deliberately dumb, it stores encrypted blobs and syncs them. It cannot read your content. This is architecture-level E2EE, not a toggle you enable.
The tradeoff: the base app is minimal. Plain text, basic organization, that’s mostly it. Rich editing (markdown preview, rich text, code editor, spreadsheets) requires extensions, which historically required a paid “Extended” subscription or running an extension server yourself. In 2026 the extension ecosystem has improved but “getting the full Standard Notes experience self-hosted for free” still involves more setup than the other two.
The mobile apps are polished. iOS and Android both have full feature parity with the desktop clients, proper biometric lock, and smooth sync. If mobile is your primary concern and you need real E2EE with good mobile apps, Standard Notes is genuinely excellent, and honestly, at that point, you might consider just paying for their hosted plan. The self-hosted setup is complex enough that the cost/benefit calculation is real.
Standard Notes Docker Compose
Buckle up. The official self-hosted stack has six to eight services depending on which features you want. Here’s the production-realistic version:
services: db: image: postgres:16-alpine container_name: sn-db restart: unless-stopped environment: POSTGRES_DB: standardnotes POSTGRES_USER: standardnotes POSTGRES_PASSWORD: changeme_db_password volumes: - sn_db_data:/var/lib/postgresql/data healthcheck: test: ["CMD-SHELL", "pg_isready -U standardnotes"] interval: 10s timeout: 5s retries: 5
redis: image: redis:7-alpine container_name: sn-redis restart: unless-stopped volumes: - sn_redis_data:/data
auth-server: image: standardnotes/auth-server:2.45.0 container_name: sn-auth restart: unless-stopped depends_on: db: condition: service_healthy environment: DB_HOST: db DB_PORT: 5432 DB_DATABASE: standardnotes DB_USERNAME: standardnotes DB_PASSWORD: changeme_db_password REDIS_URL: redis://redis:6379 JWT_SECRET: changeme_jwt_secret_32chars_min AUTH_JWT_SECRET: changeme_auth_jwt_secret ENCRYPTION_SERVER_KEY: changeme_32_char_hex_key_here_00 PORT: 3002
syncing-server: image: standardnotes/syncing-server:2.52.0 container_name: sn-sync restart: unless-stopped depends_on: db: condition: service_healthy environment: DB_HOST: db DB_PORT: 5432 DB_DATABASE: standardnotes DB_USERNAME: standardnotes DB_PASSWORD: changeme_db_password REDIS_URL: redis://redis:6379 AUTH_SERVER_URL: http://auth-server:3002 PORT: 3000
files-server: image: standardnotes/files-server:1.24.0 container_name: sn-files restart: unless-stopped environment: AUTH_SERVER_URL: http://auth-server:3002 PORT: 3104 volumes: - sn_uploads:/opt/server/uploads
api-gateway: image: standardnotes/api-gateway:2.36.0 container_name: sn-gateway restart: unless-stopped depends_on: - auth-server - syncing-server ports: - "3000:3000" environment: AUTH_SERVER_URL: http://auth-server:3002 SYNCING_SERVER_URL: http://syncing-server:3000 FILES_SERVER_URL: http://files-server:3104 PORT: 3000
volumes: sn_db_data: sn_redis_data: sn_uploads:Caddy:
notes.yourdomain.com { reverse_proxy sn-gateway:3000}This is the gotcha: this stack is six containers minimum for a working install. Keeping these all in sync version-wise, debugging when one service is unhealthy, and updating them requires more operational overhead than Joplin or Trilium. If you enjoy running microservices for fun, great. If you just want your notes to sync, you’re going to have a moment.
Head-to-Head: The Real Decisions
Search
All three have full-text search. Joplin’s is fast and indexed, works across encrypted notes client-side. Trilium’s search is powerful, you can search by attributes, note content, note type, and combine conditions. Standard Notes search is basic but functional for the plain-text model. Edge: Trilium for power, Joplin for reliability.
Attachments
Joplin handles attachments well, images, PDFs, files all inline in the editor, synced through the server. Trilium supports attachments per note. Standard Notes requires the files server running (that extra container in the compose above) and a subscription tier for full attachment support on their hosted plan. Edge: Joplin.
Web Clipper
Joplin has the best web clipper. Browser extension, multiple clip modes, directly into your notebook. Trilium has a basic browser extension. Standard Notes has no native web clipper. If you’re doing research and clipping constantly, Joplin wins this category by a mile.
Plugin and Extension Story
Joplin: Desktop plugin ecosystem (JS/TS API), custom themes, community plugins. Quality varies but there are solid options, markdown viewer, note graph, rich editor plugins.
Trilium: Server-side scripting in JS that can do almost anything. Not “plugins” in the traditional sense, but if you want to build custom behavior, automated note templates, dashboard views, relation-based navigation, Trilium gives you the tools. Steep learning curve.
Standard Notes: Extensions require either a subscription or running the extension server yourself. This is the “gotcha” most people hit: they set up the stack, then discover the editor they want costs extra. The official self-host docs explain how to get extensions without a subscription, but it adds setup complexity.
Operational Simplicity
Ranked simplest to most complex:
- TriliumNext: one container, one SQLite file, one backup command
- Joplin Server: two containers (app + Postgres), straightforward
- Standard Notes: six containers, multiple service versions to track, more attack surface for “why isn’t this working”
The Bottom Line
Choose Joplin Server if:
- You want markdown-first notes that work the same on desktop, mobile, and web
- You clip a lot of web content
- You need real E2EE where the server is truly blind
- You’re migrating from Evernote or Bear and want a familiar experience
Choose TriliumNext if:
- You think in hierarchies, outlines, and interconnected knowledge bases
- You want to script your notes app and build custom tooling inside it
- You primarily work from a desktop browser and can live without a proper mobile app
- You’re building a personal wiki, not just taking notes
Choose Standard Notes if:
- E2EE is non-negotiable and you don’t trust partial implementations
- Mobile parity is critical and you want polished iOS/Android clients
- You’re honestly okay considering their hosted plan: because the self-host complexity might not be worth it compared to paying them $9/month and knowing someone else is keeping six microservices alive at 2 AM
Honestly, for most people coming to this from “I don’t want my notes in Notion anymore,” Joplin Server is the answer. It’s the least surprising, the most portable, and the easiest to explain to the one person on your team who might also want access. Set it up once and forget it exists, which is the highest compliment you can pay to infrastructure.
Trilium is for the person who already has a labeled binder for their labeled binders. You know if that’s you.
Standard Notes is genuinely excellent software that got a bit too complex for self-hosting to be the obvious choice. If the mission is privacy above all else and you have the patience for the stack, it delivers. Otherwise, pay them the $9 and get on with your life.
