The Developer's Guide to Obsidian: My Second Brain Setup

I've always been terrible at keeping notes. I'd start with good intentions - a fresh notebook, a new app, a promise to "document everything this time." A week later, it was abandoned. Notes scattered across Apple Notes, random text files, browser bookmarks, and half-finished Google Docs.

Then I discovered Obsidian, and something clicked.

It's not perfect. It's not magical. But it's the first note-taking system that stuck for me as a developer. Here's why, and how I use it to build what Tiago Forte calls a "second brain" - an external system for capturing, organizing, and retrieving knowledge.

Why Obsidian Works for Developers

Most note-taking apps feel like they were designed for writers, project managers, or students. Obsidian feels like it was built by developers, for developers.

Plain text Markdown files - Your notes are just .md files in a folder. No proprietary format, no vendor lock-in. You can version control them, grep through them, back them up however you want.

Local-first - Everything lives on your machine. No internet required, no sync delays, no cloud service that might shut down.

Extensible via plugins - Like VSCode extensions, there's a plugin for almost anything. Community-driven development.

Graph view - Visualize connections between notes. Sounds gimmicky, but it's surprisingly useful for discovering forgotten connections.

Bidirectional links - Link notes together naturally. It creates a web of knowledge instead of rigid folders.

But here's the real reason it works: Obsidian is fast. Instant startup, instant search, no lag. When you have an idea, you capture it before it evaporates.

My Setup: The Foundation

I keep my setup relatively simple. Here's the folder structure:

obsidian-vault/
├── 00-Inbox/           # Quick captures, unsorted notes
├── 01-Projects/        # Active work projects
├── 02-Areas/           # Ongoing responsibilities
│   ├── Learning/
│   ├── Blog-Ideas/
│   └── Code-Snippets/
├── 03-Resources/       # Reference material
│   ├── Books/
│   ├── Articles/
│   └── Courses/
├── 04-Archive/         # Completed or inactive
└── Templates/          # Note templates

This is inspired by the PARA method (Projects, Areas, Resources, Archives) by Tiago Forte, but simplified for my needs.

Why This Structure Works

00-Inbox is crucial. When an idea hits, I don't think about where it goes - I dump it in Inbox. Weekly review sorts it later.

Projects vs. Areas - Projects have an end date (build feature X, write blog post Y). Areas are ongoing (learning React, improving fitness). This distinction helps me prioritize.

Code-Snippets - This folder alone justifies using Obsidian. I've saved hundreds of useful snippets here, searchable in seconds.

The Plugins That Changed Everything

Obsidian's core is solid, but plugins unlock its real power. Here are the essential ones:

1. Templater

Auto-generates note templates with dynamic content. Game-changer for consistency.

Here's my daily note template:

---
date: {{date}}
tags: [daily-note]
---
 
# {{date:MMMM DD, YYYY}}
 
## 🎯 Today's Focus
-
 
## 📝 Notes
 
 
## 💡 Ideas
 
 
## ✅ Completed
-
 
## 🔗 Links

Type a command, and this scaffolds a new daily note with today's date. No thinking required.

2. Dataview

This is wild - it's like SQL for your notes. Query and display data from your markdown files.

Example - show all unfinished tasks across all notes:

TASK
WHERE !completed
GROUP BY file.link

Or list all blog post ideas:

TABLE title, status, tags
FROM "02-Areas/Blog-Ideas"
WHERE status = "draft"
SORT file.mtime DESC

It turned my static notes into a dynamic database.

3. Calendar Plugin

Visual calendar showing daily notes. Click a date, create a note. Simple but effective for journaling.

4. Periodic Notes

Automates creation of daily, weekly, monthly notes. I use it for:

Daily: Log what I worked on, ideas, wins
Weekly: Review, plan next week, process inbox
Monthly: Bigger picture reflection, goal check-ins

5. QuickAdd

