Obsidian as a second brain: how I organized my chaos as a fullstack developer

The problem: scattered information, lost context

I work as a fullstack developer at an agency. That means multiple projects running in parallel, meetings with different teams, technical decisions made in one call and forgotten by the next, and a mental backlog that grows faster than I can process it.

Before building this system, my information lived in at least five different places: Notion for team documentation, Apple Notes for quick ideas, Obsidian with a chaotic structure, Claude conversations that got lost between sessions, Slack messages I could never find again, and shared Google Docs that nobody kept up to date.

The result was predictable. Every time I needed context about a past decision, I had to reconstruct it from scratch. “Why did we choose this architecture?” — I don’t know, ask someone who was on that call. “What was left pending from the last meeting?” — let me search across three different apps.

The real cost wasn’t the time spent searching. It was the loss of trust in my own system. If I couldn’t trust that the information was somewhere, I’d stop documenting. And if I stopped documenting, the next search would be even worse.

Why Obsidian (and not Notion, Apple Notes, or anything cloud-based)

The decision wasn’t obvious. Notion is what my team uses. Apple Notes is the fastest way to capture something. But neither solved the underlying problem.

Notion is excellent for collaborative documentation, but as a personal second brain it has friction: it depends on internet, search is slow in large vaults, it doesn’t have a portable format (your notes live in their database), and you can’t easily operate it from an AI agent.

Apple Notes is perfect for quick capture, but it has no metadata, no bidirectional links, no queries, no plugins. It’s a box where things go in and rarely come out organized.

Obsidian won for three reasons:

1. Local Markdown files. My notes are .md files on my disk. If Obsidian disappears tomorrow, my knowledge is still there. No lock-in, no painful migrations.
2. Extensibility. Plugins like Dataview, Templater, and Tasks turn a Markdown editor into a programmable productivity system. And the community ecosystem is massive.
3. Agent operability. With MCP servers, Claude Code can read, create, and modify notes in my vault without me having Obsidian open. This was the definitive differentiator: my second brain isn’t just for me, it’s also for my agents.

The architecture: PARA + Zettelkasten

I reorganized the entire vault from scratch using a combination of two methodologies:

PARA (Projects, Areas, Resources, Archive) by Tiago Forte for the folder structure. It gives you a clear place for everything based on its level of actionability.

Zettelkasten for permanent knowledge. The idea is that atomic notes, well-linked to each other, generate compound value over time.

The structure ended up like this:

00-Inbox/          → Universal capture. Everything unclassified.
01-Projects/       → Active projects with deadlines
   endeavor/       → Main project (Next.js, Salesforce, AWS)
     meetings/     → Meeting notes
     prds/         → Product Requirement Documents
     dailys/       → Daily standup logs
     decisions/    → Architecture Decision Records (ADRs)
     tickets/      → Detailed tasks as pages
   side-projects/  → Personal projects
02-Areas/          → Ongoing responsibilities (feedback, career)
03-Resources/      → Reference material, research, prompts
04-Archive/        → Completed projects
05-Knowledge/      → Permanent Zettelkasten notes
Calendar/          → Personal daily notes
Templates/         → Templater templates

The key is that every note has standardized frontmatter:

---
type: meeting | daily | prd | adr | ticket | reference
project: endeavor | meli | project-name
status: active | completed | archived
tags: [tag1, tag2]
created: 2026-04-17
---

This makes everything queryable. Dataview can ask the vault “what are this week’s Endeavor meetings?” or “which PRDs are in draft?” and get real-time answers.

The daily flow

My workday has a predictable rhythm thanks to this system:

Morning: start with context

I open the terminal, run claude, and type /today. Claude Code creates my daily note with yesterday’s pending tasks, today’s meetings, and relevant context about what I’ve been working on. In 10 seconds I have the full picture without opening a single app.

During the day: capture without friction

When something comes up — an idea, a pending item, a piece of information from a conversation — I use /capture from Claude Code. The note goes straight to 00-Inbox/ with a title and basic metadata. I don’t need to decide where it goes. Just capture it.

