Nanote

Self-hosted notes without a database, honestly reviewed. No marketing fluff, just what you get when you run it.

TL;DR

• What it is: A lightweight, self-hosted note-taking app that stores everything as plain markdown files in folders — no database, no vendor lock-in, no migration nightmare [README].
• Who it’s for: Solo founders, developers, and privacy-conscious users who want notes they can read in a terminal, edit in any text editor, and own completely.
• Cost savings: Notion ($10–16/mo), Obsidian Sync ($8/mo), and Bear ($2.99/mo) all charge recurring fees for sync. Nanote self-hosted runs on a $5–10/mo VPS with no subscription.
• Key strength: The filesystem-first architecture is the entire thesis. Your notes are just .md files in folders — you can grep them, back them up with rsync, version them with git, or abandon Nanote entirely without losing a single word [README].
• Key weakness: 150 GitHub stars, 2 contributors, basic authentication (a single secret key), and several features labeled “pending” in the README — including encryption and mobile apps. This is genuinely early-stage software [README].

---

What is Nanote

Nanote is a web-based note-taking application built by a solo developer (omarmir) who was tired of note apps that require a database between you and your own text files. The pitch is simple: folders are notebooks, markdown files are notes, and the app is a layer of UI and search on top of your existing filesystem.

The technical stack is Nuxt 4, TypeScript, Pinia, Tailwind 3, and Milkdown as the editor — modern, well-chosen tools for a lightweight app [README]. There is no PostgreSQL, no SQLite, no MongoDB. Notes are .md files. Period. That means your data is never trapped in a binary blob that requires a database restore to retrieve — you can always open the volume mount in a terminal and read your notes with cat.

As of this review it sits at 150 GitHub stars with 6 forks and 217 commits — small numbers that tell you exactly what this is: a focused personal project that the author uses daily (“I am now daily driving this for my notes so its not going anywhere”) [README].

The project has shipped 17 releases, which is a positive signal for a 150-star tool. It hasn’t stalled in its first month.

---

Why people choose it

The self-hosted note-taking space is crowded — Joplin, Standard Notes, SiYuan, Logseq, Obsidian (with sync), Memos, Silverbullet, and a dozen others. What makes someone land on Nanote?

The filesystem-portability argument is unusually strong here. Most self-hosted note apps still require you to trust their export format. Joplin uses a proprietary attachment database on top of markdown. SiYuan stores data in its own format. Standard Notes encrypts everything end-to-end, which is great until you need to read a note without the app. Nanote stores nothing that needs translation. If the app breaks, the notes survive. If the project is abandoned tomorrow, you have a folder of .md files that open in every text editor that has ever existed [README].

The “manage notes in terminal or notepad” framing resonates with developers and technical founders who treat notes as files, not as database records. The README explicitly says: “You should be able to manage your notes in terminal, notepad or any other app” — that’s a promise most note apps can’t make [README].

