Obsidian, Notion, Logseq?! The note-taking stack that doesn’t suck for devs

or those building second brains but tired of feature bloat and broken sync.

Press enter or click to view image in full size

I’ve rage-quit more note-taking tools than I care to admit.

Evernote, Bear, Roam, OneNote, Notion-only setups… they all seemed promising. Until they weren’t.
They either locked me into some cloud I didn’t trust, didn’t support Markdown properly, or just couldn’t handle code snippets without throwing a fit.

As a developer, I need something different. I’m not organizing lecture notes or tracking groceries. I’m juggling:

• System architecture scribbles,



• Terminal commands I’ll forget in five minutes



• Bug logs,



• Feature ideas at 2 AM,



• And the occasional “wtf does this regex do?” reminder.

I needed tools that didn’t get in the way, worked offline, played nice with Git, and could actually handle Markdown not fake Markdown that breaks when you paste code blocks.

After years of bouncing between apps and building Frankenstein setups, I’ve finally landed on a stack that doesn’t suck:

Obsidian for Markdown-based vaults,
Notion for collaborative docs,
Logseq for daily logs and idea dumps.

It’s not one app to rule them all. It’s a setup where each tool does its job and doesn’t try to do everything.
Here’s exactly how I use each tool, why this combo works, and how I keep it all synced without creating a second job for myself.

This is what I am covering:

1. Why most note-taking tools fail for devs



2. What devs actually need from a note stack



3. Why I chose Obsidian + Notion + Logseq



4. How I set it up (and kept my sanity)



5. What I tried and ditched along the way



6. Conclusion + helpful links

1. Why most note-taking tools fail for devs

Most note-taking apps weren’t built for developers.
They were built for students, managers, or “productivity gurus” who love tagging life lessons more than writing actual content. So when we the terminal-loving, Markdown-hoarding crowd try to use them, things break. Or worse: they work, but only if you fight the tool for hours first.

Let’s break down the usual suspects:

Evernote

Once the king of notes. Now feels like opening Microsoft Word inside a browser.
No Markdown. No local files. Syncing is slow, and don’t even try pasting a code block it turns into formatting soup.

OneNote

Looks nice, sure. But everything’s locked into Microsoft’s formatting.
You want to copy that command-line cheat sheet to your server? Enjoy pasting from hell.

Roam, Bear, and the rest

Roam is cool if you’re into networked thought. Bear is pretty but Apple-only.
Both hit limits fast if you’re trying to document infrastructure or run a knowledge base with versioning.

Notion-only stacks

Notion is amazing until you need to write fast.
The block-based editor is pretty, but clunky when you just want to type Markdown or search a note by filename like a normal dev.
Also: Offline? Sort of. Kind of. Sometimes. Good luck syncing if you’re on a flaky connection.

We don’t need infinite features, integrations, or “AI summarization.”
We need something that:

• Handles code without choking,



• Respects folders and file formats,



• Syncs reliably without breaking our notes,



• And works whether you’re in a terminal or stuck on airplane Wi-Fi.

If you’ve ever tried to grep your notes folder or commit it to Git and realized your tool exported in HTML you know the pain.

That’s why I stopped looking for a single magical app.
Instead, I built a stack where each tool solves a specific problem without trying to do everything.

Press enter or click to view image in full sizeVisualizing a developer’s second brain how core topics like programming, scripting, and algorithms interconnect

2. What devs actually need from a note stack

We don’t write notes the same way most people do.
Developers aren’t journaling our feelings or outlining a 12-step morning routine. We’re documenting:

• Bash aliases we forget every week



• Architecture diagrams and design ideas



• Git commands we never fully remember



• Bug reproduction steps from a 3AM panic



• Weird logs from staging that might be useful someday



• TODOs for side projects that live forever in limbo

Most of the time, we’re just trying to dump things fast, find them later, and maybe even version-control them like code.

So when a note app tries to be “inspiring” or “beautiful,” we’re out.
We want fast, ugly-if-it-works tools that don’t get in the way. Here’s what that means:

