Memos Review: The Self-Hosted, Markdown-Native Note-Taking Tool for Developers

If you keep notes in Notion or Obsidian but feel uneasy about vendor lock-in, or you simply want something lighter that runs on your own server without subscription anxiety, Memos is worth a serious look. It won’t replace every workflow, but for quick-capture Markdown notes that stay fully under your control, it is hard to beat on the dimension of simplicity-per-feature-per-megabyte.

Memos (project: usememos/memos on GitHub) is an open-source, self-hosted note-taking tool built around one idea: get your thought captured now, organize later. As of its v0.28.0 release in April 2026, the project has accumulated nearly 60,000 GitHub stars, which puts it firmly in the category of tools that have earned their audience rather than just their marketing.

What You Actually Get

The technical footprint is small by design. The server is a single Go binary. The Docker image weighs around 20 MB. You can run it against SQLite for a personal instance or swap in PostgreSQL or MySQL if you need multi-user scale. There is no cloud dependency — zero telemetry baked into the product, no license server phoning home.

The UI is a timeline, not a folder tree. You open the app, type, and press save. There are no notebooks, no project hierarchies, no templates to fill out. Tags (written inline as #hashtag) are the primary organizational layer, and full-text search covers the rest. For a certain kind of developer — the one who accumulates scratchpad thoughts, code fragments, and half-finished todos across a dozen tools — this is exactly the right model.

Markdown support goes further than basic bold and italic. You get syntax-highlighted code fences, tables, LaTeX math (useful if you take technical or research notes), and embedded media. Audio attachments render inline; images support arrow-key navigation in preview mode. You can drag and drop files directly into a memo. Recent releases added a Focus Mode for distraction-free writing and iframe support for embedded video content.

The REST and gRPC APIs are first-class. This matters if you want to push notes programmatically — from a terminal alias, a CI script, or a mobile shortcut. The project also maintains an official Telegram bot integration called Memogram, which lets you forward messages and photos from a Telegram chat directly into your Memos instance. If your note capture lives across multiple surfaces, that kind of plumbing is genuinely useful.

The app ships as a Progressive Web App, so you can install it on a phone or tablet from the browser without going through an app store. Offline functionality is included, though the depth of offline support depends on your browser and PWA implementation — the official docs mark some keyboard shortcuts as still in progress, which suggests that the PWA experience is functional but not fully polished.

Where Memos Fits — and Where It Does Not

Memos is deliberately opinionated about scope, and you should take that seriously before committing to it.

There is no native hierarchical organization. If your workflow depends on nested notebooks, linked document graphs, or database-style structured properties (the kind Notion is built on), Memos will feel spartan. The tag-plus-search model works well once you are used to it, but it is a genuine adjustment if you have spent years building folder structures elsewhere.

There is also no built-in sync in the cloud-sync sense. Your notes live on your server. Remote access means either exposing that server to the internet (with all the security considerations that implies), using a VPN, or tunneling through something like Tailscale or Cloudflare Tunnel. Some users set this up in under an hour; others find it a meaningful barrier. If you are running Memos on a home server and want your notes on your phone while traveling, you need to have thought through network access ahead of time.

The collaborative surface is thin. You can share individual memos via public links, and the microblog mode lets you publish notes as a lightweight personal feed. But real-time collaboration or comment threads — the kind of thing Notion or Confluence handle — are not part of what Memos does.

Import tooling is listed as a work in progress. If you are migrating from another tool with hundreds of notes, you may need to write your own import script against the API. Export, by contrast, is well-covered: you can export to Markdown, JSON, or CSV, which means your data can leave at any time in a portable format.

Self-Hosting in Practice

Deployment for a basic personal instance is one Docker command. The canonical quick-start looks like:

docker run -d \
  --name memos \
  -p 5230:5230 \
  -v ~/.memos/:/var/opt/memos \
  neosmemo/memos:stable

SQLite is the default database and stores everything in the mounted volume. If you want PostgreSQL instead, you pass a --driver flag and a connection string. There is a Docker Compose template in the official documentation for anyone who wants to co-locate Memos with a reverse proxy like Caddy or Nginx.

The maintenance burden is low. Updates come through standard Docker pull-and-restart cycles. The project releases frequently — the community has noted that specific feature requests sometimes land within days, which is unusual for a project of this size. That responsiveness is partly a function of the codebase being split roughly 55% Go backend and 45% TypeScript/React frontend, both of which are approachable stacks for contributing.

How It Compares to the Alternatives

Against Obsidian: Obsidian stores notes as local Markdown files on your filesystem, which gives you maximum portability and plugin extensibility. Memos stores notes in a database (SQLite by default) and surfaces them through a web UI. These are genuinely different models. Obsidian is better if you want a linked-knowledge graph or access to a large plugin ecosystem. Memos is better if you want a web-accessible capture tool that works on any device without syncing files.

Against Notion: Notion is a hosted, structured-data product with collaboration at its core. Memos is a personal capture tool with no spreadsheet-style database views and no real-time collaboration. If your team writes documents together, Notion does things Memos cannot.

Against Google Keep: The comparison is closer. Keep is fast, tag-based, and mobile-first. Memos is self-hosted and Markdown-native where Keep is plain text only. If you want Keep without the Google account and with Markdown, Memos is the most direct replacement — with the added cost of running your own server.

Who Should Deploy It

Memos is a good fit if you already self-host other services and want a unified note capture endpoint, or if you are a developer who wants a scriptable, API-accessible scratchpad that stays on infrastructure you control. The combination of a lightweight server, clean REST API, Telegram integration, and PWA install covers a lot of capture scenarios without adding complexity.

It is not a fit if you need collaborative documents, structured databases, a rich plugin ecosystem, or a setup that works without configuring your own network access. The tool is honest about these tradeoffs — “radically simple” is the project’s own framing, and it means it.