A newsletter that covers self-hosted tools, Enchanted Code’s “Now Self Hosted” series, included Nanote in its March 2025 issue (#10) alongside Memory and DumbPad — putting it in a category of minimalist, low-overhead apps worth trying [1]. The fact that it appeared in a roundup of genuinely used self-hosted tools (not just a GitHub star collection) is the strongest social proof available at this stage.

The honest version: people choose Nanote because it aligns philosophically with how they already think about files, not because it has the most features.

---

Features

Based on the README and repository:

Core note management:

• Notebook-based organization — folders map directly to notebooks, .md files to notes [README]
• Milkdown editor with native markdown support and proper MIME type handling [README]
• Full-text search across all notes, with OS-optimized search (requires ugrep in the Docker build) [README]
• File attachments — inline file picker (::file) and block-level file picker (::fileBlock) via custom remark directives [README]

Custom directives (Nanote’s most distinctive feature): Type these in a note and the UI handles them:

• ::file — inline file picker for uploads
• ::fileBlock — full-line file block picker
• ::today / ::tomorrow / ::yesterday — date insertion
• ::now / ::time — current datetime/time insertion

These feel like a lightweight shortcode system — useful for daily notes and time-stamped entries without leaving the editor [README].

Technical:

• REST API (TypeSafe, fully typed endpoints with validation) — documented as “will be documented better in the future” [README]
• Docker and Docker Compose deployment with a published image (omarmir/nanote) [README]
• Mobile-friendly responsive layout — no dedicated native app, but the UI works on mobile [README]
• PWA support listed in the canonical feature set [merged profile]
• Environment variable configuration for NOTES_PATH, UPLOAD_PATH, CONFIG_PATH, SECRET_KEY [README]

What’s pending (from the README’s own checklist):

• Archive for notes and notebooks
• Rollup checklists across notebooks
• File upload for non-image attachments (images work)
• Encryption at rest — listed as pending despite appearing in the canonical features list [README]
• Mobile/desktop apps via PWA (listed as possible future work)

The encryption discrepancy is worth calling out directly: the merged profile canonical feature list includes encryption, but the README explicitly has it as an unchecked pending item. Take the feature list with that caveat.

---

Pricing: SaaS vs self-hosted math

Nanote is free and open source (AGPL-3.0). There is no cloud version, no paid tier, no commercial offering. The only cost is your infrastructure.

What you’re replacing:

Tool	Monthly cost	Lock-in risk
Notion Personal Pro	$10–16/mo	Proprietary format, export is lossy
Obsidian Sync	$8/mo	Local files, but sync is SaaS
Standard Notes	$3.99–9.99/mo	Open source, but encrypted vault
Bear	$2.99/mo	Apple-only, iCloud sync

Nanote self-hosted:

• VPS (Hetzner CX11 or Contabo): $4–6/mo
• Software cost: $0
• Your notes: plain .md files you own forever

The savings math: If you’re paying $10/mo for Notion or $8/mo for Obsidian Sync, self-hosting Nanote on a $5 VPS saves roughly $60–$130/year. The raw number isn’t as dramatic as escaping Zapier bills, but the portability value is harder to quantify — your notes outlive any subscription.

One important note: if you’re already using Obsidian locally (without sync), Nanote doesn’t save you money. It solves a different problem — web access from any device without syncing a local vault.

---

Deployment reality check

The install path is Docker Compose with a published image. Compared to tools that require database migrations, Redis clusters, and S3 buckets, Nanote’s setup is minimal [README].

What you actually need:

• A Linux VPS with 512MB–1GB RAM (this is a lightweight Nuxt app, not a Java monolith)
• Docker and docker-compose installed
• A volume mount for your notes directory
• A SECRET_KEY environment variable (the default is literally nanote — you must change this)
• A reverse proxy (Caddy, nginx, Traefik) for HTTPS if internet-facing

What can go sideways:

The authentication model is a single shared secret key — not per-user accounts, not OAuth, not LDAP. Everyone who knows the key gets in. For a personal single-user setup this is fine. For a team or multi-user household, it’s a real limitation [README].

Search requires ugrep in the Docker image. The README notes you need it installed and in the path if you’re building from source. The published Docker image (omarmir/nanote) presumably bundles this, but the dependency is worth knowing about.

The REST API exists and is typed, but the README explicitly warns it “will be documented better in the future” and “things are still liable to shift” — meaning you shouldn’t build automation on top of it and expect stability yet [README].

Realistic setup time for a technical user: 20–40 minutes to a working instance. The compose file is included in the repo, volume mount configuration is straightforward. For a non-technical founder following the README: 1–2 hours, mostly spent on reverse proxy and HTTPS configuration rather than Nanote itself. If you need multi-user access or any kind of role-based control, Nanote won’t cover that today.

---

Pros and Cons

Pros

• True filesystem portability. Notes are .md files in folders. No database, no migration, no export job. Grep them, git them, rsync them, open them in Vim — the app is optional, the data is permanent [README].
• Zero cost. No pricing tiers, no feature gating, no “upgrade for X.” AGPL-3.0 means you can inspect, fork, and run it however you like [README].
• Lightweight stack. Nuxt 4 + filesystem I/O means this runs comfortably on the smallest VPS you own, not on a $20/mo server with 4GB RAM.
• Milkdown editor is solid. Milkdown is a well-regarded open-source WYSIWYG markdown editor — better than a raw textarea, not as over-engineered as BlockNote or TipTap configurations [README].
• Custom directives are useful for daily notes. The ::today, ::now, ::tomorrow directives make Nanote work reasonably well as a daily-notes or journal-style tool [README].
• Active shipping cadence. 17 releases and 217 commits from a solo developer who says they use it daily is more confidence than zero-commit tools at the same star count [README].
• Docker-first deployment. Published image, sample compose file, documented env vars — the operational story is clean [README].

Cons

• Single shared secret for auth. One key, one access level. No user accounts, no per-notebook permissions. Not suitable for teams [README].
• Encryption is pending. Listed as a feature in the canonical profile but explicitly unchecked in the README’s own feature checklist. Notes at rest are plaintext on your VPS [README].
• 150 stars, 2 contributors. Bus factor of one. If the developer stops maintaining it, you’re on your own. The AGPL license means you can fork, but you’ll need to maintain it yourself.
• REST API is unstable. Typed endpoints exist but are explicitly pre-v1 with “things are still liable to shift” — building on top of it is a risk right now [README].
• No native mobile apps yet. The README lists mobile/desktop apps as possible future work via PWA. The web UI is mobile-friendly but there’s no installable app [README].
• Requires ugrep for search. A non-obvious external dependency for self-build setups [README].
• No collaboration features. No shared notebooks, no commenting, no real-time editing. This is a personal notes tool, not a team wiki.
• Homepage is explicitly unfinished. The README asks for contributors specifically to fix the homepage: “it’s hard to read so some help there would be appreciated” [README]. The project is aware of its rough edges.

---

Who should use this / who shouldn’t

Use Nanote if:

• You want notes that are just files — no database, no vendor, no migration ever.
• You’re a solo user or at most a household where one shared key is fine.
• You want web access to your notes without paying for Obsidian Sync or Notion.
• You’re comfortable with early-stage software and willing to absorb the occasional rough edge in exchange for owning your data completely.
• You already have a VPS running other self-hosted tools and want to add notes with minimal resource overhead.

Skip it (use Joplin instead) if:

• You need end-to-end encryption for notes containing sensitive information.
• You want a more mature, multi-platform native app experience (Joplin has desktop, mobile, and web with E2EE).
• You need shared notebooks or multi-user access.

Skip it (use Obsidian locally) if:

• You work primarily on one machine and don’t need web/mobile access.
• You want a plugin ecosystem — Obsidian’s is vastly larger than anything Nanote will have for years.
• You don’t want to maintain a VPS.

Skip it (use Standard Notes) if:

• Privacy and encryption are non-negotiable.
• You need apps for every platform (iOS, Android, Linux desktop, Windows) with proper sync.

Skip it (use SiYuan or Logseq) if:

• You need bidirectional linking, graph view, or block-level references — Nanote is straightforward folder/file organization with no graph features.

---

Alternatives worth considering

• Joplin — mature, E2EE optional, desktop and mobile apps, WebDAV/Nextcloud sync. Bigger community, more features, still self-hostable. The obvious upgrade path if Nanote grows too small.
• Obsidian (local, no sync) — the gold standard for local markdown notes with a plugin ecosystem. Doesn’t require a server. Cost: free for personal use.
• Standard Notes — open source, E2EE, multi-platform apps. More opinionated, but encryption is first-class not an afterthought.
• Memos — also filesystem/database-light, more Twitter/microblog-style notes than notebook organization. Same demographic, different UX.
• Silverbullet — self-hosted, markdown-based, filesystem storage with a plugin system. More powerful than Nanote, more complex to configure.
• Flatnotes — another minimal self-hosted markdown notes app with a similar philosophy to Nanote. Enchanted Code’s newsletter reviewed it in the same note-taking issue series [1].
• Notion / Obsidian Sync — if the VPS overhead and early-stage risk aren’t worth it to you, paying $8–10/mo for a polished SaaS product is a reasonable trade.

---

Bottom line

Nanote is the right tool for exactly one kind of person: someone who thinks of notes as files and wants a clean web interface on top of their filesystem without giving up ownership of the data. The filesystem-first architecture is the whole product, and if that philosophy resonates, the execution is solid enough to use daily — which the author does.

The caveats are real and worth naming plainly: single-key auth, pending encryption, 150-star project, one active contributor. This is not a tool you hand to a 10-person team or bet your company’s knowledge base on. It’s a personal notes app for people who would otherwise pay Notion or Obsidian Sync $8–16/mo for the privilege of having someone else manage their .md files.

If that’s you, the setup is 40 minutes and the monthly cost is whatever slice of your VPS you assign to it.

---

Sources

1. Enchanted Code — “Now Self Hosted #10: Nanote, Memory and DumbPad” (March 30, 2025). https://enchantedcode.co.uk/tags/now-self-hosted/

Primary sources:

• GitHub repository and README: https://github.com/omarmir/nanote (150 stars, AGPL-3.0, 2 contributors, 217 commits)