Self-Hosted Notion Alternatives That Actually Encrypt Your Data (2026): A Founder's Honest Guide

In short. Most of the Notion alternatives you can self-host (AppFlowy, Outline, Docmost, AFFiNE) give you back control of the server, not encryption of the content: your documents live in plaintext in a Postgres database that anyone who controls the machine can read. "Self-hosted" and "encrypted" are two different guarantees that people mix up all the time. The only options that actually encrypt your content before it touches storage belong to a different family: Anytype, Notesnook, Standard Notes, SiYuan, Joplin (with optional or built-in end-to-end encryption), and Filarr, which encrypts every file with AES-256-GCM right on your disk, without even requiring a server. If your real goal is "nobody else reads my notes," you want encryption, not just a Docker container running at home.

The starting misunderstanding: self-hosted doesn't mean encrypted

There's a sentence I read ten times a week on r/selfhosted and in GitHub issues: "I'm looking for a Notion alternative I can host myself so my data stays private." The intention is excellent, but it rests on a mental shortcut that can cost you dearly. Hosting software yourself settles one question: whose machine the bytes live on. It doesn't settle another one at all, and for most people that other one matters far more: can whoever gets their hands on those bytes read them? In the vast majority of open source Notion clones, the answer is yes. Your pages, your databases, your tasks, your shared documents all land in a PostgreSQL database in plaintext, or close to it. The fact that this database runs on your own VPS rather than on Notion's servers changes nothing about how readable it is.

When I started building Filarr, this was exactly the trap I wanted to avoid, and it's why I spend so much time undoing this misunderstanding before comparing anything. Take a second and picture your own self-hosted server as a house. Self-hosting means owning the house instead of renting an apartment from Notion. That's good: you no longer depend on their goodwill, you can cut the power whenever you like, nobody can evict you. But if your documents are lying around in plain sight on the kitchen table, the first person who walks in reads them. A misconfigured backup that leaks, a Postgres port exposed to the internet, a stolen SSH key, an employee at your cloud host who mounts the disk, a backup stored with a third party: in every one of these cases, owning the house doesn't protect you. Encryption, on the other hand, means putting your documents in a safe that only you have the combination to. Whoever gets into the house, all they find is unreadable noise.

These two properties are orthogonal. You can have one without the other. Notion's cloud has neither self-hosting nor end-to-end encryption (it encrypts at rest with its own keys, which doesn't protect you from Notion itself, as I explain in what "is Notion encrypted?" really means). A self-hosted AppFlowy gives you self-hosting without content encryption. Notesnook's cloud gives you end-to-end encryption without self-hosting by default. Filarr running locally gives you encryption without needing to host anything at all. And a rare few tools give you both at once. The whole point of this article is to help you keep these two threads separate in your head, because 90% of "self-hosted Notion alternatives" guides happily blend them together and recommend tools that encrypt nothing while promising you privacy.

This confusion isn't harmless. It leads to decisions that are genuinely dangerous. People spin up Outline on a $5 VPS, pour therapy notes, contracts, passwords and startup ideas into it, thinking it's "private because it's on my own server," and then six months later that VPS gets owned through an unpatched CVE and everything walks out the door in plaintext. Self-hosting shifts the responsibility for security onto your shoulders without giving you the tool that makes that responsibility manageable. End-to-end encryption, by contrast, makes a good share of your carelessness harmless: even if you get hacked, the attacker walks away with unreadable blobs. That asymmetry is what should drive your choice, not the open source logo or the number of GitHub stars.

A quick history of the two families

To understand why the landscape looks the way it does, you have to go back to the origins. The first family, the self-hostable Notion clones, was born out of frustration among developers and tech teams: they wanted a nice-looking internal wiki, editable in blocks, with databases and Kanban views, without sending their product specs to an American SaaS. Outline is probably the credible elder of the bunch, designed from the start as a polished team wiki with SSO, powerful search and genuinely good collaborative ergonomics. AppFlowy arrived explicitly billing itself as the open source alternative to Notion, under the AGPL-3.0 license, with a native client written in Flutter and Rust for performance, and a sync server, AppFlowy Cloud, that teams can host themselves via Docker. AFFiNE pushed the ambition even further by merging the block editor with an infinite whiteboard-style canvas in a single space, but it is still pre-1.0 today (the stable version was around 0.26.3 in spring 2026), which means you need to pin your Docker images and test your upgrades instead of treating it as a rock-solid foundation. Docmost, finally, is the pragmatic newcomer: the simplest of the four to deploy, a single docker-compose file that brings up the app, Postgres and Redis, built for teams who want a knowledge base without spending their weekends on it.