Macro system for capturing notes quickly. I have shortcuts for:

Cmd+N → New inbox note
Capture code snippet with template
Save article/link with metadata
Create new project note

Speed matters. If capturing a note takes more than 5 seconds, I won't do it.

6. Excalidraw

Draw diagrams directly in Obsidian. Perfect for:

System architecture sketches
Database schema designs
Algorithm visualizations
Whiteboard-style brainstorming

The diagrams are just .excalidraw.md files - they integrate seamlessly with text notes.

7. Advanced Tables

Working with markdown tables is painful. This plugin adds spreadsheet-like editing:

Tab to move between cells
Auto-formatting
Formulas (basic calculations)

Great for comparison tables, decision matrices, and tracking.

8. Outliner

Better outlining with keyboard shortcuts:

Cmd+Up/Down - Move bullet points
Tab / Shift+Tab - Indent/outdent
Folding and zooming into sections

Makes Obsidian feel more like Roam or Workflowy.

9. Git (for backup)

Auto-commits and pushes my vault to a private GitHub repo. Set it and forget it.

Commit interval: 10 minutes
Auto-pull on startup: Yes
Auto-push on commit: Yes

My notes are version-controlled and backed up without thinking about it.

10. Kanban

Markdown-based kanban boards. I use it for:

Blog post pipeline (Ideas → Drafting → Editing → Published)
Learning goals tracker
Side project backlog

Everything stays in plain markdown, queryable with Dataview.

My Workflows

Here's how I actually use Obsidian day-to-day:

1. Morning Routine (5 minutes)

