AFFiNE: The Local-First Knowledge Base That Wants to Replace Notion — Read the License First

"Your team's knowledge base becomes institutional memory. Institutional memory should not live on someone else's terms of service."

Notion is delightful until you try to leave. Obsidian respects your files but treats collaboration as an afterthought. Confluence works but bills per seat and ages like milk. AFFiNE (GitHub: toeverything/AFFiNE) is the open-source attempt to have all three properties at once: a workspace where structured documents and an infinite whiteboard are the same surface, where your data lives on your device first, and where you can run the entire stack on your own hardware. As of September 2026 it carries roughly 72,000 stars, is built in TypeScript with Rust for its CRDT layer, and — this is the part that needs care — uses a dual-license model that most reviews wave past. This is the honest breakdown: how the docs-plus-canvas fusion actually feels, what local-first really buys you, the self-host walkthrough, the real costs, and the licensing reality that determines whether "open source" means what you think it does here.

1. What AFFiNE Actually Is

AFFiNE describes itself as a "hyper-fused" workspace, which is marketing language for a genuinely useful idea: documents and whiteboards are the same canvas, viewed two ways. In Notion, a page is a page and a diagram is an embed. In Miro, a board is a board and text is a sticky note. In AFFiNE, you toggle between Doc mode (structured, block-based writing, like Notion) and Edgeless mode (an infinite canvas where the same content becomes freeform spatial objects). Same underlying blocks, two renderings. For knowledge work that's actually how thinking happens — you outline, you realize you need to see the structure spatially, you draw connections, then you go back to writing. AFFiNE removes the export-import round trip between those modes. On top of that sit multi-view databases (table, kanban, calendar views over the same data), real-time collaboration, and an AI assistant for summarizing, rewriting, and generating mind maps. The project started in Singapore in 2022 under TOEVERYTHING PTE. LTD. and has grown in public — issues, discussions, and releases all visible in the repository.

2. The Local-First Architecture

"Local-first" is an overloaded term, so here's what it concretely means in AFFiNE: Your workspace lives on your device first. Editing works offline. Sync is optional and additive, not a prerequisite for the app to function. The desktop application reads and writes local data; if you never configure a server, it still works completely. Under the hood this is built on CRDTs (conflict-free replicated data types) implemented in Rust — the same class of technology that powers collaborative editors like Figma. CRDTs mean two clients can edit the same document while disconnected and merge cleanly when they reconnect, without a central authority deciding whose edit wins. The consequence for users is meaningful: your data is a local artifact. Not an account. Not a tenant in someone's multi-tenant database. A thing on your disk you can copy, back up, and — in principle — inspect. The honest caveat: "in principle" is doing work in that sentence. AFFiNE's local storage format is not a folder of Markdown files the way Obsidian's vault is. You get file-level ownership, not human-readable-file ownership. If "my notes must be plain text forever" is a hard requirement, that's a genuine point against AFFiNE.

3. The License Question — Read This Part Carefully

This is the section most AFFiNE coverage skips, and it's the one that matters most for a blog about software you control. AFFiNE uses a dual-license model:

• The editor (BlockSuite), the desktop app, and most of the codebase → MIT. Genuinely permissive. Do what you like.
• The backend server (packages/backend) → AFFiNE Enterprise Edition (EE) license. Per AFFiNE's own pricing FAQ: without a commercial agreement you may review the backend source code only. Modifying, compiling, or redistributing it requires commercial authorization.

This is why GitHub's license detection reports the repository as NOASSERTION rather than MIT. What does this mean practically? If you use the desktop app locally with no server: you're running MIT-licensed code and your data never leaves your machine. Cleanest possible case. If you self-host the full stack for collaboration: you're running the EE-licensed backend. For personal and internal use this is permitted and free — but you are not running a fully open-source stack, and you can't fork and redistribute the server component. If you want to build a product on top of it or rebrand it: you need a commercial agreement. Is this unreasonable? No. It's the standard open-core bargain, the same structure GitLab, Elasticsearch, and many others have adopted, and the company needs a revenue path. But it's materially different from "AFFiNE is MIT-licensed," which is the phrase that circulates. If your definition of self-hosting includes "I can fork and modify the server," AFFiNE's backend doesn't meet it. Credit where due: AFFiNE states this plainly in its own documentation rather than burying it. The problem isn't deception — it's that enthusiastic summaries compress "MIT" and drop the qualification.