What unites this whole family isn't just the Notion aesthetic. It's the architecture. All of them are designed as classic server applications: a backend, a relational database, real-time collaboration over websockets, object storage for attachments. That architecture is excellent for team collaboration, for full-text search, for fine-grained permissions. But it has a direct consequence that rarely gets spelled out: the server has to be able to read the content to do its job (indexing, merging concurrent edits, rendering pages). A server that reads the content is a server that stores that content in readable form. End-to-end encryption, where the server only ever sees ciphertext, is fundamentally incompatible with that model of server-side real-time collaboration. It's an architectural choice, not an oversight a patch could fix.

The second family was born from the opposite frustration, among people who put confidentiality ahead of collaboration. Standard Notes, launched in the mid-2010s, made end-to-end encryption and radical simplicity its identity, with a zero-knowledge model and one of the longest audit histories in the field; it was acquired by Proton in 2024, which anchored it in a broader privacy ecosystem. Notesnook came later and modernized the recipe: end-to-end encryption of everything, attachments included, a polished mobile app, and above all a fully open source sync server you can self-host (built on .NET 8, with MongoDB and MinIO), which gets you the premium features for free if you run your own infrastructure. SiYuan, coming out of the Chinese PKM world, exploded in popularity (more than 42,000 GitHub stars) with yet another approach: notes stored as local files, incremental end-to-end encrypted sync, and an optional Docker deployment for access from your phone over the LAN. Anytype, finally, took the logic all the way with an end-to-end encrypted peer-to-peer architecture, a sync protocol (any-sync) under the MIT license, a local-only mode, and the ability to host your own backup node.

These two families didn't end up side by side by accident: they answer two distinct fears. The first is afraid of dependency ("I don't want to be at the mercy of a SaaS"). The second is afraid of surveillance ("I don't want anyone reading my notes"). Filarr, honestly, was born from the second fear, but it refuses the usual compromise that fear imposes, namely giving up on files and a real workspace and settling for an encrypted notebook. I told that story in detail in why I built Filarr, and it fits in one sentence: I wanted a single encrypted place for my notes AND my files AND the graph connecting them, with no mandatory server, and nothing did that.

The philosophical divide, played out in a concrete scenario

Let's take a specific case to see the divide at work. You're an independent consultant. You're working with three clients in parallel: a law firm, a startup in the middle of fundraising, and a nonprofit. For each of them you keep meeting notes, PDF contracts, tracking spreadsheets, a few access passwords and drafts of sensitive recommendations. You want it private, you want to reach it from your laptop and your phone, and you don't feel like handing it to Notion. Let's look at what actually happens depending on which family you pick.

Scenario A: you set up AppFlowy Cloud or Docmost on a VPS. You spend an evening on the docker-compose file, you configure a reverse proxy and a certificate, you open the right ports. It works, it looks good, it's yours. Three months later, you leave on a two-week vacation without noticing a critical CVE in one of the dependencies. An automated scanner finds your instance, exploits the flaw and dumps your Postgres database. The result: the law firm's contracts, the startup's fundraising deck, your access passwords, all of it exfiltrated in plaintext, perfectly readable. Self-hosting gave you control and the illusion of security, but since the content was never encrypted at the application level, your only line of defense was your ops discipline, and it slipped once. Once is enough.

Scenario B: you use self-hosted Notesnook or Standard Notes. Same server, same VPS, same CVE, same database dump. Except this time, the attacker gets end-to-end encrypted blobs. Without your key, which never left your devices, they're holding noise. Forgetting to patch is still a mistake, but a mistake without catastrophic consequences. That's the whole difference between an architecture that assumes the server can be trusted and an architecture that assumes the server will be compromised someday. The right security question is never "can my server be hacked?" It's "when my server gets hacked, what will the attacker get?"

Scenario C, Filarr's, moves the cursor even further. You have no VPS at all. Your workspace lives encrypted on your laptop's disk, each file encrypted separately with AES-256-GCM. There's no server to patch, no port to close, no database to dump, because there's no exposed database. The network attack surface you were spending your evenings hardening in scenarios A and B has simply disappeared. If you want sync to your phone, you turn it on, and only then do opaque encrypted blobs leave for storage (Cloudflare R2 by default, in Cloudflare's Western Europe region, Cloudflare being a US company; or your own S3-compatible bucket if you'd rather host the storage yourself). The sync server never sees your keys in readable form or your content; that's the zero-knowledge principle I walk through in how Filarr's zero-knowledge sync works. Here's the philosophical divide in a single image: the first family protects the house, the second puts the documents in a safe, and Filarr takes the house out of the equation altogether while keeping the safe in your pocket.

What each tool is actually for

