Hosting Your Own Notes With Joplin or Outline

Most note apps hold your writing hostage on someone else's servers and quietly push your data through models you did not ask for. Self-hosting your notes is one of the higher-value self-hosted moves because notes are private, long-lived, and painful to migrate later. Two strong options cover the spectrum: Joplin Server for a local-first, Markdown-powered notebook, and Outline for a collaborative, wiki-style knowledge base.

Notes are the kind of data you accumulate for years, and they are exactly the data you never want to hit a paywall to retrieve. Hosting them yourself means your research, drafts, and reference material live on infrastructure you control, in formats you can export and read long after any given app is abandoned.

This guide compares the two, then shows a clean deployment of each on the same VPS pattern using Docker Compose.

Joplin vs Outline: Pick Your Style

• Joplin is a desktop/mobile app that stores notes as Markdown files, syncs via its own server, and works offline by design. Great for a personal notebook with attachments and end-to-end sync you control.
• Outline is a web-first wiki with rich text, live collaboration, and a beautiful editor. Better for a team knowledge base or public-ish documentation.

If you live in plain text and want offline access on a phone, choose Joplin. If you want a snappy team wiki with slash commands and shared spaces, choose Outline. The decision is really about whether you write alone or with a team.

There is also a hybrid angle: many people run Joplin for their private scratch notes and an Outline workspace for shared documentation like runbooks and architecture pages. The two coexist happily on separate subdomains of the same VPS, and each plays to its strength rather than trying to be everything.

Deploying Joplin Server

Joplin Server needs Postgres and a small app service:

services:
  joplin:
    image: joplin/server:latest
    container_name: joplin
    environment:
      - APP_BASE_URL=https://notes.example.com
      - APP_PORT=22300
      - DB_CLIENT=pg
      - POSTGRES_HOST=db
      - POSTGRES_PORT=5432
      - POSTGRES_DATABASE=joplin
      - POSTGRES_USER=joplin
      - POSTGRES_PASSWORD=secret-db-pass
    depends_on:
      - db
    ports:
      - "127.0.0.1:22300:22300"
    restart: unless-stopped

  db:
    image: postgres:16-alpine
    environment:
      - POSTGRES_DB=joplin
      - POSTGRES_USER=joplin
      - POSTGRES_PASSWORD=secret-db-pass
    volumes:
      - ./db:/var/lib/postgresql/data
    restart: unless-stopped

In the Joplin desktop or mobile app, point the sync target at your server URL and paste the generated token. From then on every device stays in sync through your own host, and because Joplin keeps a local copy, you can read and edit even when the network is gone.

The local copy is worth emphasizing: Joplin does not hold your notes hostage on the server. The server is a sync mechanism, and the authoritative copy lives on each device as plain Markdown. That means your notes remain readable and exportable even if you delete the whole server tomorrow, which is the strongest data-integrity argument for the local-first model.

Pointing the sync target at your server takes seconds in the settings, and the token is scoped per user, so you can revoke a stolen device without touching anyone else's access.

Deploying Outline

Outline is a heavier stack: app, Postgres, Redis, and an S3-compatible storage endpoint for attachments:

services:
  outline:
    image: docker.getoutline.com/outlinewiki:latest
    environment:
      - DATABASE_URL=postgres://outline:secret@db:5432/outline
      - REDIS_URL=redis://redis:6379
      - FILE_STORAGE=s3
      - AWS_REGION=lnd
      - AWS_ACCESS_KEY_ID=minioadmin
      - AWS_SECRET_ACCESS_KEY=minioadminsecret
      - AWS_S3_UPLOAD_BUCKET_URL=http://minio:9000
      - AWS_S3_UPLOAD_BUCKET_NAME=outline
      - SECRET_KEY=generate-a-long-string
      - UTILS_SECRET=another-long-string
      - URL=https://wiki.example.com
    depends_on:
      - db
      - redis
      - minio
    ports:
      - "127.0.0.1:3000:3000"
    restart: unless-stopped

Outline expects OAuth (Slack/Google) for sign-in. You can wire those at the identity provider, or use a lightweight custom OIDC provider if you want local credentials and no dependency on a public OAuth service.

Pick One, Keep It Simple

Start with a single note app rather than running both. Both integrate fine with a shared reverse proxy and a Postgres instance. Whichever you choose, schedule regular backups of the application data volume — notes are the kind of data you can never re-download.

The migration path between them is also friendly. Joplin exports plain Markdown that any tool can import, and Outline offers documented export too, so neither choice is a trap. Pick the one that matches your writing style today and you can move later without losing a decade of notes.

Takeaway

Hosting your notes removes dependency on closed sync services and keeps your writing fully yours, either as plain text with Joplin or a collaborative wiki with Outline.

A 2 GB Ubuntu VPS on Netbay comfortably serves either stack, deployable in under 60 seconds at netbayhosts.in.