4. Self-Hosting AFFiNE: The Walkthrough

The official recommendation is Docker Compose. The minimal shape: ``bash

After fetching the official compose file from docs.affine.pro

docker compose up -d docker compose logs -f affine # watch startup ` A more explicit configuration looks like this: `yaml services: affine: image: ghcr.io/toeverything/affine-graphql:stable container_name: affine_server restart: unless-stopped ports: - "3010:3010" volumes: - ./affine-storage:/root/.affine/storage - ./affine-config:/root/.affine/config depends_on: - redis - postgres environment: - REDIS_SERVER_HOST=redis - DATABASE_URL=postgres://affine:affine@postgres:5432/affine - AFFINE_SERVER_EXTERNAL_URL=https://affine.example.com - AFFINE_SERVER_HOST=0.0.0.0 - AFFINE_SERVER_PORT=3010 - MAILER_HOST=smtp.example.com - [email protected] - MAILER_PASSWORD__FILE=/run/secrets/mailer_password postgres: image: postgres:16-alpine volumes: - ./pgdata:/var/lib/postgresql/data environment: POSTGRES_USER: affine POSTGRES_PASSWORD: affine POSTGRES_DB: affine redis: image: redis:7-alpine volumes: - ./redisdata:/data ` The details that actually matter:

• AFFINE_SERVER_EXTERNAL_URL must be exactly right, including scheme and no trailing slash. Wrong value produces a server that starts fine and then breaks invitation links, OAuth callbacks, and file uploads in confusing ways.
• Mailer configuration is required for real multi-user use — magic-link and password-reset flows depend on it. Test it before you onboard anyone.
• Storage volume is your entire knowledge base. Back it up. A named Docker volume is not a backup.
• Put it behind TLS with Traefik or Caddy. Do not expose port 3010 to the internet.
• Resource requirements are not trivial. This is a TypeScript server plus Postgres plus Redis; expect meaningful RAM use and give it room. Users on modest hardware report lag.

5. What Works Well — and What Frustrates People

Reading across user reports, a consistent picture emerges. Genuinely strong:

• The doc/whiteboard fusion. This is the differentiator and it delivers; once you've used it, going back to separate tools feels artificial.
• Local-first means offline editing just works — no spinner, no "reconnecting."
• The block-based editor is fast and pleasant for structured writing.
• Active development. Releases land regularly and the project is clearly not abandoned.
• AI features for summarizing and mind-map generation are genuinely useful when pointed at your own content.

Genuinely frustrating:

• Self-hosted sync stability is the most-reported issue. Desktop clients connecting to self-hosted servers produce intermittent sync problems more often than they should.
• Mobile is a second-class citizen, particularly for canvas work. Plan to do serious whiteboarding on desktop.
• Resource demands are high relative to a note-taking app. Older hardware will feel it.
• Export limitations, especially for complex formats like PDF, sometimes require workarounds.
• Learning curve for the dual-mode model — new users often don't discover that Edgeless mode exists.
• The plugin ecosystem is immature compared to Obsidian's, which has years of community extensions.

6. The Honest Limitations

Consolidating the caveats honestly: The backend is not open source. Covered above; the single most important qualification. Sync bugs in self-hosted deployments are real. If your use case is "one person, one machine," you sidestep this entirely. If it's "five people collaborating on a self-hosted instance," budget debugging time. You're trusting a young project with institutional memory. AFFiNE has momentum and stars, but it's a few years old. The format is not a plain-text standard you can read with cat` in twenty years. AI features may require a cloud path. The AI assistant is convenient but understand where the request goes — if you're self-hosting for privacy, check whether AI features route content to a third party, and disable them if they do. Mobile canvas editing lags. Not a dealbreaker for everyone; a real one for some. No mature plugin ecosystem. If your Obsidian workflow depends on community plugins, expect to lose them.