It would be dishonest to let you believe these tools are interchangeable. They aren't, because they serve different core uses, and that's often what should decide things before the encryption question even comes up. AppFlowy and AFFiNE aim to replace Notion entirely as a team workspace: block documents, databases with multiple views, Kanban, wikis, and in AFFiNE's case the whiteboard on top. If your use of Notion is mostly relational databases with table, calendar and gallery views shared across a team, these are the ones that have been covering that need seriously the longest. Outline and Docmost are narrower and own it: they're knowledge bases and team wikis, excellent for structured collaborative documentation, with permissions and search, but they don't try to replicate Notion's databases.

The second family serves something else. Standard Notes is an encrypted notebook, minimalist by philosophy, made for writing text safely, not for running team projects. Notesnook is in the same vein but richer on organization and attachments, aimed at "serious private notes, including on mobile." SiYuan is a powerful PKM (personal knowledge management) tool, much loved by people building a second brain with block references, closer to Obsidian than to a team Notion. Anytype is the most ambitious of this family: a space of encrypted, local-first objects that aims to replace Notion while staying private, at the cost of a mental model of objects and types that takes real time to get used to, as I compare in depth in the dedicated article on Anytype versus Filarr.

Filarr occupies a spot I always describe honestly so as not to mislead anyone: it isn't a universal Notion replacement for a team that lives in collaborative relational databases. It's an encrypted, local-first personal workspace that brings together three things the others keep apart: your notes, your actual files (more than 80 formats, not just note attachments), and a graph view that connects the two. It also has databases inside notes, which I'll come back to. Where Notion and its clones make you choose between "notes tool" and "file manager," Filarr starts from the idea that organizing your digital life means precisely mixing the two, which I develop in organizing your whole digital life in one private workspace. If your real need is "a calm, private, encrypted place for my documents, my project notes and my ideas, on my own disk, with optional sync to my phone," that's exactly the niche. If your need is a database shared in real time with fifteen colleagues, with a company wiki around it, AppFlowy or Outline will serve you better, and I'm telling you that straight.

Encryption in depth, and what it really protects

Let's get into the hard part, because this is where the sorting happens. Encryption isn't a marketing checkbox; it's a chain of technical decisions where every link matters. Let's start with the cipher itself. Filarr encrypts every file with AES-256-GCM, an authenticated encryption mode that guarantees both confidentiality (nobody reads the content) and integrity (nobody modifies the content without it being detected), the same mode used by TLS and 1Password, which I explain in detail in what AES-256-GCM is. But the cipher is only half the story. What separates a serious architecture from sloppy encryption is the key hierarchy. Filarr uses a single random 256-bit key for your account (the FEK, File Encryption Key). Every file and every note is encrypted under that key, with a fresh random IV (initialization vector) for each one, so two identical files never produce the same ciphertext. The FEK itself is wrapped by a key (the KEK, Key Encryption Key) derived from your password. In practice, the key that encrypts your data is random rather than derived from your password, your password only unlocks it, and changing your password rewraps the FEK without re-encrypting a single file. The flip side, which I'd rather state plainly: the FEK opens the whole account, which is why the strength of your password and the safekeeping of your recovery phrase matter so much. That's the KEK/FEK principle I took apart in the KEK and FEK key hierarchy explained.

Key derivation is the next link, and it's often where things fall apart elsewhere. A human password isn't a cryptographic key: it has to be transformed, slowly and expensively, to resist brute force. Filarr derives the KEK with PBKDF2-SHA512 at 600,000 iterations, above the current OWASP guidance for that function. That deliberate slowness is a feature: it makes every attempt to guess the password expensive for the attacker. A tool that encrypts with shiny new AES-256 but derives the key with a simple fast hash has an armored door hanging on cardboard hinges.

Now let's put these choices to the test against four concrete threat models, because "it's encrypted" means nothing out of context. First model: the malicious or compromised server. With AppFlowy, Outline, Docmost and AFFiNE self-hosted, the server sees and stores your content in plaintext: if it's compromised, or if the admin is curious, or if the host mounts the disk, everything leaks. With Notesnook, Standard Notes and Anytype, the server only sees ciphertext, so a malicious server gets nothing usable. With Filarr, in pure local mode, there's no server at all, and in sync mode the server only stores opaque blobs and your key locked by your password and by your recovery phrase. Two known limits remain, and I'd rather name them. The first is transitional: since October 16, 2026, signing in sends a key derived on your device, not your password; the password is only sent during the transition, by an older version of the app or at the first sign-in after that date of an account created before it, and in that case a compromised server could capture it. The second: your 24-word recovery phrase is generated by our server and sent to you over HTTPS, and the server receives it again when you use it; it keeps only a hash of it. A stolen copy of the database, on the other hand, opens nothing without your password or your phrase. On this model, the divide between the two families is total.

