Memos: A Lightweight Self-Hosted Note-Taking and Micro-Blogging Platform

Most note-taking apps want you to organize everything into notebooks, folders, and hierarchies before you even start writing. But quick thoughts don't fit neatly into categories. You have a code snippet you want to save, a half-formed idea from a meeting, a link worth revisiting later, a command you keep forgetting. These fragments need a place to land — fast, searchable, and private.

Photo by imgix on Unsplash

Memos is a self-hosted, open-source note-taking platform built around a simple timeline interface. Think of it as a private Twitter for your thoughts: open it, type something, hit save, move on. Everything is stored as plain-text markdown, organized with tags, and searchable through a clean web UI. With 56,000+ GitHub stars and an active development community, Memos has become one of the most popular self-hosted productivity tools for people who want quick capture without the overhead of a full knowledge management system.

What Is Memos?

Memos is an open-source project (usememos/memos) written in Go with a React/TypeScript frontend. It runs as a single binary, stores data in SQLite by default (with PostgreSQL and MySQL options), and serves a responsive web interface on port 5230.

The design philosophy is deliberately minimal. There are no folders, no nested hierarchies, no complex organizational systems. You write memos — short-form notes that appear in a reverse-chronological timeline. Tags, full-text search, and filtering handle the organization. If you have ever wished you could grep your brain's scratch buffer, Memos is the closest self-hosted equivalent.

The project is MIT-licensed, collects zero telemetry, and has no cloud dependencies. Your data stays on your server, period.

Key Features

Markdown Support

Memos uses full Markdown for formatting, including:

• Headers, bold, italic, strikethrough
• Code blocks with syntax highlighting
• Tables
• LaTeX math expressions
• Checklists (interactive to-do items)
• Embedded links and images

The editor is fast and uncluttered. No WYSIWYG toolbar fighting you — just type markdown and it renders inline.

Tagging and Organization

Tags in Memos work like hashtags. Type #project/backend or #todo directly in your memo text, and Memos automatically indexes them. Tags support hierarchical notation with slashes (#work/meetings, #work/ideas), giving you lightweight organization without rigid folder structures.

The sidebar shows all your tags in a tree view, and clicking any tag filters your timeline to matching memos. Combined with full-text search, this makes finding old notes fast even when you have thousands of entries.

REST and gRPC APIs

Memos exposes both REST and gRPC APIs with full read-write access. This opens up powerful automation:

• Save notes from scripts, bots, or CLI tools
• Build custom integrations with other services
• Programmatically search and export your data
• Create webhook-driven workflows with tools like n8n or Home Assistant

Mobile-Friendly and PWA

The web interface is fully responsive and can be installed as a Progressive Web App (PWA) on both iOS and Android. Once installed, Memos behaves like a native app with its own icon, offline support, and push-to-capture convenience. There are also third-party mobile apps available for both platforms.

Single Sign-On (SSO)

Memos supports SSO through OpenID Connect (OIDC), making it easy to integrate with identity providers like Authentik, Keycloak, Authelia, or even Google Workspace. For multi-user deployments, this means centralized authentication without managing separate credentials.

Resource Management

Memos handles file attachments directly. Drag and drop images, videos, audio files, or documents into a memo, and they are stored alongside your data. No need for a separate file hosting service — everything lives in one place and is accessible through the same interface.

Sharing and Public Memos

Individual memos can be marked as public, generating a shareable link. This turns Memos into a lightweight microblog — useful for publishing short updates, sharing code snippets with colleagues, or maintaining a public changelog. Private by default, public when you choose.

Deploying Memos with Docker Compose

Memos is one of the simplest self-hosted applications to deploy. A single container handles everything.

Basic Setup (SQLite)

Create a directory for your deployment and add a docker-compose.yml:

services:
  memos:
    image: neosmemo/memos:stable
    container_name: memos
    restart: unless-stopped
    ports:
      - "5230:5230"
    volumes:
      - ./memos-data:/var/opt/memos

Start it:

docker compose up -d

