Notion vs Obsidian from a Workflow Automation Perspective

Table of Contents

1. Comparing note structure and file storage behavior

Obsidian lives on your hard drive. Like, literally. You can open any note with VS Code or grep through the files in Finder. Notion, on the other hand, is structured more like a database that pretends to be a notebook. It’s wrapped in a UI that lets you click into things, drag blocks around, and collapse toggles, but none of that gets you an actual .md file unless you’re exporting or scraping.

This gets weird when you’re trying to automate backups or sync systems. I wanted to copy all my notes from Obsidian to a cloud backup solution, and it just worked — rsync, cron job, done. Trying to get Notion notes into Git-style version control? I ended up writing a Zap that pulled pages into Airtable, which ended up being useless because Notion’s API omits basic stuff like backlinks or table content inside toggle blocks.

The undocumented edge case: if a Notion page has a synced block from another page, the API won’t return the contents of that synced block — just a reference pointer. So you’re not getting what you visually see unless you build a secondary fetch loop for those blocks too.

2. Differences in how linking and backlinks behave

Obsidian treats internal links like citizens. You drop [[this note]] into a file and it instantly becomes a connection. Click it, you’re there. There’s also a real-time backlink pane, so you can just see how everything hooks together without building anything else.

Notion technically has backlinks now, but it’s more of a cosmetic feature. It’s inconsistent. For example, if you link to a Notion database row (not a full page), the backlink doesn’t always trigger — especially if you’re using @mentions. I spent 30 minutes wondering why a particular reference wasn’t showing in my backlinks and eventually realized I had pasted a URL instead of using the internal page search. The behavior between @mentions and URL-pastes is different but not documented anywhere, which feels like a trap.

Aha moment: In Obsidian, even broken links are treated as valid nodes. That turns out to be great for roadmapping projects. If I have an idea, I can just link to a note that doesn’t exist yet, and it’ll show up in graph view as a stub. In Notion, that same workflow requires creating an empty page or putting a fake entry in a database just to anchor it.

3. Real-time collaboration limits and sharing overhead

Notion wins here if you’re a team. Real-time updates feel Google Docs-level fast, and I’ve seen multiple people edit the same database without wrecking things. You also get granular share settings, so you can give view-only access to clients or create templates for public use.

Obsidian is a black hole on this. You can use Obsidian Sync if you’re paying, or try to hack it via Dropbox or Git — but it’s still a single-user setup disguised as multi-device. Every time I tried to get my VA to work from the same vault, we’d step on each other’s config.json or plugin folders. I finally gave up after the third time she installed a plugin that broke my CSS theme for no reason.

Collaborating in Obsidian requires shared vault sync plus careful control of folder structure
Notion lets you mention a person in a comment, which triggers real notifications
Obsidian has no permissions model — it’s all or nothing
Trying to “share” in Obsidian often ends up with exporting Markdown and emailing it
Notion pages can embed Figma boards, tweets, and Google Drive files reliably
Obsidian needs community plugins for even basic embeds, and they’re hit-or-miss on updates

4. API and automation support across both platforms

This one caught me off guard. Notion has an official API, but it’s clunky. You can’t just “get all notes” — you have to traverse the page tree from a known page ID. Also, Notion’s database vs. page dichotomy feels arbitrary when you’re scripting. Simple things like “pull all pages updated in the last day” require more filtering logic than you’d think.

Obsidian… has no native API. But the local file system is the API. That’s both powerful and risky. For example, I wrote a launcher script that parses daily note templates and injects scraped AI summaries into specific sections. It works, until something in the YAML frontmatter shifts and the parser throws off HTML in the body instead of Markdown.

I also burned an hour debugging why an automation wasn’t overwriting a note during sync. Turned out I had enabled the “Safe write” option in Obsidian’s settings, which creates a backup file instead of doing a clean overwrite. Not even mentioned in the plugin’s README. I found it after grepping timestamp differences between .md and .bak files.

5. Plugin ecosystem strengths and edge cases

Notion keeps everything in-house. The integrations are mostly official, occasionally buggy, but they behave the same for everyone. Obsidian is full wild west — dozens of community plugins, some excellent, some abandoned, some terrifying in what they think counts as UI.

I was using the “Tasks” plugin in Obsidian to track projects and noticed it was auto-completing recurring tasks before I’d even opened my daily note. Turns out it calculates based on system time rather than file open event — so if you don’t open your note on the right day, the recurrence still runs. Not documented, and if you sync across time zones, you can end up with tasks from the future.

Useful surprise: The “Templater” plugin in Obsidian can execute JS inside the note template. I built a timestamp comparison hack to show how many notes I hadn’t updated in 30 days. Essentially a dead-link scanner for my brain. It still surprises me how useful that turned out to be in curating old project ideas.

6. Mobile app behavior differences under inconsistent sync

Mobile is where the polish gap shows. Notion’s mobile app is sluggish but stable. Obsidian’s is snappy but — frequently — unreliable. I once edited the same daily note on mobile and desktop two hours apart and ended up with a zero-byte file. Sync hadn’t finished uploading from mobile, and desktop overwrote it. The vault didn’t even crash; everything just went quiet. No warning. Checked the file history later and it was just… gone.

iCloud sync with Obsidian on iOS is also risky if you don’t explicitly wait for files to upload. I’ve seen diffs that never synced because I left a vault open overnight. Simple fix: close the app. But you’re not going to remember that when you’re editing notes in line at a coffee shop.

Notion’s mobile app auto-saves to the cloud constantly — maybe too aggressively. I once watched it revert a paragraph because of some kind of cached view refresh. Still, you know where your content is, and at worst, you can check version history by opening the page in web. Can’t do that in Obsidian without intentional backups.

7. Nesting hierarchy and global organization limitations

This matters more once you’ve hit 100+ notes. Obsidian treats folders like the filesystem: infinite depth works, and search is immediate. You can build your own hierarchy scheme. Some of mine look like ideas/pending/v2/AI-notes/2023-crashes.md. It actually feels useful during bulk refactors when I just grep and move stuff.

In Notion, everything is a page inside a page — unless it’s a database. Databases are fast for filtering and views, but nesting feels fake. You can’t drag a database into a database without embedding it, and then all the powerful view logic disappears. I tried building a folder-style structure once using page nesting and ended up with a 20-page-wide breadcrumb trail that broke keyboard nav.

Behavioral oddity: You can’t multi-select nested Notion pages unless you’re in the sidebar view — not inside a database. Try holding Shift or Cmd. Nothing happens. So mass moving a group of research notes into a different topic involves dragging them one at a time. Eventually I gave up and built a flow in Make that batch renames and relocates them via the API — which sort of works, but sometimes skips properties with emoji in the name because the Make parser doesn’t handle unicode field keys well.

8. Templates and structured input patterns

Notion templates are amazing when you’re working in a database. You get consistent layouts, pre-filled properties, embedded instructions — everything to keep your team aligned. But they don’t work at the page level unless you’re doing manual duplication. That breaks fast if you want automation.

Obsidian treats templates as flat files, which makes them better for flexible usage. Using the Templater plugin, I inject context-aware notes like this:

— Meeting Note —
Date: <% tp.date.now("YYYY-MM-DD") %>
Context: <% tp.system.clipboard() %>
Tags: #meeting

The real kicker is you can run inline JS to create conditionals in the template. I used it to auto-classify client meetings vs. internal ones based on previously used tags. That’s not possible in Notion without an entirely separate scripting layer.

Still, Notion wins if you need UI forms. Like if you want someone junior to fill out a project update without messing up the layout. Obsidian can’t lock anything, so one wrong paste breaks the YAML or collapses a hidden section.