Second model: the stolen laptop. It's the most common and the most underestimated. With SiYuan and Joplin, your notes sit unencrypted on disk by default (end-to-end encryption only applies to sync, not to local storage at rest): a thief who gets your unencrypted laptop reads everything, unless you've encrypted your disk at the OS level. With Filarr, your files are encrypted at rest by default, independently of any full-disk encryption: the thief finds encrypted files and a local key sealed by your operating system's secure storage for your user account. That protection doesn't cover a session that's already open, so lock Filarr when you step away; on a shared computer, turn on Enhanced lock, and Filarr deletes the local key when it closes and asks for your password at every launch. It's a difference in default posture, and defaults govern the real security of real people, because almost nobody manually turns on a security option.

Third model: the weak password. No encryption saves a password like "qwerty123," but good key derivation makes the difference between "cracked in a second" and "cracked after weeks of computation." Filarr's 600,000 PBKDF2 iterations buy time and make brute force expensive; the same goes for Standard Notes and Notesnook, which take derivation seriously. On the other side, the Postgres clones don't even have this debate, since their content isn't derived from a user password at all. Fourth model: a legal request from a judicial authority. If a court orders the host to provide your data, on a self-hosted Outline at a cloud provider, the provider can deliver a readable disk. On a zero-knowledge architecture (Notesnook, Standard Notes, Filarr with sync), the provider can only provide ciphertext, because it only holds your key in locked form; in Filarr's case, that's encrypted data, the locked copy of your key, and account metadata such as your email address. What it stores stays unreadable even under legal compulsion, which is precisely the point of zero-knowledge that I contrast with end-to-end in end-to-end vs zero-knowledge.

Sync architecture and multiple devices

The way a tool syncs reveals its whole philosophy, and this is where the trade-offs become tangible. Notion clones sync through a central server that is the source of truth: your client talks to the server, the server merges concurrent edits server-side (because it reads the content), and redistributes them. Offline, you're often very limited, or even stuck, because the intelligence lives on the server. If the server goes down, your team is blocked. If you cancel or shut down the instance, you have to export first, or you lose access. It's efficient for real-time collaboration, but it makes the server a single point of failure and a mandatory custodian of your plaintext content.

End-to-end encrypted tools flip this model. The client is the source of truth, and the server is just a relay for encrypted blobs. Notesnook and Standard Notes work perfectly offline and catch up on sync when the connection returns, because encryption and decryption happen on the device. Anytype goes further with peer-to-peer: your devices can sync directly over the local network without a central node, and the backup node is a convenience, not a dependency. SiYuan encrypts its incremental sync end to end to minimize bandwidth. In all these cases, a server outage doesn't break your local access: you keep working, and sync catches up later.

Filarr is firmly in this second camp, with a nuance that matters: it's local-first in the strong sense, which means the desktop app works 100% offline, with no account, no network, indefinitely, and cloud sync "just follows." That's not a vocabulary detail; it's an architectural guarantee I go into in what local-first software is. When you turn on sync, each file is encrypted locally under your FEK with its own fresh IV, the FEK is wrapped, and only the encrypted blobs plus an encrypted manifest leave for R2 (or for your own S3 bucket with BYOS). The server never sees your keys in readable form or your content, nor the names of your files and folders; it just stores and serves opaque blobs and relays the key exchange between your devices when you pair them, via ECDH. If Filarr's server goes down tomorrow, or if you stop paying for sync, your files stay right there, encrypted, on your disk, perfectly usable: you lose sync, not your data. That's a property neither Notion nor its server-centric clones can offer, because for them the server isn't optional, it is the product.

Recovery and losing access

Encryption done right has a downside you need to look squarely at: if you lose your key, nobody can recover it for you, because "nobody can recover it" is precisely the property you paid for. That's the price of zero-knowledge, and it's a real price. With Notion and unencrypted self-hosted clones, a forgotten password is fixed with a simple reset email, because the server can decrypt again or reassign access: convenient, but it's also proof that the server had the power to read your data all along. That convenience is the symptom of the problem.

On the encrypted side, recovery becomes a real design question. Standard Notes and Notesnook rely on your password as the root: forget it without a backup, and your notes are unrecoverable, full stop. Some offer recovery keys or codes to keep somewhere safe. Anytype gives you a recovery phrase you have to store securely, without which a lost device means lost access. Filarr follows the same logic of responsibility, with a standardized safeguard: a 24-word recovery phrase in BIP-39 format, the same proven standard cryptocurrency wallets use, which lets you get your master key back if you forget your password, as long as you've kept those 24 words offline (a local profile without an account gets its own 12-word phrase, which never leaves your device). Filarr can't reset an account's password by email, by design: that reset would leave your files locked under the old password. It's a deliberate trade-off: more security against third parties, more responsibility on your shoulders. I always recommend treating this phrase like the spare set of your house keys, printed and physically stored away, because that's literally what it is.