Open http://your-server:5230 in a browser. The first user to register becomes the admin. That is the entire setup — no database to configure, no environment variables required, no companion services.

Production Setup with PostgreSQL

For larger deployments or if you prefer a dedicated database server, Memos supports PostgreSQL:

services:
  memos:
    image: neosmemo/memos:stable
    container_name: memos
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy
    ports:
      - "5230:5230"
    environment:
      MEMOS_DRIVER: postgres
      MEMOS_DSN: postgresql://memos:${POSTGRES_PASSWORD}@postgres:5432/memos?sslmode=disable
    volumes:
      - memos-data:/var/opt/memos

  postgres:
    image: postgres:16-alpine
    container_name: memos-db
    restart: unless-stopped
    environment:
      POSTGRES_USER: memos
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: memos
    volumes:
      - memos-pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U memos"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  memos-data:
  memos-pgdata:

Create a .env file:

POSTGRES_PASSWORD=your-secure-password-here

Start the stack:

docker compose up -d

Behind a Reverse Proxy

For HTTPS access, put Memos behind a reverse proxy. Here is a Caddy example:

notes.yourdomain.com {
    reverse_proxy localhost:5230
}

Or with Nginx:

server {
    listen 443 ssl http2;
    server_name notes.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/notes.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/notes.yourdomain.com/privkey.pem;

    location / {
        proxy_pass http://localhost:5230;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Configuration and Setup Walkthrough

First Launch

After starting Memos, navigate to the web interface. You are prompted to create an admin account. Once logged in, you land on the timeline view — an empty canvas ready for your first memo.

Settings to Configure Early

Navigate to Settings (gear icon) and consider these adjustments:

• Server URL: Set your public-facing URL if using a reverse proxy. This ensures shared links and API endpoints use the correct address.
• Registration: Disable open registration if this is a personal instance. Go to Settings → System → General and toggle registration off.
• Storage: Configure where uploaded resources (images, files) are stored. The default is local filesystem, but you can configure S3-compatible storage for scalability.
• SSO: If you run an identity provider, configure OIDC under Settings → System → SSO to enable single sign-on.

Daily Workflow

The typical Memos workflow is intentionally simple:

1. Open Memos (or the PWA on your phone)
2. Type your thought, snippet, link, or note
3. Add tags inline with #tag-name syntax
4. Hit save (or Ctrl+Enter)
5. Move on

Later, find things through the tag sidebar, full-text search, or the calendar filter that lets you browse memos by date. The lack of organizational friction is the point — Memos encourages you to capture everything without deciding where it belongs first.

Using the API

Generate an access token from Settings → My Account. Then interact with your memos programmatically:

# List recent memos
curl -s https://notes.yourdomain.com/api/v1/memos \
  -H "Authorization: Bearer your-access-token" | jq '.memos[:3]'

# Create a new memo
curl -X POST https://notes.yourdomain.com/api/v1/memos \
  -H "Authorization: Bearer your-access-token" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Quick note from the command line #cli #automation"
  }'

This makes it straightforward to pipe output from scripts, cron jobs, or monitoring tools directly into your Memos timeline.

Comparison: Memos vs Obsidian vs Standard Notes vs Joplin

When to Choose Each

Memos — You want a fast, frictionless capture tool for fleeting thoughts, code snippets, daily logs, and quick references. You value a timeline interface over hierarchical organization. You want multi-user support or public sharing.

Obsidian — You are building a personal knowledge management system with interlinked notes, a graph view, and heavy customization through plugins. You want local-first with no server dependency.

Standard Notes — Privacy and end-to-end encryption are your top priorities. You want a clean, minimal editor with strong security guarantees.

Joplin — You need a full-featured note-taking app with notebooks, tags, and the ability to sync across devices using your own server or cloud storage. You want rich formatting and plugin support.

These tools are not mutually exclusive. Many people run Memos alongside Obsidian — using Memos for quick capture throughout the day and Obsidian for longer, structured knowledge work.

Use Cases

Personal Knowledge Capture

The most common use case. Memos replaces the random text files, sticky notes, and browser tabs you use to temporarily hold information. A command you just figured out, a configuration snippet, a thought about a project — capture it in seconds and find it later with search or tags.

Developer Daily Log

Use Memos as a work journal. Tag entries with #standup, #debug, or project names. At the end of the week, filter by tag to reconstruct what you worked on. The timeline format is natural for chronological logging.

Team Quick Notes

In multi-user mode, Memos works as a lightweight team bulletin board. Share quick updates, post useful links, and document ad-hoc decisions that don't warrant a full wiki page or Slack thread.

Self-Hosted Microblog

With public memo sharing, Memos doubles as a personal microblog. Publish short-form content, code snippets, TILs (Today I Learned), or project updates. The API makes it possible to syndicate public memos to other platforms.

Read-It-Later and Link Collection

Save interesting links with a quick note about why they matter. Tag them by topic. Unlike browser bookmarks, the surrounding context you write is searchable, so you can find that "article about Postgres vacuum tuning" even if you forgot the title or URL.

Meeting Notes and Action Items

Memos' checklist support makes it useful for capturing action items during meetings. Create a memo with attendees and to-do items, then check them off as they are completed. Tags like #meeting/weekly or #meeting/project-x keep them organized.

Tips and Best Practices

Develop a Tagging Convention

Decide on a tag hierarchy early and stick with it. A few examples:

• #work/project-name for work-related notes
• #til for things you just learned
• #todo for action items
• #ref for reference material you revisit often
• #idea for half-formed thoughts worth revisiting

Consistent tagging pays dividends as your memo count grows into the hundreds and thousands.

Use the Keyboard

Memos supports keyboard shortcuts throughout the interface. Ctrl+Enter saves a memo. Ctrl+K inserts a link. / focuses the search bar. Learning a handful of shortcuts makes the capture-and-move-on workflow significantly faster.

Back Up Your Data

For SQLite deployments:

# Simple backup — copy the data directory
cp -r ./memos-data ./memos-backup-$(date +%Y%m%d)

For PostgreSQL deployments:

docker exec memos-db pg_dump -U memos memos > memos-backup-$(date +%Y%m%d).sql

Schedule these with cron. Memos data is small (mostly text), so backups are fast and cheap to store.

Secure Your Instance

If your Memos instance is internet-facing:

• Put it behind a reverse proxy with HTTPS
• Disable open registration after creating your account
• Consider Cloudflare Access, Authelia, or another authentication layer in front of it
• If using SSO, restrict allowed email domains

For personal use, keeping Memos behind a VPN (Tailscale, WireGuard) is the simplest security model.

Integrate with Your Workflow

The API opens up many possibilities:

• Shell alias: Create a memo command that posts directly from your terminal
• iOS/Android Shortcuts: Use the API to create a share-sheet action that sends content to Memos
• CI/CD: Post build summaries or deployment notifications to a dedicated Memos account
• Browser bookmarklet: One-click to save the current page URL and title as a memo

Keep It Simple

Resist the urge to over-organize. Memos is designed for speed and simplicity. If you find yourself spending more time tagging and organizing than writing, you are using it wrong. Write first, organize later (or not at all — search handles most retrieval needs).

Conclusion

Memos fills a specific gap in the self-hosted ecosystem: fast, frictionless capture of thoughts, snippets, and references without the organizational overhead of a full note-taking application. It is not trying to replace Obsidian for knowledge management or Standard Notes for encrypted long-form writing. Instead, it gives you a private timeline where quick thoughts have a home.

The single-container deployment, SQLite default, and minimal resource footprint make it one of the easiest self-hosted apps to get running. The API, SSO support, and multi-user capabilities mean it scales from a personal scratch pad to a small team's shared notes without changing tools.

If you have ever typed a note into a random text file and then lost it three days later, Memos is worth the five minutes it takes to deploy.

Resources

• Memos official site
• Memos GitHub repository
• Memos documentation
• Docker deployment guide
• Memos feature overview
• Memos API documentation
• Obsidian — Local-first knowledge management
• Standard Notes — Encrypted note-taking
• Joplin — Open-source note-taking with sync