7. What It Actually Costs

| Item | Cost | Notes | |---|---|---| | AFFiNE self-hosted (personal/internal) | $0 | No license fee for self-hosting | | VPS (4 GB RAM minimum, 8 GB comfortable) | ~$20–40/month | Server + Postgres + Redis | | Storage | ~$3–10/month | Grows with attachments and version history | | Domain + TLS | ~$1/month or free | Let's Encrypt | | Backups | ~$2–5/month | Object storage | | Total | ~$26–56/month | For a team-sized instance | If you don't need collaboration, the desktop app alone costs nothing — no server, no VPS, no monthly bill. That's the underrated path and the one most aligned with the "own your data" thesis. Compare to the incumbents: Notion Team runs roughly $8–10 per user per month, so ten users is around $1,200/year. Confluence is similar. AFFiNE self-hosted is a fixed infrastructure cost regardless of headcount — and the paid AFFiNE tiers exist for teams who'd rather not operate it themselves.

8. Where Your Data Lives

Self-hosted AFFiNE:

• Documents, whiteboards, databases → your Postgres database and your storage volume, on your disk.
• Local-first workspaces → on your device, with sync as an opt-in.
• Credentials and session data → your Postgres and Redis, in your control.
• AI requests → check your configuration. If AI is enabled against AFFiNE Cloud, selected content leaves your machine. Disable it for a fully local posture.

What leaves your network by default:

• Telemetry, if enabled — check and disable if you want zero outbound.
• Update checks — routine version pings.
• Email, if you configure a mailer for invitations and resets.

The cleanest privacy posture: desktop app, no server, AI disabled, telemetry off. In that configuration AFFiNE is essentially a local application that happens to be open source, and your knowledge never touches a network you don't control.

9. AFFiNE vs Notion vs Obsidian vs Outline

| | AFFiNE | Notion | Obsidian | Outline | |---|---|---|---|---| | Hosting | Self-host or cloud | Cloud only | Local files | Self-host | | Storage model | DB + local-first | Vendor DB | Plain Markdown files | Postgres | | Whiteboard | Native, same canvas | Limited | Plugin | No | | Offline | Yes | Limited | Yes | No | | Collaboration | Yes | Excellent | No (sync paid) | Yes | | Plugins | Immature | Good | Excellent | No | | License | MIT editor / EE backend | Proprietary | Proprietary | Business Source | The honest summary: AFFiNE beats Notion on ownership and canvas, loses on integrations and polish. It beats Obsidian on collaboration, loses on file transparency and plugins. If your priority is "my notes are plain text forever," Obsidian still wins. If it's "docs and diagrams in one place, on my hardware," AFFiNE is the strongest open option.

10. Who Should Not Self-Host AFFiNE

• You only need personal notes on one machine. Use the desktop app and skip the server entirely. Self-hosting adds failure modes you don't need.
• Your workflow depends on a specific Obsidian plugin. Check first. Likely unavailable.
• You need a fully forkable, OSI-open stack. The EE backend disqualifies that.
• You need rock-solid multi-user sync today. The reported issues are real; evaluate before committing a team.
• Mobile-first whiteboarding is essential. Not there yet.

Migration: Getting Your Notes In (and Out)

The practical question nobody answers well: can you actually move? From Notion, use Notion's export to Markdown + CSV, then AFFiNE's import. Expect a lossy process — databases usually come across as static tables, some block types don't map, and deeply nested toggles flatten. Budget a weekend for a large workspace, and keep the Notion export archived rather than deleted. From Obsidian, the situation is better for prose and worse for metadata. Markdown files import cleanly. Dataview queries, plugins, and frontmatter-driven workflows do not — they're Obsidian-specific and will need rebuilding as AFFiNE databases. From Confluence, export to HTML or Markdown and expect meaningful cleanup. The uncomfortable truth: migration between knowledge tools is always partial. Structure that depends on a specific product's features doesn't survive the trip. Plan for "90% of content, 60% of structure, 0% of automation." Getting out deserves equal thought, and it's where AFFiNE is weaker than Obsidian. You can export to Markdown and HTML, but complex PDF export is limited and the underlying storage isn't a folder of readable files. If "I can always walk away with plain text" is a core requirement for you, test the export path with a representative document before you migrate — not after.