There's a scenario few people anticipate and that deserves to be laid out: the death of the account holder, you or someone close to you. On an end-to-end encrypted architecture, your heirs can access nothing without your password or your recovery phrase, which protects against the curious but creates a problem of passing things on. The good practice, with Filarr as with Notesnook or Anytype, is to treat your recovery phrase as an asset to pass on deliberately (a digital will, a safe, a trusted person), exactly as you would for a bank safe-deposit box. Unencrypted clones don't have this problem, but only because they lack the protection that creates it. It always comes back to the same trade-off: easy recovery and confidentiality pull in opposite directions, and honestly, I'd rather have a tool that clearly chooses confidentiality and gives you a robust safety net than a tool that keeps a spare set of your keys for your convenience.

The comparison in one table

The table below sums up the axes that really matter. Read it with the nuance of the previous sections in mind, because a table inevitably flattens complex realities: "encrypted at rest by default" doesn't mean the same depth everywhere, and "self-hostable" hides very different ops efforts.

Tool	Self-hostable	Encrypts content (E2EE/zero-knowledge)	Encrypted at rest by default	Files + notes	License	Entry price
AppFlowy	Yes (Docker)	No (readable Postgres)	No	Notes + databases	AGPL-3.0	Free self-hosted / Cloud from $10/user/month
AFFiNE	Yes (pre-1.0)	No	No	Notes + canvas	See repo	Free self-hosted
Outline	Yes (Postgres + Redis + S3)	No	No	Notes/wiki	BSL, converting later	Free self-hosted
Docmost	Yes (the simplest)	No	No	Notes/wiki	AGPL-style	Free self-hosted
Anytype	Yes (backup node)	Yes (E2EE, P2P)	Yes	Objects + files	any-sync MIT / source-available client	Free
Notesnook	Yes (FOSS sync server)	Yes (zero-knowledge)	Yes	Notes + attachments	AGPL / open source	Free self-hosted / Cloud ~$4.50/month
Standard Notes	Yes	Yes (zero-knowledge)	Yes	Notes (few files)	Open source	Free (plain-text editor) / paid plans for more
SiYuan	Yes (Docker/LAN)	E2EE sync	No (plain local files)	Notes/PKM	See repo	Free
Filarr	BYOS S3 storage (Pro plan)	Yes (zero-knowledge)	Yes (AES-256-GCM, fresh IV per file)	Notes + files + databases + graph	Desktop client BSL 1.1 (source available); server not public	Free locally, 5 GB of sync included / from €4/month

What the table shows at a glance is the fault line: the "encrypts content" column cleanly separates the two families, and it doesn't line up with the "self-hostable" column. You can self-host a tool that encrypts nothing (AppFlowy, Outline) just as well as a tool that encrypts everything (Notesnook, Anytype). The other lesson is in the "files + notes" column: very few tools treat actual files as first-class citizens rather than attachments. That's where Filarr and Anytype stand apart from the rest, and it's often the deciding criterion for anyone who truly wants a unified workspace rather than a notebook.

Where the competitors really win

I'm not going to sell you a world where Filarr ticks every box, because a comparison where my product wins everywhere would rightly be suspicious. Let's start with what the first family does better, honestly. For real-time team collaboration at scale, AppFlowy, Outline and AFFiNE are in another league. If you have fifteen people editing the same roadmap database at the same time, with per-page permissions, comments, mentions and a shared history, those tools were designed for that from end to end. Filarr does have live co-editing: in a shared vault, several members can write in the same note at the same time and see each other's changes as they type, with comments, mentions and tasks, while the relay only sees who is connected, not what the note says. But it's recent, the personal plans cap a shared space at a few people (3 on Solo, 6 on Pro, more through the Teams plan), and doing it end-to-end encrypted is structurally harder, because, as I explained, the devices have to merge the edits instead of a server that reads everything. If dense collaboration across a large team is the core of your work, don't kid yourself: the first family will serve you better.

Relational databases are the second area where the Notion clones have a head start. Multiple views (table, Kanban, calendar, gallery, timeline), relations between databases, rollups, formulas: that's Notion's DNA, and AppFlowy replicates it seriously. Filarr now covers part of this ground: a note can hold a database with typed columns, relations, rollups and formulas, and table, board, calendar, gallery, timeline, chart and form views, all encrypted along with the note. But it's young, and if your life runs on large interconnected databases shared with a team, the years AppFlowy has spent on exactly that remain the safer bet today.

