Obsidian for Developers: Why I Chose It Over Notion and Never Looked Back

I once heard a developer say he lost thousands of notes overnight — not from a crash, but from a pricing change. The SaaS note app he’d been using for years moved his tier behind a paywall. He exported everything as HTML, but proprietary formatting doesn’t travel well. Half his notes were garbled. Internal links? Gone.

That story stuck with me. It crystallized something I’d been feeling for a while: the note app I depend on every day should follow the same rules I apply to production systems. Open formats. No vendor lock-in. Full control.

That’s why I use Obsidian. My notes are plain Markdown files in a local folder. I can grep them. I can git log them. I can pipe CLI output straight into my daily note from the terminal. And if Obsidian disappears tomorrow, my notes are still just .md files I can open in any text editor on earth.

Here’s what most “Obsidian vs Notion” articles get wrong: they compare features. But Obsidian for developers isn’t about features. It’s about architecture. It wins because it respects the same engineering principles I apply to every production system I build.

Why Markdown Files Are a Developer’s Best Data Format

When I pick a database for a project, I think about data format, portability, query capability, and backup strategy. At some point I realized I should think about my notes the same way.

Obsidian stores everything as plain .md files with YAML frontmatter in a local directory. That single design decision changes everything.

Here’s what this looks like in practice:

# Search across your entire vault in milliseconds
grep -r "MQTT" ~/ObsidianVault/ --include="*.md" -l

# Count notes by topic using frontmatter tags
grep -r "tags:.*swift" ~/ObsidianVault/ --include="*.md" | wc -l

# Version control your entire knowledge base
cd ~/ObsidianVault && git add -A && git commit -m "daily sync"

Criteria	Obsidian	Notion	Apple Notes
Data format	Plain Markdown (.md)	Proprietary (API export)	SQLite (locked)
Version control	Native Git integration	Not possible	Not possible
Offline access	Full (local-first)	Partial (caching)	Full (but locked format)
CLI access	Official CLI (v1.12+)	API only (rate-limited)	None
Portability	Copy the folder, done	Export required	Export breaks formatting
Vendor lock-in	Zero	High	Very high

Your notes are just files. Files you own. Files you can script against, version control, and move to any Markdown editor whenever you want.

The CLI That Changed Everything (Obsidian 1.12)

In February 2026, Obsidian shipped version 1.12 with a built-in command-line interface. This is the feature that turned Obsidian from “a good note app” into genuine developer infrastructure.

The CLI isn’t a separate download — it’s a remote control for the running Obsidian instance. Every operation goes through Obsidian’s internal API, which means file moves automatically update wikilinks and the search index stays intact. No more broken links from shell mv commands.

To set it up:

# In Obsidian: Settings → General → Command line interface → Enable → Register CLI
# Verify
obsidian version

Here’s my actual morning routine script:

#!/bin/bash
# morning.sh — runs via cron at 7:30 AM

# Open today's daily note
obsidian daily

# Add standing tasks
obsidian daily:append content="- [ ] Review PRs"
obsidian daily:append content="- [ ] Check CI/CD pipeline"
obsidian daily:append content="- [ ] Write TIL note"

# Check for orphaned notes (notes with no links)
obsidian orphans

Pro tip: Pipe the output of other tools directly into your vault:

# Save AWS cost report as a note
aws ce get-cost-and-usage --time-period Start=2026-03-01,End=2026-03-09 \
  --granularity MONTHLY --metrics BlendedCost \
  | obsidian create name="AWS-Cost-March-2026" content=-

The CLI also ships with a TUI (Terminal User Interface) — run obsidian with no arguments and you get a full-screen, keyboard-driven file browser for your vault. It even has autocomplete. For developers who live in the terminal, this feels like home.

Bases: The Feature That Killed My Last Reason to Use Notion

The one thing Notion had over Obsidian was databases. Tables with filters, sorts, formulas, and multiple views. Then Obsidian shipped Bases in v1.9 (August 2025), and that gap closed fast.

Bases let you turn any set of notes into a queryable database using YAML frontmatter as your schema. All data stays in your local Markdown files — the .base file just defines the view.

# Example frontmatter for a project note
---
title: "SwiftUI Widget Redesign"
status: "in-progress"
priority: "high"
due: 2026-03-15
tags: [ios, swiftui, ios26]
---

With Bases, I create a table view filtered to status: "in-progress", sorted by due, with formula columns that calculate days remaining. I can switch between table and card views without touching the underlying files.

The critical difference from Notion databases: everything is still plain Markdown + YAML underneath. My Dataview queries still work. My grep commands still work. The data isn’t trapped anywhere.

⚠️ Watch out: Bases is still maturing. The plugin API shipped in v1.10 (October 2025), and more view types are on the roadmap. It doesn’t fully replace Dataview for complex JavaScript-driven queries yet. I use both, and they coexist well.

Here’s What Most People Miss About Obsidian

Let me reframe the whole conversation.