Markdown-first (not “Markdown-lite”)

If it can’t handle code blocks, inline commands, or bullet lists like a README, it’s useless.
We live in Markdown. It should be native not some export-after-the-fact hack.

Local-first, sync-optional

We want our notes stored on disk, not locked into a proprietary cloud.
If I can’t access my notes offline in a .md file and push them to Git it’s a no-go.

Keyboard-driven and fast

I don’t want to click five dropdowns just to make a heading.
Shortcuts matter. Speed matters. You should be able to take a note mid-debug without breaking flow.

Git-compatible

Being able to version your notes, diff changes, and sync via Git is 🔥. Especially when you’re writing per-project knowledge or keeping a changelog.

Searchable, linkable, and taggable

We don’t need a pretty homepage. We need to search by file name, grep text, or jump to a backlink in seconds.

That’s why the tools I stuck with aren’t “perfect” but they get these core things right.

And when you stack them properly, they cover almost everything you’d need without turning your note system into a second full-time job.

3. Why I chose Obsidian + Notion + Logseq

After years of hopping between apps, I realized one thing:
No single tool does it all and that’s okay.

Instead of forcing one app to handle everything from quick snippets to team docs, I split my workflow across three tools, each with a job:

• 
  
  Obsidian → for dev-focused, local-first Markdown notes



• 
  
  Notion → for team docs, structured content, and sharing



• 
  
  Logseq → for daily logs, idea dumping, and outlining thoughts

This combo hits the sweet spot between flexibility and sanity. Here’s how I use each.

Obsidian: My dev brain

Obsidian is where 80% of my dev notes live. Why?

• It uses plain .md files no lock-in



• Local-first and blazing fast



• Folder-based, with tags, backlinks, and killer search



• Git works perfectly with it (more on that later)



• Massive plugin ecosystem (but optional)

How I use it:

• Per-project vaults synced with Git



• Infra setups, CLI cheat sheets, Kubernetes commands



• Notes on APIs I reverse-engineer



• Keyboard-first journaling with custom templates



• Occasional architecture diagrams using Excalidraw plugin

Notion: My team workspace

I tried running everything in Notion before. Bad idea.
It’s great for sharing docs and collaborating. It’s terrible for fast, personal dev notes.

But as a shared workspace? It shines:

• Well-structured docs with comments and tables



• Easy to embed images, code blocks, Loom videos, whatever



• Perfect for async teams

How I use it:

• Project documentation



• Meeting notes



• Product specs and PRDs



• Internal guides for onboarding

Tip: Use a minimalist template. Otherwise, you’ll spend more time making pretty dashboards than writing.

Logseq: My daily log + scratchpad

Logseq feels like Roam Research but without the hype or the price tag.
It’s an outliner-based note-taker that stores files locally as .md or .org.

What makes it stick?

• Daily journal pages



• Easy backlinks and graph views



• Simple TODO/task tracking



• Works with Git, just like Obsidian

How I use it:

• Daily stand-up notes (real or solo)



• Bug reproduction logs



• Dev journal entries like “why did this thing break?”



• Brain dumps at 1am before I forget an idea

When to use what?

Press enter or click to view image in full size

This isn’t a perfect division but it works.
Each tool stays in its lane, and I don’t waste time wondering “where should I put this note?”

4. How I set it up (and kept my sanity)

Alright, now for the part that usually breaks people: setup.
Running three tools sounds like chaos. But it’s surprisingly smooth once you set boundaries and sync things smartly.

Let’s break it down tool by tool:

Obsidian setup: Markdown, Git, done

Obsidian stores your notes in plain folders with .md files. That means you can version-control everything with Git which is exactly what I do.

Here’s the setup:

1. Create a folder structure for your notes:

~/vaults/
├── dev-notes/
├── project-alpha/
└── personal-snippets/

2. Initialize a Git repo inside each vault:

git init
git add .
git commit -m "Initial commit"

3. Install the https://github.com/blacksmithgu/obsidian-dataview (Dataview for querying .md files)


Press enter or click to view image in full size