Open Obsidian (auto-creates today's daily note)
Review yesterday's note
Write 3 focus items for today
Check weekly note for bigger goals

2. Capturing Throughout the Day

Whenever I learn something useful, I hit Cmd+N (QuickAdd shortcut):

Code snippet I want to remember:

---
tags: [code, typescript, utility]
language: typescript
---
 
# Remove Duplicates from Array
 
## Code
 
```typescript
const unique = [...new Set(array)]
```
 
## When to Use
 
When you need to deduplicate an array of primitives.
Does NOT work for objects (use lodash uniqBy instead).
 
## Related
- [[Array Methods]]
- [[TypeScript Utilities]]

Article worth remembering:

---
source: https://...
author: Jane Doe
tags: [article, react, performance]
---
 
# Article Title
 
## Key Takeaways
-
-
-
 
## Notes
 
## Code Examples
 
## Related
-

The key: templates for common note types. No decision fatigue about structure.

3. Weekly Review (30 minutes, Sunday evening)

This is where the magic happens:

Process Inbox - Sort all notes from 00-Inbox into proper folders
Review daily notes - Pull out important ideas, create permanent notes
Update projects - Mark completed, archive finished, plan next steps
Check blog ideas - Any notes ready to become posts?
Refactor links - Connect related notes, improve discoverability

The weekly review prevents my vault from becoming a dumping ground.

4. Building "Evergreen Notes"

I don't just dump information - I process it into "evergreen notes."

Fleeting note (in Inbox):

"Read article about React Server Components. Interesting pattern for data fetching."

Permanent note (after processing):

---
tags: [react, server-components, patterns]
created: 2025-12-18
---
 
# React Server Components - Data Fetching Pattern
 
Server Components can fetch data directly without client-side effects.
 
## Benefits
- No useState/useEffect waterfall
- Reduced bundle size (fetch logic stays on server)
- Better SEO (HTML includes data)
 
## Trade-offs
- Can't use React hooks
- More complex mental model
- Requires Next.js or similar framework
 
## Example Pattern
 
```typescript
// app/users/page.tsx (Server Component)
export default async function UsersPage() {
  const users = await db.query('SELECT * FROM users')
 
  return (
    <div>
      {users.map(user => (
        <UserCard key={user.id} user={user} />
      ))}
    </div>
  )
}
```
 
## When to Use
- Data needed for initial render
- SEO-critical content
- Static or slow-changing data
 
## Related
- [[Next.js App Router]]
- [[Data Fetching Patterns]]
- [[Server vs Client Components]]

Notice:

Context (what, why, trade-offs)
Concrete example
Guidance on when to use
Links to related concepts

This is a note I'll actually find and use later.

5. Blog Post Development

My blog post workflow lives entirely in Obsidian:

Capture idea in 02-Areas/Blog-Ideas/
Brainstorm - bullet points, examples, outline
Draft - write in Obsidian (it's just markdown)
Polish - move to MDX file in my Next.js project
Publish - but keep research notes in Obsidian for reference

Current blog post pipeline (using Kanban plugin):

Ideas: 12 notes Researching: 3 notes Drafting: 2 notes Ready to Publish: 1 note

All queryable: "Show me blog ideas tagged 'react' that I haven't started"

LIST
FROM "02-Areas/Blog-Ideas"
WHERE contains(tags, "react") AND status = "idea"

Settings That Matter

Here are settings I've tweaked from defaults:

Editor:
├── Readable line length: ON (easier on eyes)
├── Strict line breaks: OFF (soft wrapping)
├── Show frontmatter: ON (see all metadata)
└── Vim keybindings: ON (personal preference)

Files & Links:
├── Automatically update links: ON
├── Default location for new notes: "00-Inbox"
├── New link format: "Shortest path"
└── Use [[Wikilinks]]: ON

Appearance:
├── Theme: Minimal (clean, fast, readable)
├── Base theme: Dark
└── Font: JetBrains Mono (same as VSCode)

Hotkeys:
├── Quick switcher: Cmd+O
├── New note: Cmd+N
├── Open graph view: Cmd+G
├── Toggle edit/preview: Cmd+E
└── Search: Cmd+Shift+F

Vim mode is controversial, but if you already use Vim bindings, Obsidian supports them natively. Navigating large notes is much faster.

How I Use Graph View

The graph view looks cool but can be useless if you don't use it intentionally.

Here's what works for me:

Filter by tag - Show only #react notes, see how they connect Find orphans - Notes with no links are isolated knowledge (bad) Discover connections - Hover over a note, see what relates to it

I don't stare at the graph daily, but weekly I'll explore it to find:

Underconnected notes (add links)
Emerging clusters (maybe a blog post?)
Forgotten topics (time to revisit?)

Code Snippets System

This deserves its own section because it's so useful.

Structure:

02-Areas/Code-Snippets/
├── TypeScript/
├── React/
├── CSS/
├── Bash/
├── Git/
└── SQL/

Each snippet follows a template:

---
tags: [snippet, <language>, <topic>]
language: <language>
created: <date>
---
 
# [Snippet Name]
 
## Code
 
```language
// The actual code
```
 
## Explanation
What it does and why
 
## When to Use
Context for applying this snippet
 
## Gotchas
Edge cases, limitations, warnings
 
## Related
- [[Related Snippet 1]]
- [[Related Snippet 2]]

Search is instant. Cmd+O, type "debounce typescript", hit Enter. Snippet appears in 1 second.

Compare that to:

Searching through old projects
Googling and hoping Stack Overflow has it
Asking ChatGPT and debugging its hallucinations

I've saved myself hours with this system.

What Didn't Work

Things I tried but abandoned:

Over-organizing - Too many folders, too many tags. Simpler is better.

Zettelkasten strict rules - The slip-box method is powerful but felt too rigid for me. I took the principles (atomic notes, links, permanent notes) but simplified the system.

Daily note perfectionism - Tried to log everything meticulously. Burned out. Now I just capture highlights and key takeaways.

Too many plugins - At one point I had 30+ plugins. Obsidian got slow. Now I keep it under 15.

Complex templates - Tried super detailed templates with 20 fields. Never filled them out. Simple templates get used.

Mobile Workflow

Obsidian has mobile apps (iOS/Android). Here's how I use them:

Capture only - Phone is for quick captures, not deep work

Voice notes - Record audio, transcribe later on desktop

Daily note - Quick journal entry, task completion logging

Reading - Review saved articles during commute

I sync via Obsidian Sync ($10/month). Worth it for instant sync across devices. Alternatives: iCloud, Syncthing, or Git.

The "Second Brain" in Practice

Here's a real example of how this system helped:

Scenario: Client asks about implementing real-time search with debouncing in React.

Without Obsidian:

Google "react debounce search"
Find Stack Overflow answer
Copy code, probably has issues
Debug for 30 minutes
Forget the solution next time

With Obsidian:

Cmd+O → "debounce"
Find my note: [[React Debounced Search Pattern]]
See working code I've used before
See notes about gotchas (cleanup, deps array)
See link to [[Custom Hooks Best Practices]]
Implement in 5 minutes

The second brain isn't about remembering everything - it's about quickly retrieving what you've learned.

Getting Started: My Advice

If you want to try this, here's what I'd do:

Week 1: Just capture

Install Obsidian
Create an Inbox folder
Dump every idea, snippet, note into it
Don't organize yet

Week 2: Find your structure

Review the week's notes
What categories emerge naturally?
Create folders that match your needs
Move notes accordingly

Week 3: Add one plugin at a time

Start with Templater (for templates)
Then Calendar (for daily notes)
Then one more based on your workflow

Week 4: Build a habit

Morning: Review yesterday, plan today
Throughout day: Capture when you learn
Weekly: Process inbox, connect notes

Don't:

Don't copy someone else's entire system
Don't install 20 plugins on day 1
Don't try to be perfect
Don't migrate all your old notes at once

Start small. Let it grow organically.

My Actual Vault Stats

After 8 months of daily use:

1,247 notes (growing daily)
89 code snippets (the most valuable)
24 blog post drafts in various stages
156 daily notes (not every day, but most)
23 project notes (current and archived)

The vault is becoming genuinely valuable. It's where I think, where I learn, where I plan.

Resources

Want to go deeper?

Books:

Building a Second Brain by Tiago Forte - The philosophy behind this approach
How to Take Smart Notes by Sönke Ahrens - Zettelkasten method

Links:

Obsidian.md - Official site
Obsidian Forum - Community plugins, tips, discussions
r/ObsidianMD - Active subreddit

Similar Tools:

Logseq - Open source, outliner-focused, similar philosophy
Roam Research - Pioneered bidirectional links, more expensive
Notion - More features, less local-first, slower
Dendron - VSCode-based, for developers who want everything in one tool

The Bottom Line

Obsidian isn't magic. It's just files and folders with some nice features. But it finally gave me a system that works with my developer brain instead of against it.

The best knowledge management system is the one you'll actually use. For me, that's Obsidian - fast, local, extensible, and built on plain text files I can control.

If you're drowning in scattered notes, browser bookmarks, and forgotten ideas, give it a shot. Start simple. Capture everything for a week. See what emerges.

What's your system for managing knowledge? Are you using Obsidian, something else, or still searching for what works? I'd love to hear what's working for you.

Quick Start Checklist:

[ ] Download Obsidian
[ ] Create vault in a synced folder (Dropbox, iCloud, etc.)
[ ] Create Inbox folder
[ ] Install Templater plugin
[ ] Create daily note template
[ ] Set QuickAdd shortcut for new notes
[ ] Capture 3 things today
[ ] Review and organize this weekend

My Essential Plugins:

Templater (templates with logic)
Dataview (query your notes)
Calendar (visual daily notes)
Periodic Notes (daily/weekly/monthly)
QuickAdd (fast capture)
Excalidraw (diagrams)
Advanced Tables (better markdown tables)
Outliner (better list editing)
Git (backup)
Kanban (visual task boards)