The question people argue, and the one that matters
"Obsidian or Notion?" is one of the most-argued questions in the second-brain world, and almost everyone answers it as a taste contest — dark mode versus databases, links versus kanban, which one feels nicer. That framing misses the only thing that actually decides it.
The real question isn't which tool is better. It's which layer is this tool? Every knowledge system has two: a source of truth — where your knowledge actually lives — and an interface — how you look at it, edit it, share it. They are not the same job, and the most consequential decision you make is which tool you let be the source. Get that backwards and no feature list saves you.
My own answer, and the reason for it, comes down to one line: own the source, rent the interface.
The source has to be something you own
The source of truth is the foundation everything else stands on — your AI reasons over it, your rules run against it, your future self depends on being able to read it. So the source has exactly one non-negotiable requirement: you have to own it, in a form that outlives any single tool.
Plain markdown files clear that bar completely. My vault is tens of thousands of .md files sitting on my own disk. They're readable by any text editor written in the last forty years, greppable, versionable in git, and — the part that matters most now — readable directly by any AI I choose. Claude today, something else tomorrow; the files don't care. That's the whole "rent the AI, own the structure" bet made concrete: the model is a commodity I swap at will, precisely because the source underneath it is open and mine.
This is why, as a source, an open format wins before we compare a single feature. It isn't that markdown is elegant. It's that a source you don't fully own isn't a foundation — it's a rental you've mistaken for a floor.
What "rented" actually costs — the Notion case, fairly
Notion is the reference example of the other kind, and I want to be precise and fair, because it's a genuinely good product — just at a different layer than most people use it.
In Notion, your content isn't plain files. It's block objects living in Notion's cloud, reached through an API that returns them as JSON, not documents. That design is great for what Notion is: a collaborative, real-time, database-driven workspace. But it means the source of truth is a proprietary structure on someone else's servers, and getting your knowledge back out cleanly is genuinely hard.
This isn't a hypothetical. Notion's own markdown export is structurally lossy — and not as a bug they'll patch, but because the source is richer than the target. Toggles flatten, callouts collapse into quote blocks, synced blocks duplicate, and the database layer — views, filters, rollups, formulas — is simply dropped on the way out. That's not Notion being careless; it's what happens when the interface's internal model is your source. The richness that makes it pleasant to use is exactly what refuses to leave when you do.
So the honest cost of a rented source isn't a monthly fee. It's that your knowledge is shaped to fit a vendor's model, reachable only through their door, and lossy to extract. For a workspace you'll abandon in three years, fine. For the foundation your AI and your future depend on, that's the one thing you can't afford.
Notion's real, honest place: the interface
None of this makes Notion the villain — it makes it an interface, and a strong one. Real-time collaboration, a polished out-of-the-box experience, databases and boards that a whole team can use without a manual: those are things a folder of markdown files genuinely does not do well. Obsidian is superb for the sovereign, technical solo builder and clumsy the moment you want five people editing live. Notion is the reverse. That's not a defeat for either — it's the tell that they belong on different layers.
Which is exactly how I use it. My vault is the source; Notion is a publication layer on top of it — a read-only, mobile-friendly window onto selected slices, driven one-way from the vault through a small connector. I publish to Notion; I never sync with it. The vault never reads Notion back, so there's no conflict to resolve and no corruption to fear. It's the same discipline as "one-way publishing": you don't marry two systems, you publish from one. The moment an interface starts feeding edits back into your source, rot begins.
This is a real decision I made and wrote down, not a thought experiment — Notion earns its keep as the nice front-of-house, precisely because it was never allowed to be the kitchen.
The lock-in test
If you want a single question to settle "which layer is this tool," here it is — run it against anything before you trust it with your knowledge:
Can an AI of my choosing read this directly, and can I get every byte back out without loss?
Markdown files pass on both counts: any tool reads them, nothing is trapped. A proprietary block-and-page store fails on both: the AI reaches it only through the vendor's API, and the export leaves richness behind. That's not a knock on the product's quality — a tool can be excellent and fail the lock-in test. It just tells you which layer it's allowed to be. Passes the test → it can be your source. Fails it → it's an interface you rent, and you keep the real source somewhere open.
The honest limit
Two caveats, because "own everything, rent nothing" is the wrong lesson.
First, owning the source is only worth it if you actually use it as one. A pile of markdown files you never structure, link, or query is just a rental you happen to hold the keys to — the ownership matters because of the reasoning and rules you run on it, not as a virtue in itself. Open format is necessary, not sufficient.
Second, renting interfaces is completely fine — encouraged, even. I rent the AI. I publish to Notion. I'd happily push a slice to a tool I've never heard of next year. Interfaces are supposed to be swappable and disposable; that's their job. The only rule is the one in the title: keep them on top of a source you own, and never let the convenient one quietly become the foundation.
Own the source. Rent the interface. Choose your tools by which layer they're allowed to be — and the tool wars stop being a matter of taste and start being a matter of architecture.