Within the encrypted family itself, there are also areas where others are ahead of Filarr, and it's important to say so. Standard Notes has a much longer history of independent security audits, now backed by Proton: if audited maturity and long-standing reputation are your number one criterion, that's a real argument in its favor. Notesnook has a mature, proven mobile app today, whereas Filarr's mobile app is brand new: the Android app has been on Google Play since October 2026, and there's no iPhone app. SiYuan has a massive community and a very rich PKM ecosystem, with advanced block referencing that Filarr doesn't claim to match. Anytype offers a model of typed objects and peer-to-peer sync with no central server, which will appeal to people who want zero third-party infrastructure, even optional. And all of these tools, being older or more widely adopted, have a larger community than Filarr, which is still a young project from 2026. If you want the most tutorials, user stories and community plugins right now, the established competitors have time on their side.

Where Filarr really wins

That said, there are things Filarr does better than anyone in this landscape, and I'll be as direct about my strengths as I've been about my weaknesses. The first is true unification of notes and files. Nearly every tool mentioned here forces you into a mold: either it's a notes app that tolerates attachments (Notesnook, Standard Notes), or it's a team wiki (Outline, Docmost). Filarr treats your files, in more than 80 formats, as first-rank objects, on the same level as your notes, connected in the same graph view. When you run a real project, you don't just have text: you have PDFs, images, spreadsheets, archives. Filarr lets you file them, link them and find them again in the same encrypted space, which I expand on in stop losing your files. No encrypted notebook does this as naturally.

The second strength is encryption at rest by default, without you having to turn anything on. It's a point I never let go of, because it's decisive: with SiYuan and Joplin, your notes live unencrypted on disk and encryption only covers sync; with Filarr, every file is encrypted with AES-256-GCM on disk from the start, under your account key, with a fresh IV for each one. The default is the secure one, not the option. And since people's real security is governed by defaults, not by the boxes they forget to tick, that's what actually protects a normal user against the most mundane laptop theft.

The third strength is local-first without the ops compromise. Self-hostable encrypted tools like Notesnook require you to set up and maintain a server to get sync; the Notion clones require it just to work at all. Filarr works 100% locally, with no account, no server, for free and forever, and only adds sync if you want it, end-to-end encrypted, with the BYOS option to host the S3 storage yourself if that's your thing. You get ownership without the system administration chores, which is exactly what most people who say "I want to self-host" really want deep down: control and privacy, not a second job as a sysadmin. The fourth strength, a quieter one, is the KEK/FEK key hierarchy: a random account key that's never derived from your password, wrapped by a key that is, with the exact parameters published on the security page rather than summed up as "military-grade encryption." I detailed the whole defensive posture in Filarr's security, layer by layer.

Migrating for real, with the real friction

Moving from Notion to a local-first encrypted tool isn't magic, and I'll tell you the truth about the friction rather than sell you a miracle button. From Notion, the standard path is export: Notion gives you your pages as Markdown and your databases as CSV, plus the attached files. The good news is that Markdown is an open format that every tool in the encrypted family (Filarr included) can import without locking you into a vendor. The bad news is that Notion's relational databases, with their relations, rollups and formulas, don't survive a CSV export: you get flat tables and lose the relational logic. If your use of Notion leaned heavily on those databases, no migration to an encrypted tool will be painless. I say so plainly in my guide to migrating from Notion to an encrypted app.

For Filarr specifically, the cleanest path is to export your Notion workspace in the Markdown & CSV format, sub-pages included, and import the ZIP with the desktop app's import wizard, where every note and every file gets encrypted on the way in. Your pages become notes, your Notion databases become databases inside those notes (Filarr guesses each column's type, so check them), and your attachments become real first-class files. The honest friction is the manual work of rebuilding the relations, rollups and formulas the CSV flattened, and of reconnecting things in the graph view. Plenty of people discover while migrating that they weren't really using Notion's relational power and that a space of linked files and notes is more than enough, but if that's not your case, better to know before you move.

Migrating between encrypted tools (from Standard Notes or Joplin to Filarr, say, or the other way around) is generally simpler on the format side, since Markdown is the common denominator, but be careful: you decrypt on one side to re-encrypt on the other, so do it on a trusted machine and properly destroy the intermediate plaintext exports, which are the weak link in the process. A plaintext export lying around in your Downloads folder cancels out the whole benefit of encryption in both apps. The golden rule of any migration between encrypted tools is that the intermediate file is the moment of maximum vulnerability, and it has to be treated as such.

The price, broken down with real numbers

Let's talk money concretely, because "free self-hosted" often hides a real cost. Take three scenarios. Scenario 1: the student or individual who just wants private notes and files on their laptop and phone. With a self-hosted clone, they pay for a VPS (€5 to €10 a month depending on resources), plus setup and maintenance time, plus the mental load of security updates. With Filarr, they pay nothing locally, forever, nothing for sync to their phone either as long as 5 GB is enough, then €4 a month for 25 GB. For this profile, Filarr is both cheaper and infinitely less work, because there's no server to maintain. Notesnook's cloud at about $4.50 a month is in the same ballpark for encrypted notes, but without first-class files or the graph.