If I have a meeting, /meeting creates the note with the right template, in the right folder, with context from the last meeting of the same project. I just fill in the bullet points during the call.

End of day: process the inbox

When I have a gap, I run /inbox. Claude shows me each inbox note, suggests which folder to move it to based on content and frontmatter, and waits for my confirmation. In 5 minutes the inbox is empty and everything is classified.

Friday: weekly wrap-up

/wrapup generates a summary crossing all the week’s activity: meetings, completed tasks, decisions made, notes created. I review it, adjust if needed, and with /notion-sync publish it to Notion so the team has visibility.

Automation with Claude Code

Automation is what separates an organized vault from a second brain that actually works. Without it, the friction of keeping the system up to date eventually beats discipline.

Slash commands: my vault’s interface

I have 9 slash commands in .claude/commands/ covering all common operations:

Each command knows where to save things, which template to use, which frontmatter to apply, and which vault context to include. I don’t have to remember any conventions — the system enforces them for me.

The global skill: vault-save

Beyond local commands, I have a global skill (/vault-save) in ~/.claude/commands/ that’s available from any project where I run Claude Code. If I’m working in the blog repo and want to save a PRD to my vault, I don’t need to change directories. The skill knows the exact paths and frontmatter rules for each content type, and uses MCP to write directly to the vault.

MCP servers: the bridge between Claude and Obsidian

The piece connecting everything is an Obsidian MCP server configured as a global server in Claude Code. This gives Claude 14 tools to operate the vault: read notes, search content, create files, update frontmatter. Without having Obsidian open, without manually touching the filesystem.

Combined with the Notion and GitHub MCP servers, the result is an agent that can read my vault, create a summary, publish it to Notion, and update a GitHub issue. All from a single prompt.

Tickets: the task system that scales

For simple tasks I use inline checkboxes (- [ ] task 📅 date). But when a task needs context, acceptance criteria, or status tracking, I escalate it to a ticket: a full note in 01-Projects/{project}/tickets/ with its own frontmatter and status flow (open → in-progress → review → done).

The Obsidian Dashboard shows three ticket views: open by priority, in progress, and completed in the last 14 days. The rule is simple: if it fits in one line, it’s a checkbox. If it needs more than one line, it’s a ticket.

What changed in my work

After several weeks using this system, the most notable changes are:

I stopped losing context between projects. When I return to a project after a week, /status gives me the full picture in seconds. I don’t need to reconstruct anything from memory.

Meetings became data. Each meeting has a structured note with decisions and action items that automatically show up in the Dashboard. When someone asks “what did we decide about X?”, the answer is one /search away.

Documentation writes itself. It’s not that I became more disciplined. It’s that the friction of documenting dropped so much that the cost of NOT doing it became higher. Creating an ADR takes 30 seconds with /decision. Documenting a meeting takes as long as the meeting itself. Capturing an idea takes one /capture.

The vault accumulates intelligence. The more notes it has, the better Claude can answer questions about my work. “When was the last time we discussed CDC?” is no longer a rhetorical question — it’s a query with an answer.

My mental backlog emptied. Everything that used to live in my head — pending items, ideas, decisions — is now externalized in a system I trust. And that trust is the most important change of all.

Next steps

The system is stable and functional, but there are extensions I want to explore:

• Slack and Gmail integration to automatically capture tasks and context that currently get lost in those channels.
• Telegram sync for mobile capture — being able to send a message to the vault from my phone.
• Obsidian Copilot for RAG over the vault: semantic search instead of keyword matching.
• Automated cron jobs on the Mac for inbox processing and report generation without manual intervention.
• Weekly reports auto-synced to Notion so the team has visibility without me having to publish manually.

The vault is a living organism. It’s not finished and probably never will be. But the difference between a system that evolves and chaos that accumulates is the initial structure and the automations that sustain it. And that, at least, I’ve got sorted.

If you want to build something similar, my recommendation is to start with the folder structure and standardized frontmatter. Plugins and automations can come later. What can’t wait is deciding where each thing goes — because if you don’t make that decision at the start, you’ll make it (badly) a hundred times a day.