Choosing a note-taking tool is an architectural decision — the same kind you make when you pick a database, a deployment strategy, or a programming language. The criteria should be identical.

Open format? Markdown is to notes what JSON is to data exchange — universally readable, endlessly portable.

Version controllable? I git commit my vault daily. I can git diff to see what I learned this week. I can git blame a note to trace when I first wrote down a particular idea. Good luck doing that with Notion.

Scriptable? With the v1.12 CLI, I automate vault maintenance, generate reports from frontmatter, and pipe output from any developer tool into my notes.

Zero vendor lock-in? If Obsidian shuts down tomorrow, I have a folder of .md files. If Notion shuts down, I have an export button and hope.

Extensible? Over 2,700 community plugins make Obsidian closer to VS Code’s ecosystem than to any note-taking app. Excalidraw alone has 5.5M+ downloads.

The real comparison isn’t “Obsidian vs Notion.” It’s more like comparing SQLite to a Google Sheet. They serve different architectural philosophies. One gives you a polished UI on someone else’s infrastructure. The other gives you raw, scriptable, versionable control over your own data.

When you think about it this way, the choice becomes obvious — at least for developers who care about owning their tools.

My Actual Obsidian Setup (The Practical Part)

I’ve been refining my vault structure for a year. Here’s where I landed:

~/ObsidianVault/
├── 00-Inbox/          # Quick capture, unsorted
├── 10-Projects/       # Active projects (SwiftUI app, blog posts)
├── 20-Areas/          # Ongoing responsibilities (iOS dev, AWS, blog)
├── 30-Resources/      # Reference material (Swift snippets, CLI commands)
├── 40-Archive/        # Completed projects
├── Daily/             # Daily notes (YYYY-MM-DD.md)
├── Templates/         # Note templates
└── .obsidian/         # Config, plugins, themes

Plugins I actually use every day:

• Templater — Dynamic templates with JavaScript execution. My daily note template auto-fills the date, links to yesterday’s note, and pulls in standing tasks.
• Dataview — SQL-like queries across your vault. TABLE status, due FROM "10-Projects" WHERE status != "done" SORT due ASC gives me a live project dashboard.
• Git — Auto-commit every 30 minutes. Every change is tracked, and I can roll back any note to any point in time.
• Excalidraw — Whiteboard-style drawings embedded directly in notes. Perfect for architecture diagrams before I write a single line of code.

Pro tip: For cross-device sync, I use iCloud Drive (free). My vault lives in ~/Library/Mobile Documents/ and syncs to my iPhone automatically. The iOS app (v1.12) now has a Share extension — I can save content from Safari straight into my vault without even opening Obsidian.

What Doesn’t Work (An Honest Take)

I’d be dishonest if I said Obsidian was perfect. Here’s where it falls short:

The learning curve is real. My first week was spent tweaking plugins instead of writing notes. Productive procrastination is a genuine trap with Obsidian. My advice: start with zero plugins. Just write Markdown. Add plugins only when you hit a specific pain point.

Real-time collaboration is limited. Obsidian Sync now supports shared vaults, but it’s not as fluid as Notion or Google Docs for team editing. For solo developers and pairs, it works fine. For a 20-person team, stick with Notion.

Mobile is “good enough,” not great. The iOS app has improved a lot in 2026 (faster startup, customizable toolbar, better plugin support), but heavy editing still feels better on desktop.

Bases isn’t Notion databases — yet. If you depend on Notion’s complex relation rollups, linked databases, and every filter combination imaginable, Bases doesn’t match that today. It’s getting there, and for most developer use cases it’s already sufficient, but I want to be straight about it.

If you just want simple notes, Obsidian is overkill. Apple Notes is great for quick jotting. Obsidian is for people who want to build a knowledge system, not just take notes.

Frequently Asked Questions

Is Obsidian free for commercial use?

Yes. As of February 2025, Obsidian removed the commercial license requirement. Anyone can use it for work at no cost. Optional commercial licenses are still available if your organization wants to support development.

Can I sync Obsidian between iPhone and Mac without paying?

Yes. Store your vault in iCloud Drive and it syncs automatically. Obsidian Sync ($4/month) adds end-to-end encryption and version history, but it’s not required for basic sync.

Is Obsidian better than Notion for developers?

It depends on what you value. If data ownership, offline access, CLI scripting, and Git version control matter to you, Obsidian is the clear winner. If you need polished real-time collaboration and mature databases, Notion still has advantages — though Bases is narrowing that gap quickly.

What are the best Obsidian plugins for developers?

Start with four: Templater (dynamic templates), Dataview (vault-wide queries), Git (automatic version control), and Excalidraw (embedded diagrams). Add more only when you need them.

---

The best note-taking setup is the one you actually use. For me — and I suspect for most developers who think about their tools the way they think about their code — that means something built on open formats, version control, scriptability, and zero vendor lock-in. Obsidian is that tool. Create a vault, write one note today, and let the compound effect do its work.