The AI Features: What They Do and Where Data Goes

AFFiNE ships an AI assistant for rewriting, summarizing, mind-map generation, and presentation outlines. On a good day it's genuinely useful — summarizing a long research page or turning notes into a mind map saves real time. The sovereignty question is the one that matters for this blog. Check your configuration, because the answer differs by deployment:

• AFFiNE Cloud AI — your selected content is sent to AFFiNE's AI backend. Convenient, but it means parts of your knowledge base leave your machine.
• Self-hosted with AI — depending on configuration, requests may route to a third-party model provider or to a local model endpoint you control.

If you self-host specifically for privacy, the safe default is to leave AI disabled until you've confirmed where requests go. There's no shame in that; an unconfigured AI feature costs you nothing, while a misconfigured one quietly ships your institutional memory to a vendor. The upside of self-hosting is that you get to make this choice deliberately rather than accept a default. That's the whole point.

What It's Like Day to Day

Specifications don't tell you whether a tool survives contact with actual work, so here's the texture. The thing that changes your habits is the mode toggle. You start a page as an outline, hit the switch, and suddenly the same blocks are objects on a canvas you can rearrange spatially. After a few weeks you notice you're reaching for a separate diagramming tool far less — and that's the promise delivered. The thing that wears on you, in self-hosted setups, is sync. Users report occasional desync between the desktop client and a self-hosted server: a document that doesn't reflect a change made elsewhere until a restart, or a conflict that resolves in a surprising way. It's intermittent rather than constant, and it's the single most common complaint. Running without a server avoids it entirely; running with one means accepting some friction until it's fixed. Performance is the other daily consideration. This is an Electron application with a Rust sync engine, and it behaves like one — smooth on modern hardware, sluggish on older machines with large workspaces. If your laptop is already struggling, AFFiNE will not help. Net effect: for individual, local-first knowledge work it's a genuinely pleasant daily driver. For teams on a self-hosted instance it's good with rough edges, and you should pilot it with real content before committing.

11. Getting Started Sensibly

A low-risk path: 1. Install the desktop app first. Use it locally for two weeks. No server, no commitment. 2. Decide if you actually need collaboration. Many people don't, and skipping the server removes most of the operational pain. 3. If you do need it, deploy with Compose, configure the mailer, set the external URL correctly, and put it behind TLS. 4. Verify backups on day one — do a restore test, not just a dump. An untested backup is a hope, not a backup. 5. Review AI and telemetry settings before adding real content. 6. Import incrementally. Don't migrate your entire second brain before you trust the sync.

12. The Verdict

AFFiNE is the most ambitious open-source answer to Notion, and the docs-plus-canvas fusion is not a gimmick — it changes how you move between structuring and spatializing ideas. The local-first architecture is real, the project is genuinely active, and 72,000 stars reflect substance rather than hype. But the honest assessment requires holding two things at once. The editor is MIT and excellent. The backend is enterprise-licensed, self-hosted sync has reported stability issues, mobile lags, and the plugin ecosystem is young. None of those are fatal — several are normal for a project at this stage — but together they mean AFFiNE is better suited to an individual or an adventurous small team than to a company standardizing its institutional memory today. The recommendation, then, is narrower than the hype: install the desktop app, keep your workspace local, and see whether the canvas sticks. If it does, self-hosting becomes a decision you make with evidence rather than optimism. And if licensing purity is non-negotiable for you, know exactly what you're agreeing to before you deploy the server.

Related

• Paperless NGX: The Self-Hosted Document Archive That Reads Your Paperwork So You Never Have To — the other half of a self-hosted knowledge stack: documents you didn't write.
• Meilisearch: The Open-Source Search Engine That Makes Your App Feel Instant — the search layer a growing knowledge base eventually needs.
• Traefik: The Reverse Proxy That Configures Itself While You Sleep — put your AFFiNE instance behind TLS in minutes.