Scenario 2: the independent consultant from our opening example, three clients, needing reliable sync and serious security, but with no appetite for ops. The self-hosting math turns unfavorable: a decent VPS plus backups plus the time spent (billable time, at that) costs far more than €4 a month, and above all the security responsibility rests entirely on them, with the scenario A risk we saw earlier. Filarr at €4 a month gives them encrypted sync with no infrastructure, and if they really insist on hosting their own storage, BYOS S3, included in the Pro plan (€8 a month), lets them point to their own bucket without having to manage a full application server. The total cost of ownership, time included, leans clearly toward the managed encrypted solution.

Scenario 3: the team of ten that lives in collaborative databases. Here the math honestly flips. A self-hosted AppFlowy on a shared VPS can end up cheaper than a per-seat subscription past a certain number of users, and above all it offers the mature real-time collaboration the team needs. For this profile, the encrypted family isn't the obvious choice, Filarr included: its Teams plan (€11 per seat per month, three seats minimum) brings shared vaults with live editing, but if the team lives in dense collaborative databases, the real trade-off today is between self-hosted AppFlowy and Notion's cloud, depending on your tolerance for ops. I'm telling you this because it's true: price is never read in the absolute, it's read in your usage scenario, and mine isn't universal. For a full overview of current pricing by use case, I keep a list in the best local-first apps in 2026.

Open source and licensing, and what it changes for you

Licensing is often treated as a badge, when it has concrete consequences. AppFlowy is under AGPL-3.0, a strong copyleft license that guarantees the code stays open but imposes constraints if you want to redistribute a modified version as a service. Anytype has a hybrid structure I think is important to distinguish: the any-sync sync protocol is MIT, genuinely open source and auditable, while the client code is under a "source-available" license (the Any Source Available License) that lets you inspect the code and check for backdoors, but isn't open source in the strict OSI sense. Notesnook is plainly open source, sync server included, which is a real trust asset. Outline has a licensing history that went through the BSL. These nuances matter because they determine what you can actually verify, fork and self-host.

Filarr makes a choice I want to present without any blur, because I hate it when people keep the confusion going on this topic. The code of Filarr's desktop client is public under the Business Source License 1.1 (BSL 1.1), on GitHub: you can read it, audit it, and check exactly how local encryption is implemented, which is the only thing that makes an encryption promise credible. BSL 1.1 is a "source-available with a switchover" license: it restricts certain competing commercial uses for a period, then the code converts to a classic open source license, Apache 2.0, on April 19, 2030. I explained this choice in detail, what it allows and what remains closed, in Filarr publishes its code: why BSL 1.1. An important point not to mix up: only the desktop client is public. Filarr's server, its cloud sync modules and Filarr Send's cryptography are not. That distinction is real, and I'd rather you know it than read a misleading shortcut somewhere else.

What it changes for you, concretely: with Filarr, you can check the local encryption code yourself or have it audited, which is the guarantee that counts when an app promises you encryption, because closed-source encryption asks you to take it on faith. What you can't do, on the other hand, is build a competing commercial service on this code during the BSL window. For the overwhelming majority of users who simply want an encrypted tool whose promises they can check, BSL 1.1 delivers the essential part: transparency of the code. If your requirement is hardline OSI open source for ideological reasons, Notesnook or AppFlowy will meet that specific criterion better, and that's a legitimate trade-off I respect.

Four profiles, four recommendations

Enough generalities; let's ground this in concrete personas. First profile: you're a developer or a privacy-minded knowledge worker, you use Notion or Obsidian today, you want real encryption and ownership of your data without becoming a sysadmin. Choose Filarr. That's exactly the niche: AES-256-GCM encryption of every file at rest, notes plus files plus graph in a single space, free locally, optional sync included up to 5 GB, then from €4. You get the confidentiality you're after without the weekend of ops that self-hosting a clone would impose, and without the "notes only" compromise of encrypted notebooks.

Second profile: you're a purist about audited security and long reputation, you want encrypted notes with the longest possible audit history, and a mature mobile app is non-negotiable right now. Take a serious look at Standard Notes (backed by Proton) or Notesnook. They do less than Filarr on files and the graph, but their maturity and audits are a real argument if that's your dominant criterion, their mobile apps are proven today, and Filarr has no iPhone app. I'd rather point you to them honestly on that specific criterion than hold you back.

Third profile: you run a team that lives in collaborative databases and real-time editing, and confidentiality comes after collective productivity. Don't force yourself into an encrypted tool that will frustrate you. A self-hosted AppFlowy or Outline will serve you better, as long as you accept that the content lives in plaintext in your database and that your security rests on your ops discipline. At the very least, encrypt your server's disk and lock down network access. It's not the privacy-maximalist choice, but it's the right functional choice for your use, and denying that would be dishonest.

