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:
- Why most note-taking tools fail for devs
- What devs actually need from a note stack
- Why I chose Obsidian + Notion + Logseq
- How I set it up (and kept my sanity)
- What I tried and ditched along the way
- 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.
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
.mdfiles 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:
- 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 Obsidian Git plugin
- Autosync on startup
- Manual push/pull
- Works offline
4. (Optional) Use Obsidian Sync if you want cloud sync without Git but it’s paid.
💡 Pro tip: Use .gitignore to skip plugin metadata or .DS_Store junk on macOS.
Logseq setup: daily logs + Git FTW
Logseq is like Obsidian’s chaotic cousin more fluid, more outline-based. But it stores everything as Markdown too.
- Default daily journals go into
journals/YYYY_MM_DD.md - You can use the same Git setup as Obsidian.
- Works beautifully with GitHub, GitLab, or even local backups
My setup:
- Daily journaling logs in Logseq
- Synced via Git with a private repo
- Quick CLI alias to push/pull:
alias lpush='cd ~/logseq && git add . && git commit -m "daily sync" && git push'
Warning: Don’t try to sync with cloud drives and Git at the same time pick one. Cloud sync + Git = guaranteed merge hell.
Notion setup: keep it minimal
Notion doesn’t need much setup. But you need discipline, or it becomes a UI graveyard.
Here’s how I keep it sane:
- One workspace
- Three top-level pages:
/Team Docs/Product Specs/Meeting Notes
Inside each, I keep templates simple. No fancy covers. No emojis unless someone begs.
I use Notion like a dev uses Confluence: just write and move on.
Bonus tip: Create a “Quick Capture” page with a synced block paste stuff here, sort it later.
What about mobile?
- Obsidian: Use the mobile app. Works well with Obsidian Sync, or setup Git via Working Copy (iOS) or Termux (Android)
- Logseq: Mobile app exists but can be buggy. Stick to desktop for heavy use.
- Notion: Mobile app is solid good for reading docs, less so for editing deeply.
Once it’s all wired up, syncing becomes muscle memory.
I commit Obsidian/Logseq changes like code, and Notion just… sits there and works.
You don’t need dashboards, zettelkasten pyramids, or 100 plugins.
Just a working setup that doesn’t waste your time.
5. What I tried and ditched along the way
Before I landed on this Obsidian + Notion + Logseq setup, I fell for all the shiny things.
Tana
People kept calling it “Roam on steroids.” What I got was a system so complex I needed a second brain just to use my second brain.
Tried it for two weeks. Ended up spending more time organizing than writing.
Verdict: powerful, but too much overhead for devs who want to move fast.
Evernote (yes, again)
Look, I wanted it to work. I really did.
But the moment it turned my terminal output into Comic Sans spacing, I knew we were done.
Also: paid features, slow sync, no Markdown, no Git it’s stuck in 2012.
Apple Notes
Beautiful and fast. Until you try pasting a shell script or exporting anything useful.
Great for grocery lists. Garbage for dev notes.
Dropbox Paper
Actually decent. It handled Markdown better than expected, had a nice layout, and decent search.
But it’s… dying. No real updates, and not ideal for long-term note hoarding.
Why chasing perfect tools never works
Every time I thought “maybe this new app will finally solve it”, I lost hours migrating content, re-learning shortcuts, and reorganizing.
Eventually, I realized:
The best stack is the one you’ll actually use.
Notion will never be Obsidian. Logseq isn’t built for teams. That’s fine.
Trying to force one tool to do everything leads to bloat, frustration, and weird folder hierarchies you abandon after a week.
This current stack isn’t perfect but it’s good enough to stop searching.
And honestly, that’s the most underrated feature of all.
6. Conclusion + helpful links
So yeah after years of bouncing between tools, I stopped trying to find “the one”.
Instead, I built a stack where each app plays a role, and none of them fight each other.
If you’re a dev, here’s the TL;DR:
- Obsidian is your Markdown brain local, fast, Git-friendly
- Notion is your team’s brain structured, collaborative, clean
- Logseq is your scratchpad for daily logs, thought-dumps, and wild ideas
They don’t try to do everything. And that’s why it works.
You don’t need a zettelkasten system from YouTube. You just need a setup that lets you write, find, and reuse your own notes without rage.
Here’s what I’d tell any dev building a second brain:
Start ugly. Write messy. Organize later. Just pick tools that don’t fight you.
Helpful resources
- Obsidian Git plugin (auto-sync with Git): https://github.com/denolehov/obsidian-git
- Logseq (Markdown outliner + journal): https://logseq.com
- Notion minimal template (to avoid the dashboard trap): https://www.notion.so/templates
- Obsidian community plugins list: https://obsidian.md/plugins
- Example vault structure for dev notes (GitHub): https://github.com/blacksmithgu/obsidian-dataview (Dataview for querying .md files)
Top comments (2)
Some comments may only be visible to logged-in visitors. Sign in to view all comments.