Self-Hosted Notion Alternative: AppFlowy vs Affine vs Anytype vs Outline vs SiYuan
Here's a question that should bother you more than it does: where do your notes actually live?
If the answer is "Notion," then the honest follow-up is: on someone else's computer, in a proprietary format, behind an API you can't export cleanly, with a terms-of-service that can change tomorrow. Notion is a genuinely great product. It's also a black box you rent. Your second brain — the thing holding your meeting notes, your project plans, your half-finished novel, your kid's medical history, your business's entire operating manual — is a tenant in a building you don't own and can't inspect.
The self-hosting crowd has spent the last few years building real answers to this. The problem isn't a lack of options anymore — it's that there are now five credible ones, and they're built on two fundamentally different philosophies that most comparison posts blur together.
This post is about the decision that actually matters, not the feature checklist. Because before you ask "which one has the best kanban board," you need to answer a question that determines everything downstream:
Do you want your data to live on your device first, or on your server first?
That's the local-first vs server-based split, and it's the whole ballgame. Let me show you why, then walk you through all five tools honestly.
The One Decision That Matters: Local-First vs Server-Based
Every self-hosted Notion alternative falls into one of two camps, and the camp determines your entire experience — sync, offline, collaboration, backup, and what happens when your server dies.
Local-First (data lives on your device, sync is an afterthought)
In a local-first tool, the source of truth is a file (or database) on your own machine. The server — if there even is one — is just a sync relay and a backup. Your notes work with zero network. You can open them in a text editor. If the company behind the tool vanishes tomorrow, your data is still sitting on your disk in a format you can read.
The tradeoff: real-time multiplayer collaboration is hard. Local-first tools are fundamentally single-user-first. They bolt collaboration on later, and it's never as smooth as Google Docs. If you need five people editing the same page simultaneously, local-first will frustrate you.
Server-Based (data lives on your server, devices are thin clients)
In a server-based tool, the source of truth is a database running on a machine you control. Your laptop and phone are just windows into it. This is the classic self-hosted model — it's how your Jellyfin, your Nextcloud, your Vaultwarden all work.
The tradeoff: you need the server up to do anything. No server, no notes. And "self-hosted" means you are now the sysadmin responsible for backups, uptime, and security patches. The tool is free; your time is not.
The Decision Framework
Here's the framework I use, and it's the spine of this whole post. Answer these four questions in order:
- How many people need to edit the same page at once? If the answer is "more than one, regularly," you're server-based. Stop reading the local-first section.
- Do you need your notes to work on a plane, in a tunnel, with zero signal? If yes, local-first wins by default.
- How much do you trust yourself to run a server? Server-based tools are only as reliable as your backups. Local-first tools are only as reliable as your sync setup. Pick the failure mode you're more comfortable managing.
- What's your exit strategy? If the tool dies, can you get your data out in a useful form? This is where most tools fail, and I'll flag it for each.
Now let's meet the five contenders.
The Five Contenders, At a Glance
| Tool | Philosophy | Language | Sync Model | Collaboration | Best For |
|---|---|---|---|---|---|
| AppFlowy | Local-first | Rust + Flutter | Self-hosted cloud or local | Basic (workspaces) | Notion refugees who want native apps |
| Affine | Local-first | TypeScript | Self-hosted cloud | Real-time (CRDT) | Whiteboard + docs hybrid |
| Anytype | Local-first | Go + TypeScript | P2P encrypted sync | Limited | Privacy-first, offline-first |
| Outline | Server-based | TypeScript | Server is source of truth | Excellent (real-time) | Teams, wikis, docs |
| SiYuan | Local-first | Go + TypeScript | Self-hosted sync | None (single-user) | Power users, PKM, block-level |
Notice something: four of the five are local-first. That's not an accident. The self-hosting community has spent years being burned by server-based lock-in, and the pendulum has swung hard toward "my data, my disk, my format." Outline is the lone server-based holdout, and it's the best of the bunch if you actually need real-time team collaboration.
Let me go through each one properly.
AppFlowy — The Notion Clone That Runs on Your Machine
AppFlowy is the most direct answer to "I want Notion, but self-hosted." It's an open-source reimplementation of Notion's core model — pages, blocks, databases, kanban, calendar — written in Rust (for the backend) and Flutter (for the cross-platform apps). It's fast, it's polished, and it's the closest thing to a drop-in Notion replacement you'll find.
What it gets right:
- Native apps everywhere. Windows, macOS, Linux, iOS, Android. This is the biggest differentiator — most self-hosted tools are web-first, and AppFlowy gives you a real desktop app that feels like a first-class citizen.
- The Notion mental model, minus the lock-in. If you already think in Notion's blocks-and-databases paradigm, there's zero learning curve.
- Local-first by default. Your data lives in a SQLite database on your machine. You can use it fully offline, forever, with no account.
What it gets wrong:
- Collaboration is still young. AppFlowy has been promising real-time multiplayer for years, and it's still not there. Workspaces exist, but simultaneous editing is not the smooth experience you'd get from Outline or Notion.
- Sync requires their cloud (or self-hosting the sync server). The local-first promise is real, but syncing across devices means either paying for AppFlowy Cloud or running their sync server yourself — which is a non-trivial Docker setup.
- The AI features are a moving target. AppFlowy has been pushing AI hard, and the feature set churns. If you want a stable, boring tool, the churn can be annoying.
The verdict: AppFlowy is the best choice if you're a solo Notion user who wants to keep the Notion feel but own your data. It's not the best choice for teams, and it's not the best choice if you want something that's been stable for years.
Docker Compose (self-hosted sync server):
services:
appflowy:
image: appflowyinc/appflowy_cloud:latest
container_name: appflowy
restart: unless-stopped
ports:
- "8000:8000"
environment:
- APPFLOWY_DATABASE_URL=postgres://appflowy:appflowy@postgres:5432/appflowy
- APPFLOWY_REDIS_URL=redis://redis:6379
- APPFLOWY_S3_BUCKET=appflowy
- APPFLOWY_S3_ACCESS_KEY=minioadmin
- APPFLOWY_S3_SECRET_KEY=minioadmin
- APPFLOWY_S3_ENDPOINT=http://minio:9000
depends_on:
- postgres
- redis
- minio
postgres:
image: postgres:16
container_name: appflowy-postgres
restart: unless-stopped
environment:
- POSTGRES_USER=appflowy
- POSTGRES_PASSWORD=appflowy
- POSTGRES_DB=appflowy
volumes:
- ./postgres:/var/lib/postgresql/data
redis:
image: redis:7
container_name: appflowy-redis
restart: unless-stopped
minio:
image: minio/minio:latest
container_name: appflowy-minio
restart: unless-stopped
command: server /data --console-address ":9001"
environment:
- MINIO_ROOT_USER=minioadmin
- MINIO_ROOT_PASSWORD=minioadmin
volumes:
- ./minio:/data
Affine — The Whiteboard That Ate a Document Editor
Affine is the most interesting of the five, and the hardest to categorize. It's a local-first editor built on CRDTs (conflict-free replicated data types) that treats documents and whiteboards as the same thing. You can type a paragraph, then drag a sticky note onto the page, then draw an arrow connecting them, then embed a kanban board — all in the same canvas. It's what Notion's "everything is a block" philosophy looks like when you push it to its logical conclusion.
What it gets right:
- Real-time collaboration that actually works. Because Affine is built on CRDTs from the ground up, multiplayer editing is genuinely smooth — the best of any local-first tool here. Two people can edit the same canvas simultaneously and it just works.
- The whiteboard is a killer feature. If you think in diagrams, mind maps, and spatial layouts, Affine is the only tool here that treats that as a first-class citizen rather than an afterthought.
- Clean, modern, fast. The UI is gorgeous, and it's TypeScript so it runs in the browser with no install.
What it gets wrong:
- Younger and less battle-tested. Affine is newer than AppFlowy and has had fewer years of real-world abuse. The API and data model are still stabilizing.
- The "everything is a canvas" model isn't for everyone. If you want a clean, linear document, Affine's spatial freedom can feel like a distraction. It's a tool for people who want the whiteboard, not people who just want to write.
- Self-hosting is more involved. The sync server (Affine Cloud) is a multi-container setup with its own database and object storage. Doable, but not a one-liner.
The verdict: Affine is the best choice if you want real-time collaboration and local-first data, and you're drawn to the whiteboard/canvas model. It's the most forward-looking of the five, with the caveat that "forward-looking" and "stable" are often in tension.
Docker Compose (self-hosted Affine Cloud):
services:
affine:
image: ghcr.io/toeverything/affine-graphql:stable
container_name: affine
restart: unless-stopped
ports:
- "3010:3010"
environment:
- AFFINE_SERVER_HOST=affine
- DATABASE_URL=postgres://affine:affine@postgres:5432/affine
- REDIS_SERVER_HOST=redis
- REDIS_SERVER_PORT=6379
- R2_ACCESS_KEY_ID=minioadmin
- R2_SECRET_ACCESS_KEY=minioadmin
- R2_ENDPOINT=http://minio:9000
- R2_BUCKET=affine
depends_on:
- postgres
- redis
- minio
postgres:
image: postgres:16
container_name: affine-postgres
restart: unless-stopped
environment:
- POSTGRES_USER=affine
- POSTGRES_PASSWORD=affine
- POSTGRES_DB=affine
volumes:
- ./postgres:/var/lib/postgresql/data
redis:
image: redis:7
container_name: affine-redis
restart: unless-stopped
minio:
image: minio/minio:latest
container_name: affine-minio
restart: unless-stopped
command: server /data --console-address ":9001"
environment:
- MINIO_ROOT_USER=minioadmin
- MINIO_ROOT_PASSWORD=minioadmin
volumes:
- ./minio:/data
Anytype — The Privacy-First, Offline-First Object Store
Anytype is the odd one out, and I mean that as a compliment. It's not really a "Notion alternative" in the clone sense — it's a local-first, peer-to-peer, end-to-end-encrypted object store that happens to have a Notion-like interface. Your data is encrypted on your device, synced P2P across your devices (no central server sees your content), and organized as "objects" with "types" and "relations" rather than pages and blocks.
What it gets right:
- Privacy is the product. Everything is end-to-end encrypted, and the sync is peer-to-peer. There is no server that can read your notes, because there's no server holding them in plaintext. This is the strongest privacy story of the five by a wide margin.
- Offline-first, genuinely. Anytype works fully offline, and syncs when you're back online. It's designed for people who are frequently disconnected.
- The object model is powerful. Once you grok "everything is an object with a type and relations," you can build genuinely sophisticated systems — a CRM, a recipe database, a project tracker — that would be clunky in a page-based tool.
What it gets wrong:
- The learning curve is real. Anytype's object model is powerful but not intuitive. If you're coming from Notion, expect a week of "wait, why can't I just make a page?" before it clicks.
- Collaboration is essentially absent. Anytype is a single-user tool. There's no real-time multiplayer, and sharing is limited. If you need a team wiki, this is not your tool.
- The P2P sync can be finicky. Because there's no central server, sync depends on your devices being able to reach each other (or a relay). It works, but it's more fragile than a simple server sync.
The verdict: Anytype is the best choice if privacy and offline capability are your top priorities and you're a solo user willing to invest in learning a new mental model. It's the wrong choice for teams and for people who want Notion's simplicity.
Self-hosting note: Anytype's sync is P2P by design, so there's no traditional "server" to self-host in the same way. You can run a self-hosted sync node, but the primary model is the encrypted P2P network. For most users, the "self-hosting" is really "your devices are the hosts."
Outline — The Server-Based Team Wiki That Just Works
Outline is the exception that proves the rule. It's the only server-based tool in this list, and it's the best choice if and only if you need real-time team collaboration. Outline is a beautiful, fast, Markdown-based wiki with real-time multiplayer editing, granular permissions, and a clean reading experience. It's what you'd build if you wanted a self-hosted Notion for a team of five to five hundred.
What it gets right:
- Real-time collaboration is excellent. This is the one area where server-based tools genuinely beat local-first tools, and Outline is the best example. Multiple people editing the same doc simultaneously, with presence indicators and live cursors, and it's smooth.
- Markdown-native. Everything is Markdown under the hood, which means your data is portable and your content is clean. No proprietary block format to get locked into.
- Mature and battle-tested. Outline has been around for years, has a large community, and is used by real companies in production. It's the "boring, reliable" choice.
What it gets wrong:
- You need the server up. No server, no notes. This is the fundamental server-based tradeoff, and it's non-negotiable. If your homelab goes down, your team's wiki goes down with it.
- Authentication is a hurdle. Outline requires an external auth provider (Slack, Google, OIDC, etc.) — it doesn't do its own user accounts. This is fine for teams but annoying for a solo user who just wants to log in.
- It's a wiki, not a second brain. Outline is optimized for shared, structured documentation. It's not great for personal PKM, quick capture, or the messy, freeform note-taking that Notion and Obsidian users love.
The verdict: Outline is the best choice for teams that need real-time collaboration and are comfortable running (and backing up) a server. It's the wrong choice for solo users who want offline access or a personal knowledge base.
Docker Compose:
services:
outline:
image: docker.getoutline.com/outlinewiki/outline:latest
container_name: outline
restart: unless-stopped
ports:
- "3000:3000"
environment:
- URL=https://outline.yourdomain.com
- SECRET_KEY=generate-a-long-random-string
- UTILS_SECRET=generate-another-long-random-string
- DATABASE_URL=postgres://outline:outline@postgres:5432/outline
- REDIS_URL=redis://redis:6379
- OIDC_CLIENT_ID=your-oidc-client-id
- OIDC_CLIENT_SECRET=your-oidc-client-secret
- OIDC_AUTH_URI=https://auth.yourdomain.com/authorize
- OIDC_TOKEN_URI=https://auth.yourdomain.com/token
- OIDC_USERINFO_URI=https://auth.yourdomain.com/userinfo
- OIDC_USERNAME_CLAIM=preferred_username
- OIDC_DISPLAY_NAME=Outline
- OIDC_SCOPES=openid profile email
depends_on:
- postgres
- redis
postgres:
image: postgres:16
container_name: outline-postgres
restart: unless-stopped
environment:
- POSTGRES_USER=outline
- POSTGRES_PASSWORD=outline
- POSTGRES_DB=outline
volumes:
- ./postgres:/var/lib/postgresql/data
redis:
image: redis:7
container_name: outline-redis
restart: unless-stopped
SiYuan — The Power User's Block-Level Obsidian
SiYuan is the dark horse, and it's the tool I'd recommend to the most technically-inclined readers. It's a local-first, block-level note-taking app that stores everything in a local database (with Markdown export), supports backlinks, bidirectional linking, and a plugin ecosystem — think "Obsidian, but with a proper block-level data model and a built-in sync server you can self-host."
What it gets right:
- Block-level granularity. SiYuan treats every paragraph, heading, and list item as an individually-addressable block. You can reference, embed, and transclude blocks across documents. This is more powerful than Obsidian's file-level model and closer to Notion's block model.
- Local-first with a self-hostable sync server. Your data lives in a local database, and you can run SiYuan's sync server yourself (or use their cloud). The sync is solid and the data is yours.
- Deeply extensible. SiYuan has a real plugin system, themes, and an active community of power users building on it. If you want to tinker, this is the tool.
What it gets wrong:
- Single-user only. SiYuan has no collaboration. It's a personal knowledge base, full stop. If you need to share or co-edit, look elsewhere.
- The learning curve is steep. Block-level thinking, the database model, the plugin ecosystem — SiYuan rewards investment but demands it. It's not a tool you'll be productive in on day one.
- The UI is functional, not beautiful. SiYuan prioritizes power over polish. It's not ugly, but it's not the Apple-grade design of Affine or AppFlowy.
The verdict: SiYuan is the best choice for power users who want Obsidian-level capability with a proper block model and self-hosted sync, and who don't need collaboration. It's the wrong choice for teams, for design-sensitive users, and for anyone who wants zero learning curve.
Docker Compose (self-hosted sync server):
services:
siyuan:
image: b3log/siyuan:latest
container_name: siyuan
restart: unless-stopped
ports:
- "6806:6806"
volumes:
- ./siyuan:/siyuan/workspace
command: --workspace=/siyuan/workspace --accessAuthCode=your-access-code
The Decision Matrix
Here's the whole thing in one table. Find your row, and the answer falls out.
| Your Situation | Pick This | Why |
|---|---|---|
| Solo Notion user, want the same feel, own your data | AppFlowy | Closest Notion clone, native apps, local-first |
| Want real-time collab and local-first, love whiteboards | Affine | CRDT-based, best multiplayer of the local-first tools |
| Privacy and offline are everything, solo user | Anytype | E2E encrypted, P2P sync, strongest privacy story |
| Team wiki, real-time co-editing, server is fine | Outline | Best collaboration, Markdown-native, mature |
| Power user, want Obsidian-level depth + block model | SiYuan | Block-level, extensible, self-hosted sync |
The Exit Strategy Test (The Part Everyone Skips)
Here's the question I ask about every tool before I commit years of notes to it: if this project dies tomorrow, what do I actually have?
- AppFlowy: SQLite database + Markdown export. You can get your data out, but the export is lossy — databases and relations don't survive cleanly. Grade: B-
- Affine: Markdown + JSON export, but the whiteboard/canvas data is in a proprietary format. Your text is safe; your diagrams are not. Grade: B
- Anytype: Markdown + JSON export, but the object/relation model doesn't map cleanly to flat files. You can get the content out, but the structure is lost. Grade: B-
- Outline: Markdown-native, so your data is already in a portable format. This is the best exit story of the five. Grade: A
- SiYuan: Markdown export is a first-class feature, and the block model maps reasonably well. Grade: A-
This is why I keep coming back to Markdown-native tools. The format is boring, which is exactly what you want for something you're trusting with years of your life. A tool that stores your notes in a proprietary binary format is a tool that's holding your data hostage, even if it doesn't mean to.
My Recommendation
If you've read this far and still want a single answer, here it is:
- Solo, want Notion's feel: Start with AppFlowy. It's the lowest-friction migration from Notion, and you can always export to Markdown later.
- Solo, want maximum power and don't mind a learning curve: SiYuan is the best long-term home for a serious personal knowledge base.
- Team, need real-time collaboration: Outline is the only real answer, and it's a good one. Just budget for the server maintenance.
- Privacy absolutist: Anytype is the only tool here that can honestly say "no server can read your notes."
The one thing I'd urge you not to do is keep your second brain in a rented black box because switching feels like work. The switching cost is real, but it's a one-time cost. The cost of staying is permanent: you never actually own the thing you've spent years building.
Your notes are the one dataset that's genuinely irreplaceable. Photos can be re-taken, code can be re-written, but the thought you had at 2 AM that you didn't write down is gone forever. Don't store the ones you did write down somewhere you can't get them back.