Fourth profile: you refuse any third-party infrastructure, even optional, and you want pure peer-to-peer. Anytype is probably made for you, with its P2P sync and self-hostable backup node, provided you accept its model of typed objects and its source-available client license rather than strict open source. If you want the same control but with real first-class files and encryption at rest by default that's simpler to reason about, compare it calmly with Filarr before you decide, because the choice will come down to the mental model (objects versus files) more than to raw security.

Conclusion: choose based on the guarantee you actually want

If you remember only one thing, let it be this: stop looking for "a self-hosted Notion alternative" and start looking for "the guarantee I actually need." If your real fear is dependency on a SaaS and you want team collaboration, self-host AppFlowy or Outline with your eyes open, knowing that your content lives in plaintext and that your security rests on your ops. If your real fear is someone reading your notes, then self-hosting alone won't save you, and you need end-to-end encryption: Notesnook, Standard Notes and Anytype are excellent choices depending on whether you favor maturity, simplicity or peer-to-peer.

And if you want encryption without the burden of hosting anything, with your files and your notes brought together on top of that in a single space encrypted at rest by default, that's precisely the gap Filarr was built to fill. Not a universal Notion replacement, I'll never sell it to you that way, but the encrypted local-first option for anyone who wants to organize their private digital life without entrusting their data to anyone and without becoming a system administrator. Self-hosting was always a means, never an end. The end was control and confidentiality. Local-first encryption gives you both, without the server. You can start for free, locally, today, and add sync only on the day you want it.

FAQ

Does self-hosting a Notion alternative automatically encrypt my data? No, and that's the core misunderstanding. Self-hosting moves your data onto your server, but in most Notion clones (AppFlowy, Outline, Docmost, AFFiNE) the content is still stored in plaintext in a PostgreSQL database. Anyone who controls the server, or compromises it, can read it. Content encryption is a separate property you have to check explicitly.

Which Notion alternatives actually encrypt the content? The ones that do end-to-end or zero-knowledge encryption: Notesnook, Standard Notes, Anytype, and for sync, SiYuan and Joplin. Filarr encrypts every file with AES-256-GCM right at rest on your disk, without requiring a server. In all these cases, the content is encrypted before it touches storage.

Is Filarr self-hostable like AppFlowy or Notesnook? Filarr is local-first above all: it works 100% offline on your disk, with no server, for free. So you don't need to self-host anything to get privacy. If you want sync and want to host the storage yourself, the BYOS option (Pro plan) lets you point to your own S3-compatible bucket, without having to maintain a full application server.

What happens if I forget my Filarr password? As with any zero-knowledge architecture, nobody can recover your key for you; that's the price of confidentiality. Filarr gives you a 24-word recovery phrase in BIP-39 format: keep it offline somewhere safe, and it lets you get your master key back. Without it and without your password, your data is unrecoverable.

Is a self-hosted clone's encryption at rest (the VPS disk encryption) enough? Not really. Disk encryption at the server level protects you if someone physically steals the powered-off disk, but as soon as the server is running, the database is decrypted and readable by the application, the admin, or an attacker who compromises the running machine. Client-side end-to-end encryption protects you even while the server is running, and even if it's compromised.

Can my team collaborate in real time with an encrypted tool? Yes, but it's harder to build, so it's rarer and younger. Real-time collaboration the way Notion clones do it requires the server to read and merge the content, which is incompatible with end-to-end encryption, where the server only sees ciphertext. An encrypted tool has to merge the edits on the devices instead, with the server relaying encrypted changes. Filarr's shared vaults work this way: several members can edit a note live, and the relay sees who is connected, not what the note says. If dense simultaneous editing across a large team is your core need, the first family (AppFlowy, Outline) is more mature; if confidentiality comes first, you choose the second.

Does Filarr completely replace Notion? Not for every team, and I say so frankly. Filarr has databases inside notes (relations, rollups, formulas, several views) and live co-editing in shared vaults, but it isn't built as a company-wide wiki for dozens of people, and those features are younger than Notion's. It excels as an encrypted personal workspace that brings together notes, real files and a graph view. If your life runs on Notion databases shared across a large team, a self-hosted clone will suit you better; if you want an encrypted private space for your documents and ideas, that's Filarr's niche.

How does Filarr's license differ from the others? The code of Filarr's desktop client is public under the Business Source License 1.1 (source available, not open source in the OSI sense before it converts to Apache 2.0 on April 19, 2030), which lets you audit its local encryption code; the server, the cloud modules and Filarr Send's cryptography are not public. Notesnook and AppFlowy are strict OSI open source, and Anytype has a source-available client and an MIT protocol. For most people, what counts is being able to check the encryption promises, which BSL 1.1 allows.