Splitting Notes in Obsidian


One of the key things you need to understand about obsidian if you really want to make the most of it is the concept of atomic note taking. The TL;DR is to break down your notes into the smallest possible pieces which allows them to be linked together and makes them visible inside of the Local Graph view.

This can come in handy when you’re navigating the notes inside your Obsidian vault. But this is different that the default way most of us have become used to taking notes. If you’re like me, most of the time when you’re taking notes, you just jot down a bunch of things at once. But with Obsidian, you can actually break apart those notes after the fact and effortlessly link those notes together.

For this example, let’s use this note that I have here for the book Atomic Habits by James Clear. I’ll start with this really big note of everything from the book but then I want to break apart individual pieces of this into their own specific notes. And there’s a couple ways that we can do this.

Simple: Note Composer

The first way is to use the Note Composer plugin, which is a core plugin allowing you to both split apart notes and to combine notes. But for the purposes of atomic note taking, we’re going to look at breaking apart notes.

To enable the Note Composer core plugin, first click the Settings button down here in the left sidebar,

Next, click on Core Plugins and make sure that note composer is toggled on.

Once this is toggled on, you can activate the Note Composer actions from Obsidian. So let’s close our settings, go back to our note for Atomic Habits, and select a part of the note we want to break apart into a separate note (like the section right here on the British cycling team). Now we can break this into its own specific note by right clicking and selecting Extract current selection.

(I can also access this by going to the Command Palette by hitting Command-P and searching for note composer.)

When you select Extract current selection, Obsidian will ask you which file you want to send that selection too. Select an existing note to append the text to that note (add it to the bottom), or type a name for a new file like British Cycling Team and hit Enter to create a new note. Once you do, the new note will be created and the selection will become the contents of the new note.

And in the original Atomic Habits note, the original selection is gone and in its place is an internal link to the British Cycling Team note.

This link connects the two notes using bidirectional linking, and allows me to navigate between these notes using the Graph view

Advanced: Note Refactor

But there’s another plugin we can use to break things into separate notes that’s a little bit more powerful. It’s kind of like Note Composer+, and it’s called Note Refactor. This is a community plugin, so to enable Note Refactor, you need to go to Settings, then go to Community Plugins, and click Browse.

Next, search for Note Refactor and make sure that it is both installed and enabled.

Once it’s active, you can access Note Refactor via the Command Palette. This plugin breaks apart your notes as well, but it does a lot of other really cool things. For example, you can take a lengthy note and break apart every header section in the note as it’s own note. Let’s use this note for The Great Mental Models, Volume 1.

Each third level header in the book (indicated the the ### at the beginning of the line) covers a specific mental model. So let’s say I want to break each one of those mental models apart as its own separate note using Note Refactor. To do this, I just hit Command-P to activate the Command Pallete, search for Note Refactor, and select the option Split note by headings - H3.

Now when I hit Enter, a whole bunch of new notes get created and each one of those new notes is now linked to inside of my original note.

And because those are individual notes, I can connect those notes to other notes which may reference those ideas, allowing me to build a spiderweb of backlinks from the notes in my library.

(If you want more plugin recommendations, check out A Few of Our Favorite Obsidian Plugins).

Obsidian vs. Roam Research

Obsidian vs. Roam

The last 18 months could be classified as “the rise of the connected note-taking app.” In the past year, Roam Research raised $9 million dollars (with a $200 million valuation) , Obsidian was nominated for the Product Hunt Golden Kitty award from for the Productivity category, and countless other note-taking apps entered the productivity space with their own version of bidirectional linking features. Even Drafts got an update which allows wiki-style cross-linking.

It’s an exciting time for thinkers and creators.

While there are lots of apps doing lots of interesting things with notes right now, by far the two most popular options are Roam Research and Obsidian. In this article, we’re going to compare these two connected note-takers and help you choose the right one.

The Approach

It’s impossible to say “just use this one” when it comes to picking the right connected note-taking app for you. On the surface they may seem similar, but there are several important differences that stem from fundamentally different approaches to how your notes are stored and managed.

There are lots of things you can look at when picking your PKM app, but here are the criteria we used:

  • User Interface
  • Graph View
  • Daily Notes
  • Backlinks
  • Sidebar
  • Block Embeds/References
  • Markdown Support
  • Search/Query
  • Daily Notes
  • Tasks
  • Expandability
  • Theming
  • Data Portability
  • Publishing
  • Data Security
  • Mobile Experience
  • Pricing

In this article, we’re going to carefully consider the design choices each app makes in these categories and do our level best to help you pick the right PKM app to fit your workflow.

User Interface

The user interface is arguably the most important aspect of a note-taking app, making it easy (or unnecessarily difficult) to capture your ideas and thoughts when you have them.


As a pure note-taking app, Obsidian’s interface can be confusing. There are a couple of sidebars and a whole bunch of buttons that can get in the way of capturing text into your Obsidian vault.

Once you understand the interface, this really isn’t a problem. But I’ve watched more than one person open Obsidian for the first time and immediately close the app because it looked too complicated.

When working with text in Obsidian, there are two different modes you will switch between:

  • Edit Mode where you write your text
  • Preview Mode where you can view the result of your Markdown-formatted text

You can switch modes by clicking the icon in the top-right of the document pane, but if you switch back and forth a lot this can be a little tedious. You can actually hold the Command key when you click on the Preview icon to open the preview in a new pane, which gives you a side-by-side view of your note.

I actually prefer to write this way as the preview gets updated in real-time. But it’s not entirely discoverable for a brand new user.


The user interface is where Roam Research really shines. It has a clever way of displaying the raw text when you click on a line, then rendering the preview when you switch the focus to another line.

This is a great way to work with your text, and eliminates a lot of the friction if you do more than just text.

Roam also includes a section at the bottom of each note which shows the backlinks, making them more easily discoverable for new users. We’ll dig deeper into backlinks in the next section, but it’s worth calling out here because being able to see and link related pages is an important of the user interface and Roam does this better.

Winner: Roam

Graph View

The Graph is kind of like a mind map, showing all of the connections between all of the notes. It can be useful to help see links between notes and ideas, but can also be overwhelming when you have a lot of notes.


Obsidian’s graph view is incredible. Not only is it super-fast, but you can apply filters, create groups, and even change the look and functionality of the graph itself:

But the real magic in Obsidian happens in the local graph.

You can open a local graph by clicking on the three dots in the upper-right of the active note and selecting Open local graph from the menu. This opens a simpler graph which shows the notes in your vault that link to the active note, and the notes that the active note links to. These bidirectional links allow you to navigate between your notes by clicking on the dots in the local graph.

The local graph automatically updates when you open a new active note, and it can be stored in the sidebar so you can access it quickly.


The Graph Overview in Roam gives you a look at the connections between all the notes in you library, but is completely unusable if you have a large number of notes. You can see the connections when you hover over a circle for a specific note, but they seem to be randomly spaced and there isn’t a great way to navigate between them.

There are also no filters to help clean up the Graph overview, and it’s much slower in our testing than the Graph View in Obsidian.

Roam does have a button on each note page that you can click to “Open a graph of this page in the sidebar,” but it doesn’t update as you navigate through your notes. It is literally a static graph view of the current note and the links between other notes in your Roam database. While it can serve it’s purpose, we feel the Graph View in Obsidian is much more polished - and much more useful.

Winner: Obsidian

Backlinks are the foundation of a connected note-taking app, allowing you to navigate between your notes like a personal wiki. Both Roam and Obsidian take this wiki-style linking a step further though, allowing you to surface unlinked mentions of your currently selected note and make connections with a click. This allows you to intentionally connect your notes in new and more meaningful ways, which can be especially useful for creatives who want to develop their ideas.


Linking to pages in Obsidian is simple: just use [[pagetitle]] anywhere in your text to add a link to the note with that page title. Obsidian’s auto-complete helps you find the page you want to link to, or you can create a link to new page by entering a text string that doesn’t currently exist in a note title. You can click on these links to navigate to that page when in Preview mode, and the connection also shows up in the graph view.

You can also use Obsidian’s auto-complete to link to headers in the document by using #, or link to a specific block by using ^.

The problem with backlinks in Obsidian lies in how it handles unlinked mentions. Backlinks (linked mentions and unlinked mentions) are both located in the sidebar and easy to miss. Once you know where to look it’s not a big deal, but we prefer the way Roam puts backlinks at the bottom of the note.


Just like Obsidian, Roam allows you to create a ink to another page using [[pagetite]]. The big difference is the addition of the linked mentions and unlinked mentions at the bottom of your currently selected note. This may seem like a small detail, but it makes finding and creating links incredibly easy in Roam since it’s hard to miss. And the more that you use intentionally link your notes together, the more valuable your web of ideas becomes.

Roam also does a much better job handling backlinks to individual blocks. Unlike Obsidian (which uses individual text files), Roam is a database. This means that each individual block in Roam is it’s own entry in the database, and makes it much easier to link atomic note elements together. We’ll dig into this in the next section on block references, but Roam is built to make the most of this essential feature.

Winner: Roam

Another important part of the user interface is the sidebar. This can display related information to the note you’re currently editing and serve as a collecting place for related notes that you want to view together.


The sidebar in Obsidian is where much of the magic happens. It can not only show you the linked and unlinked mentions for the note you are currently editing, but can also do things like display an outline of your note broken down by header and give you quick access to your tags. You can even keep a local graph in the sidebar of linked notes that updates when you open a new note.

Using third-party plugins can extend the sidebar capabilities even further. For example, the Calendar plugin allows you to navigate a calendar view and quickly jump to Daily Notes pages for a specific date. Plugins are a whole separate section, but they can extend the capabilities of the sidebar in Obsidian in some really cool ways/


The sidebar in Roam serves a little bit of a different purpose. Instead of panes where you can choose what information you want to show, the primary role of the sidebar in Roam is to serve as a collecting place for related information. For example, hold the Shift key while you click a link and the note opens in the sidebar instead of navigating away from the note you are currently on.

Putting related notes int he sidebar also makes it easier when you want to embed a block from one note into another one. Just hold down the Option key and drag the block from the sidebar into the note in the main window and the block will be embedded automatically.

The big difference here is that the sidebar in Roam has a very specific function: to aid you in your research. The design choices about the sidebar reflect this: the sidebar is for the bits and pieces, the main window is for your active note. There is no such distinction in Obsidian, but the flexibility it gives you in designing your sidebar layout makes up for this in time. While there’s a lot to be said for Roam’s focused simplicity, when you start extending Obsidian’s capabilities using plugins the sidebar becomes an essential tool

Winner: Roam

Block Embeds/References

Occasionally, you might want to link to a specific section of a note. These fundamental building blocks of notes are called blocks, and being able to link and embed them in other notes is a powerful benefit of connected note-taking apps.


To embed something in Obsidian, you simply put an ! character before the [[pagetitle]]. This tells Obsidian that instead of just linking to the page, you want to embed it in the current location in the active note. You can take this even further by using a # to embed a specific header or ^ to embed a specific block. Using auto-complete like this make block embeds in Obsidian even easier than they are in Roam.

Linking and embedding blocks is kind of a hacky workaround in Obsidian. Since it’s based on individual text files, the way Obsidian connects to individual blocks is to add a weird identifier at the end of the block that it can use to locate it again:

This is fine for embedding blocks into other notes. Where this really falls down though is with block references.

Unfortunately, the only way to see block references is in the backlinks section in the sidebar. This isn’t a problem if you have very small (atomic) notes in your Obsidian vault, but it gets tricky if you have longer notes with lots of blocks you’d like to reference in other notes. Instead of quickly being able to find the few notes that reference a specific block in a list, you have to comb through all the links to the entire page.

This is Obsidian’s achilee’s heel, and forces you to keep a large number of short notes in your vault instead of a small number of large notes. You can work around it, but it’s annoying.


Block embeds and references in Roam are easy. Because everything in Roam is stored in a database, there is no distinction between individual notes and blocks and everything can be broken down into more atomic units.

You can use a block reference in Roam by:

  • Using (( and searching your database for the block you want to link
  • Right-clicking on a block and selecting Copy Block Reference
  • Dragging a block from a note in your sidebar into the main note window

Because Roam converts text to preview the moment you deselect the line, a block reference in Roam looks very much like a block embed in Obsidian. It shows you the contents of the original block, but if you go back to the original block you will also see a number to the right of the block. This indicates the number of references to the block in your entire Roam Research database, and clicking on it will show all references in line:

This is incredibly useful, and a major reason to choose Roam Research for your PKM needs. The more you use block references like this, the more powerful you realize this feature is.

Block Embeds in Roam are also better than they are in Obsidian, allowing you created a linked copy of the block in the current note. The difference here is that instead of merely pointing back to the original block and displaying the contents, a block embed allows you to edit the contents of the block right in your new note. When you do, the original block (and all other embedded copies of the block) are updated as well.

Winner: Roam

Markdown Support

Both apps support Markdown formatting in plain text. This allows you to style your text (for example, for publishing to the web), but means your plain text notes are compatible with any text editor on the planet.


Obsidian is simply an interface for plain text files that are stored on your computer, and supports standard Markdown formatting. Many themes will have syntax highlighting to make it easier to see your Markdown-formatted text, but the Markdown that Obsidian supports will be viewable in any other text editor.

This is unremarkable, but the way it should be.


Roam, on the other hand, supports a weird flavor of Markdown. Most of it will be familiar (i.e. # for headers, bulleted lists, etc.), but it also inexplicably changes some very familiar Markdown formatting. For example, standard Markdown lets you use ** (or __) for bold and * (or _) for italic formatting. But in Roam, you have to use ** for bold and __ for italic. This goes directly against the standard Markdown convention of double characters for bold text and single for italic.

I don’t understand why the Roam team made this choice. You can argue that you’ll just get used to it, but not if you do writing in any other plain text editors that support standard Markdown formatting. This is inexcusable, and a dealbreaker for many.

Winner: Obsidian


Search used to be the only practical way to surface your notes after you had captured them. This has changed with the advent of bidirectional linking in connected note-taking apps, but search is still useful when you need to locate something specific. In addition, queries can help you comb through your entire database of notes quickly and easily return notes that match certain criteria, like tasks due on a certain date or articles that are currently in progress.


After spending some time using search and queries in both apps, I have toa dmit that search in Obsidian feel secondary. It lets you search your library using criteria like path:, file:, and tag:. You can also combine search modifiers to quickly find the needle in the digital haystack.

It feels very much like a standard boolean search, but doesn’t do a great job of showing the context of your search results. You can embed a search or query in a note, but the annoyances with displaying note context make this… not great.


Roam’s minimal interface has a search bar at the top to help you quickly find anything you might be looking for, but the real magic happens with Roam’s Queries. Queries require a specific formatting to be used, but are incredibly powerful because they embed the blocks that match your criteria in the page. For example, a simple query that return everything with a tag of #Quote looks something like this:

In addition to search and queries, Roam also has Filters that can limit what data you see when looking at your note. Click the funnel icon and you can choose what you want to include or remove using the filter.

Winner: Roam

Daily Notes

Both Obsidian and Roam have support fora feature called Daily Notes. Daily Notes are the digital equivalent of the Bullet Journal’s daily page, serving as a place to capture bits and pieces of information before you process them and decide where they belong.


If you open a fresh install of Obsidian, you won’t see the Daily Notes feature as it’s not on by default. It must be enabled by going to Settings –> Core Plugins and toggling on Daily Notes. This is both an advantage and a disadvantage, as it’s not on by default but also allows you to limit the features you don’t use to keep Obsidian from getting unwieldy.

Once you have Daily Notes enabled, an icon will appear on the left sidebar that you can click to go straight to today’s Daily Note:

This opens up today’s daily note, and you can capture text that gets linked to that specific date.

And out of the box, that’s all it does. But with the addition of other plugins, Daily Notes can get a lot more powerful.

For example, the Calendar plugin gives you a monthly calendar view that you can use to jump to a specific date (either past or in the future). You can also use the templates feature (another Core Plugin) to auto-populate your new daily notes with text templates, like I do for journaling.

The big limitation with Obsidian’s Daily Notes is in the way it surfaces tasks (or rather doesn’t). We look at tasks in another section, but Daily Notes are an important piece to task management and it’s a little bit lacking in Obsidian. You can link tasks to a specific date, but because they aren’t displayed in the main note it’s very easy to miss them.


Daily Notes are a very important part of the Roam Research experience. In fact, the app opens straight to your Daily Notes page for today when you log in.

With Roam, there is a specific workflow you are guided into:

  1. capture things on your daily notes page
  2. embed/reference them somewhere else later

The way Roam handles queries and block references/embeds, the focus is clearly on just capturing things to your Daily Notes page - not on deciding which note they belong with. You can easily do that after the fact using the sidebar, or not at all if you prefer and just surface things using queries. This makes for some very interesting journaling workflows.

By opening to today’s daily note, Roam also makes it a better option for managing tasks than Obsidian. In addition to showing linked tasks (the ones due that day) on the main note in the linked mentions section, it also shows that day first thing when you open the app so you don’t miss them. Of course, that still assumes you are opening the app every day.

Winner: Roam


Plain text task management is nothing new. But bidirectional linking opens up some interesting new possibilities, like a digital bullet journal or being able to link directly to the article you’re writing in the same application.


You can create a task in Obsidian by using the - [ ] formatting, which makes it possible to check off the task as complete in Preview Mode.

You can also link a task to a specific date using the [[pagetitle]] syntax. Just insert the name of the daily note you want to link the task to, and the task will show up in the linked mentions on that date. It’s not great, but it works.

Unfortunately, tasks don’t feel like they belong in Obsidian. But there are lots of third-party plugins that try to fix this in lots of different ways, like:

  • the Slated plugin which adds a bunch of additional features to task management in Obsidian
  • the Todoist plugin that allows you to embed tasks from Todoist using filters
  • the Kanban plugin which allows you to create cards for your tasks and link to pages from the card titles

But the vanilla Obsidian app leaves a lot to be desired.


Roam seems to be built with task management in mind. From any block, you can use the keyboard shortcut Command + Enter to cycle between a todo, a completed todo, and a plain text block. You can also use the slash command in the block to quickly access the date picker and select a due date for the task, which creates a page link to that day’s daily note in Roam:

From here, surfacing your tasks when they are due is easy. Roam opens to today’s daily note by default, and your tasks that are due are surfaced in the linked mentions section at the bottom of the main note window.

You can also use tags and Roam’s powerful queries to cobble together your own GTD-style task management system in Roam.

It’s still not as nice as a dedicated task management app like Things, but if you have only basic task management needs or want to link your tasks to the documents you’re working on, Roam is a decent option.

Winner: Roam


Both apps can do a lot out of the box, but you may want to customize the app you use to fit your specific workflow. With a few tweaks, you can turn your note-taking app into a productivity powerhouse.


Obsidian ships with standard feature set, but it is easily expandable using plugins. There are two kines of plugins:

  • Core plugins, which ship with the app
  • Community plugins, which are developed by third-parties and installable via a public directory

As of this writing, the Obsidian API is not officially released (at least per the public development roadmap). But it’s still amazing what you can do currently with community plugins. There are currently 178 plugins listed in the directory, which can do things like:

  • Push a backup of your entire vault to GitHub
  • Create editable kanban boards
  • Automatically log completed tasks from Things
  • Use natural language for dates
  • much, much more

It’s impossible to overstate how awesome plugins are in Obsidian. Some of the functionality third-party developers have been able to add is astounding. It takes some trial and error to figure out which ones will fit for you, but the quality is great and the directory keeps getting bigger.


Roam doesn’t have plugin like Obsidian, but you can embed scripts and code directly into Roam to extend it’s capability. One of the most popular Roam “extensions” is called Roam42. Roam 42 gives you a lot of extra stuff Roam doesn’t support by default, like:

  • SmartBlocks workflows to use your text in some pretty incredible ways
  • deep navigation using the keyboard
  • natural language processing for dates

To “install” code snippets like Roam42, you copy a script and embed it in a code block in your database. There are obviously some security risks inherent with this, but it’s currently the only way to extend Roam’s capabilities.

Winner: Obsidian (by a landslide)


In addition to extending functionality, you can also customize the look and feel of each app using themes. These themes are built using CSS, which means you have the ability to tweak them exactly the way you want - with a little bit of web development knowledge.


Installing themes in Obsidian is incredibly easy. You can actually access a public directory of themes right from the app by going to Settings –> Appearance –> Community Themes. You can select a theme to install it, or preview any of the themes in the directory if you’re not quite sure.

All of the themes that you download are kept in a hidden folder on your computer, and you can edit the CSS directly in a text editor like SublimeText or BBEdit.

You can also create your own CSS Snippets that can be toggled on or off from Settings –> Appearance. But there are a lot of great themes that also have an associated plugin that allow you to tweak the visual settings without touching any actual code.


Roam doesn’t have a public directory of themes you can access directly from the app, but it does allow you to make the same kind of changes by pasing a CSS code block on your roam/css page.

You can have many of these code snippets active at once, which can cause conflicts if you’re not sure which ones are enabled (you way you turn them off is to switch the code snippet from CSS to Clojure). But if you want to tweak any of these settings yourself, you’re going to have to know your way around CSS.

Winner: Obsidian

Data Portability

The beauty of plain text is that it is timeless, giving you access to your notes on any platform and any device. By keeping your notes in plain text, you ensure future compatibility should you decide to switch apps down the road.


Obsidian as an application sits on top local files stored on your computer. The files themselves are not imported into Obsidian, they are simply opened and viewed there. That means that if you ever decide to stop using Obsidian, what you are left with is a bunch of local plain text files. While some features in Obsidian may use special formatting, the foundation of your notes documents is standard Markdown that can be opened and edited in any other plain text editor.

In terms of futureproofing, it doesn’t get any safer than this.


Roam also uses plain text, but stores it in a proprietary database format. You can export your data from Roam as either separate Markdown files or a single JSON file, but while your data is in Roam it is still in a proprietary format.

I’ve personally used Roam’s export feature and it worked fine. There’s no reason to think you won’t be able to get your notes out of Roam if decide to switch connected note-taking apps, but recognize that there is an additional step involved and it isn’t as simple as it is in Obsidian.

Winner: Obsidian


Occasionally, you may want to share your notes with someone directly. Publishing your notes allows you to send a public link to someone so they can access them directly via a web browser.


Obsidian has an add-on service called Publish that you can buy directly from the developers. It is currently $8/month per site (billed annually), and allows you to publish your notes directly to the web. The service gives you a publish.obsidian.md site, but you can also use a custom domain if you want.

The site itself displays the notes that you choose to publish, alongside the local graph view of the currently selected note. You can even password protect your site if you want to control who has access to it.

This is pretty brilliant way to monetize the application without charging people for features if they don’t need them.

One note: you can’t publish directly to a Wordpress site from Obsidian like you can from Ulysses, but the standard Markdown formatting means it is easy to copy and paste your text when you’re done writing in Obsidian.


Sharing notes in Roam is a little more complicated.

First, you need to understand that data in Roam is not end-to-end encrypted (more on this later). That might not be such a big deal, except that when you share a note in Roan, all of the data in your entire graph gets loaded in your visitor’s browser. There’s even a warning if you toggle on the setting for sharing individual pages:

The alternative is to make your entire graph public, but if you keep notes on things you don’t want to share with the world you’ll need to keep that info in a separate graph (meaning it’s unlinkable from the graph that you share).

Like Obsidian, Roam also doesn’t have a way to publish directly to Wordpress. But it also doesn’t use standard Markdown, which means you can’t simply copy and paste either. It seems like the Roam team is focused on developing more multi-user features, but at the moment it’s not a great publishing or sharing platform for most people.

Winner: Obsidian

Data Security

Your notes should be private unless you decide to share them. Plain and simple.


If you’re concerned about the security of your notes, Obsidian is the obvious choice for a couple of reasons.

First, all your notes in Obsidian are really just text files that are stored locally on your computer. They’re not shared publicly anywhere by default unless your vault is located in a shared folder like Dropbox or iCloud Drive.

Second, the Obsidian Sync service (another add-on which currently costs $4/month, paid annually) is end-to-end encrypted. Whatever data you decide to send to the Obsidian servers is encrypted from the moment it leaves you hard drive to the moment you download it on a new device.

It’s also important to note that you don’t need to use Obsidian’s Sync service. But it is the best way to sync data if you’re going to use the Obsidian mobile app.


With Roam Research, everything is stored on their servers. There’s also no two-factor authentication for logging in, and no end-to-end encryption of your stored data.

For some, that’s not a big deal. If someone wants to steal my sermon notes, I don’t really care. But if you store sensitive information in your notes, Roam’s “security by obscurity” is not going to be enough.

Winner: Obsidian

Mobile Experience

While the computer is the primary place to interact with your notes with both of these apps, occasionally you may want to access your notes on the go.


As mentioned above, Obsidian sits on top of plain text files on your computer. Which means the way you can access your notes on your iOS devices is fairly limited (at least until the iOS app is officially released).

One easy way to see and edit your notes on the go is to keep your notes in a cloud folder and access them via an iOS text editor. For example, I keep my vault in my Dropbox folder, which allows me to access my notes in apps like 1Writer. Because Dropbox sync is so solid, any changes are instantly sent back to my Mac and instantly show up in Obsidian.

There is also an iOS app in development, but it is currently in closed beta as of this writing. It’s amazingly functional and very solid for such a young app, but early signs indicate this could be a very pleasant iOS experience for Obsidian users - assuming that they are willing to pay for Obsidian Sync to keep their vault up-to-date between their different devices.


Roam Research is not made for mobile access. Plain and simple. There is no mobile app for Roam, and the full site in a mobile browser is not a pleasant experience.

Roam does have a mobile stylesheet that changes the main page from the standard Daily Notes page to a Quick Capture page. Quick Capture lets you jot down text, todos, links, and images and add them as blocks directly to your Daily Notes pages so you can process them when you get back to your computer. You can choose the graph you want and select the page you want to add the block to, but it’s really just for capturing things on the go.

Bottom line: if you want to access your notes from your iPhone, Roam isn’t a great option.

Winner: Obsidian


While we all love a good deal, ultimately you want to make sure that the connected note-taker you decide to use has a clear business model that can support future development. And of course, the price you pay must be reflective of the value that you get form using the application itself.


Obsidian’s pricing model is very interesting.

The app itself is actually free for personal use. You can download the app, point it at your notes stored locally on your device, and use it forever without paying a dime. That would normally make us a little nervous, but Obsidian has a very clear monetization strategy by offering add-ons for purchase.

There are currently two different add-ons available for Obsidian:

  • Publish, which allows you to share your notes publicly via the web for $8/month (current pricing, paid annually)
  • Sync,which allows you to access your vault on your mobile devices and includes 1 year of revision history for $4/month (current pricing, paid annually)

Both of these services are well implemented, and allow users who need them to support Obsidian’s development. Note that these add-ons are not the same as the plugins mentioned earlier, which are accessible in the free version. And if you don’t need Sync or Publish but just want to support the Obsidian team, you can do that as well via the web.


Let’s get this out of the way: Roam is really expensive.

There is no free version of Roam, and pricing begins at $15/month for the “Pro” version. If you decide to pay yearly it’s $165, and there is a “Believer” plan that is $500 for 5 years. The Pro version includes a 30 day free trial (you get charged on day 31), but it’s a pretty big investment. By comparison, if you signed up for both the Sync and Publish add-ons using current pricing, you’d be paying $144/year for Obsidian.

It’s hard to make a blanket statement about whether Roam’s hefty price tag is worth it. If you’re all in with Roam it probably is. But if you’re just getting started with connected note-taking and dipping your toes in the PKM waters, it’s hard to justify.

Winner: Obsidian

Note-Taking vs. Note-Making

I’ve been thinking a lot about Personal Knowledge Management lately and the path information takes as it enter and exits my PKM system. For a primer on PKM, check out Intro to Personal Knowledge Management. And I’ve noticed that information tends to fall into one of three buckets:

  1. Things I may need to reference
  2. Tasks I will need to do
  3. Ideas I want to develop

The first two are pretty straightforward - I simply capture those into the appropriate bucket. For a long time, I used Evernote as my reference file and OmniFocus as my task list. But when COVID-19 happened and I reworked my system, I found a lot of value in having everything in one place. So now, I keep reference material and tasks in the same bucket as the ideas I want to develop. This has a lot of benefits, but I’ve also discovered I can’t treat all my notes the same. I have a separate, more active system for developing my ideas. It’s quite a bit more involved, but I believe it’s worth it.

In this article, I want to consider the difference between my old note-taking workflow and the note-making that helps me so much in the creative process.

What is Note-Making?

I first heard the term note-making from Nick Milo, who has an excellent YouTube channel called Linking Your Thinking. (He also runs an excellent workshop that I have gone through as a paying customer.) ALso check out Nick Milo’s Mindfulness Monday Interview.

The basic idea of note-making is that you don’t simply just capture your notes and dump them in a library somewhere. Instead, you work on your notes and update them over time. Instead of simply taking notes, you are crafting them. Your approach is like that of a skilled craftsman, who knows that within the chunk of wood or stone lies a beautiful carving. You can’t see it at the beginning, but as you continue to refine the material you’re working with, you start to see it come through.

To the note-making craftsman, a tool like Obsidian is more of a workbench than a filing cabinet. It’s not a place where you hold things until you need them; it’s a place where a magical transformation happens. It’s where you work your craft and refine your ideas as you turn them into something special worth sharing.

The end result is something that reflects your current thinking on a topic, comprised of useful facts and information as well as your own opinions on the topic. Something much more beautiful than simply a captured note. Nick calls this type of note a Map of Content (or MOC), and describes your role in crafting it as that of a cartographer.

This analogy immediately resonated with me as I had just finished reading The Great Mental Models, Volume 1 where one of the models described is The Map is Not the Territory. You see, whenever you see a map, what are you actually seeing is an opinionated interpretation of what the map maker (cartographer) considered important enough to include. There’s no way you can include all the information in a map, so the cartographer is forced to make decisions about what’s important, and what’s not.

As you collect notes on a topic, you will eventually get to a point where you feel overwhelmed by everything you’ve collected. That is the point where you assume the cartographer role and go back to your workbench (MOC) as you craft your thoughts via intentional note-making.

Let me give you an example of an MOC from my own Obsidian vault.

This is my MOC on the topic of habits:

In this note, there are several things:

  • A note at the top as to why this MOC exists
  • A section on the standard habit loop (and image) presented by Charles Duhigg in The Power of Habit
  • An opinion about why I don’t like this definition
  • A section on James Clear’s 4 Laws of Behavior Change from Atomic Habits and why I like this better
  • A section on BJ Fogg’s Behavior Model (and accompanying chart) from Tiny Habits
  • A section with some links to additional resources/notes that speak to this topic
  • A section on Bible verses that speak to the topic of habits

Every time I add a note to Obsidian about habits, I look at this MOC and see what I want to add or update. As a result, this note is in constant development and continues to get better and better over time. And I’ve found that as I force myself to make this note better every time I touch it, my thoughts on the topic continue to gain clarity. The process of forcing my self to add opinion notes and decide what’s important helps me to better understand the topic.

Note-Making vs. Note-Taking

As I consider my new note-making workflow with the traditional note-taking practice, I notice there are several important differences.

First, note-making assumes that your notes are living things. While note-taking, captured notes are static and never change. But with note-taking, your notes are dynamic, and are constantly being updated and refreshed.

As a result, note-making means your notes are never etched in stone. With note-taking, your notes are finished when they are captured and added to your library. They are there so you can find them if you need them, but they aren’t really doing anything while they sit in storage. With note-making, you’re notes are in active development. Each note you make is a reflection of the sum total of notes you’ve collected, and the value is in the relation to your other notes.

With note-making, relationships are important. Note-taking focuses solely on the content of the active note, but note-making considers the connections to other notes. Note-making recognizes the fact that each note is influenced by the other notes in your library, and takes into consideration the value of previous thoughts and ideas.

The fundamental approach to your notes is completely different with note-making. Instead of trying to collect everything that you think might be useful someday, you’re focused on understanding as much as you can from the ideas that you already have.

I talked with David Sparks about this on a recent episode of Focused, and he described the difference in mindset as the dragon and the jeweler. The dragon tries to horde things and sits on top of the diamonds so no one else can get them. But the jeweler is actively working on his diamond so he can make it even better. The dragon may accumulate a lot, but doesn’t do anything with it. The jeweler is the one who is getting the real value from working with what he/she already has.

A Couple Tips for Making Note-Making a Habit

Here’s a couple of quick tips I’ve learned about note-making over the past several months that could help you develop a jeweler’s mindset and find more diamonds.

More Signal, Less Noise

I’ve intentionally set up my note capturing system so that it doesn’t just automatically add everything to my Obsidian vault. I capture notes in two places:

  1. My fancy notebook
  2. Drafts on my iPhone (and occasionally Apple Watch)

At the end of the day, I transfer things over as part of my shutdown routine. This forces me to manually add the notes that I capture to Obsidian, and adds another review step where I can filter out any notes that I don’t really want.

The key here is that I am a ruthless about cutting things here. I estimate about 4 out of every 5 things I capture never makes the cut and gets transferred to Obsidian.

The more distance I get between the moment I capture my idea, usually the less excited I am about it. Every idea seems great when you have it, but not every idea is a good one. By making myself wait, I increase the quality of the ideas that actually end up being developed in Obsidian.

Which is really the key. I’d rather 5 really great ideas than 500 mediocre ones. When it comes to ideas, quality beats quantity.

As your notes library grows, resist the urge to link everything. Bidirectional linking is a really powerful concept, but loses value if it’s overused. For example, if I have a note called “Habits”, My Unlinked Mentions will show me every use of the the word “habits” in my entire vault. You can turn any of these into a Linked Mention by clicking the Link button, but resist the urge to do so! You don’t want every mention of the term “habits” to show up, you want only the best ones.

I wrote recently about the power of Obsidian’s local graph and how I use it to navigate my notes, but if every page has 100 linked mentions it’s difficult to see which ones really matter. Just like the notes themselves, you want quality over quantity here.

Don’t Judge Your Work

As you see examples of others work, don’t compare the results of your note-making practice with anyone else. Your notes are a reflection of your personal journey. Your Habits MOC may look completely different than mine, and that’s the point! Add your own opinions and don’t try to be someone else. The more authentically you that your notes are, the more value they have.

If you’re unhappy with the output, then change the input. Your brain is always connecting things, so the place to make improvements is to give it better dots to connect. But remember, quality matters more than quantity. Read more books, but don’t try to recreate every argument the author makes. Capture the things that stand out to you, then spend some time thinking about them and figure out how and why they matter.

Automate Your Review

Note-making requires that you look at your notes frequently. I do this as I process my notes in Obsidian, but I still find some of my MOCs don’t get much TLC. So recently I installed the Review plugin

One thing that makes reviewing and updating notes easier is the Review plugin. (You can also install this in Obsidian by going to the Settings, clicking Community Plugins, and browsing for Review.) Once installed, you can access the Command Palette by using the keyboard shortcut Command - P and selecting the Add this note to daily note for review option. Select date (the Natural Language Dates plugin allows you to use terms like tomorrow, next week, etc.) and a Review section will be added to that daily note with a link to your current note. Then when you go to your daily note on that future date, you can just click the link to review your note and make any necessary changes.

Meeting Notes in Obsidian

Obsidian is a great place to keep meeting notes. But there are a couple of best practices, which can make your meeting notes more effective. In this article, we walk you through setting up a meeting notes template and how to use it in Obsidian.

Setting Up the Meeting Notes Template

Creating a template makes it much easier to take meeting notes. This template is simply a note in my Obsidian vault. Here’s the meeting notes template I use:

This template has 4 sections:

  • A date token at the top
  • An Attendees section
  • An Agenda section
  • An Action items section

Each section is separated as a second-level header, except for the metadata at the top.

The date token in the curly brackets tells Obsidian to insert a date stamp using the YYYY-MM-DD format, and the double brackets link that date to the daily note for the day.

Once you have your template file the way you want it, the next step is to set up the Templates plugin.

Setting Up the Templates Plugin

First, click on the Settings button in the left sidebar.

Select Core Plugins, and make sure Templates is toggled on.

Next, go to the setting for the Templates plugin and make sure that it is pointing at the folder where you have your Meeting Notes template stored.

Once you have the plugin enabled and pointing at your templates directory, we’re ready to use the template we created.

Using the Template

To use the template, you first need to create a new blank note. Give your note a title, and then hit Command-P to access the Command Palette. From the Command Palette. select the Template: Insert template option.

If you pointed the Templates plugin at the right folder, you should see all the files in that folder appear as template options.

Select your meeting notes template and hit Enter. The empty note populates with the contents of your template file. The date token is converted to today’s date, and each of your sections is created.

Meeting Notes Tips

I like to link the attendees to the meeting notes by including their names in the Attendees section in double-brackets. This links the meeting notes file and the person via the Local Graph.

I also use double brackets to create internal links to important agenda items. For example, if we’re talking about a project, I’ll use double brackets to link to the project name.

You can also use Obsidian’s Markdown-based task syntax to track action items. Just use a - [ ] before the task name and it will render as a clickable box in Preview mode.

You can also link those tasks to a specific person or date by adding either inside of double brackets as well.

Nick Milo's Mindfulness Monday Interview

In this Mindfulness Monday post, Nick Milo of Linking Your Thinking joins us to talk about note-making, idea emergence, the hold of the screen, and breaking free of rigid systems

Meet Nick Milo

Nick Milo is the creator of the Linking Your Thinking YouTube Channel, where he makes a lot of helpful videos about using Obsidian as a thinking tool and Personal Knowledge Management in general . He also hosts a phenomenal community-driven workshop where he helps people craft their own custom PKM system.

I first discovered Nick when I went through the workshop myself, and it was the first time that Obsidian really clicked for me. His explanation of idea emergence in particular was a big help as I was trying to wrap my head around how I was going to use Obsidian.

Over the last several months as I’ve gotten to know Nick, I’ve continually been impressed with his perspective on idea development. I’ve learned a lot from him about knowledge management, and am thrilled that he agreed to share about his own mindful approach to technology use.

What sort of boundaries or intentional constraints (i.e. rules) have you set up around how you use your technology?

In an age where The Screen dominates, it’s easier than ever to live in a perpetual state of distraction. That won’t surprise this audience. In the age “Before Screen” (BS), our default was to walk around, to daydream, and to talk with people. Now, After Screen (AS), the default is to fall from one distraction to the next. So we have to define our own intentional constraints if we want to get the best out of The Screen, without falling into it.

My constraints take the form of whispers in the back of my mind that say things like:

  • Just because you can, doesn’t mean you should.
  • How are you being manipulated right now?
  • What is your environment doing to you right now?

That does two things: it makes me aware, and gets me peeved. I think getting peeved is a good thing in this context because it gives me enough of a kick in the butt to break The Screen’s powerful hold over me.

What does your phone home screen look like? How has the application of your intentional constraints shaped what shows up here?

Nothing special here. I try not to use my phone much. Honestly, it kinda feels wrong…hunching over, working inefficiently when I have a keyboard and mouse nearby. I mainly browse with Firefox, check email with Gmail, sometimes check the chats, watch Youtube vids at night, and now also jump into the Obsidian app at night. So my main constraint is just not using it.

As you apply intentionality to your use of technology, what are some examples of what you consider to be net positive technology uses?

Without a doubt, note-making in Obsidian is my favorite net positive technology use.

Plainly speaking, that means I type out things that mean something to me in a bunch of different notes and make links between those notes, which leads me to re-write (refactor) those same notes into something that some people might call some form of wisdom.

I think this is the most valuable use of technology for about a million reasons, but I’ll only pick three for now: note-making helps you create “value” in the world, it forces you to do critical and creative thinking, and it coaxes you into a state of Flow.

What was your tipping point — the moment when you decided you needed to do something about your technology defaults?

Growing up in Montana, it was easy to not get lost in technology because it was too easy to get lost in Nature. So moving to NYC was a radical break from that. The streets were littered with people walking with their heads down buried in their phones. It felt like some alternative reality.

I tried it. It tried to look at my phone while walking, but I would immediately notice my levels of anxiety start to creep upward. When I put my phone back in my pocket, my intuitive anxiety meter would go back down to natural levels.

Why was everybody else seemingly not concerned about this?!

The tipping point was at the HBO offices where I used to work, specifically in the fitness center where this guy spent an hour every day on the elliptical treadmill with his back hunched and neck cranked to the extreme just so he could stare at his phone. That guy thought he was getting healthier but I just saw his body getting sicker and more contorted over time.

Years later and it still angers me, even though I don’t really know what I’m even mad at! I just know that I have taken a personal vow to never become like that guy on the treadmill.

As you’ve changed your technology habits, what are some of the things you’ve had to learn to work around or live without?

I’ve had to allow myself the freedom to stop trying to track and manage every tiny task and project. My efforts always led to an entire breakdown in the system, where I would abandon the system and feel bad about it. But what if I wasn’t the problem?

What if the problem was believing some rigid digital system—that required high-maintenance —was ever going to be a good solution in the first place? It wasn’t. It was always bound to fail (at least for me).

Plus, it cut me off from using my intuition and instincts to rapidly adjust to new information. Rigid systems to manage yourself fall apart under new stressors. So now I don’t have an actual project management system; I don’t use any special software to manage projects, and I’m getting a tremendous amount of stuff done. It’s counter-intuitive maybe, but it’s very liberating.

What app (or service) has the strongest pull towards getting you to go back to the way things were? And how do you deal with it?

Discord or Twitter and even YouTube at times. I don’t know how I deal with it really. I guess there comes a point where it starts to feel bad. Then, if my energy levels are normal, I’ll just stop doing it. If my energy levels are so low and my distractability is high, then I’ll re-prompt myself with those questions from the top: “how are you being manipulated right now?” Then I get peeved enough to get up and change my environment ASAP.

How has implementing boundaries or intentional constraints positively impacted your life?

One of the best things I ever did with my relationship to knowledge was defining it.

There is an exponentially growing amount of information available to each of us. That used to fill me with dread because I thought I would always feel inadequate in my knowledge. But then the opposite happened. Instead of worrying about the Noise, I focused on my Signal: the things that really resonated with me.

Defining what the Signal was for me made it okay to stop worrying about the Noise.

How has your approach to Personal Knowledge Management (PKM) influenced your intentional technology use?

It’s taken me out of the rat race. I’m no longer addicted to shiny new apps “just because”. I’m now constantly a version behind every new Mac OS release. I don’t care that Apple gave one of their apps some silly shiny feature that I’ll use once and then never use again. I don’t care about the shiny stuff because I care so deeply about my signal. And when you have a clear signal, all that noise is no longer enticing —it’s annoying.

And then—and this is getting philosophical—once you get out of the Noise and hone in on your Signal…you recognize “Knowledge” isn’t static and it’s not meant to just be consumed. Instead, you can interact with it, develop your opinions about it, and make personally meaningful insights around it. What a soul-nourishing endeavor that is!

What are the apps/devices that use to manage the different areas of your PKM system?

My main apps: Obsidian, Firefox, Gmail, Fantastical, Drafts, and Dropbox.

Do you have any guidelines/rules for what comes on or goes out of your PKM system?

Yes. I practice what I call “Radical Idea Emergence.” Basically, if I forget something, that means it wasn’t important enough to remember. But if I keep re-remembering something, then I recognize its importance and I externalize it in my PKM system (digitally write it down) so I can better think and build with it. I could go on, but in short: I don’t over-collect because I have faith that the good ideas find a way; they will earn a place at the table.

What’s your best advice for the person who is trying to change how they use their technology to be more intentional?

I have made it an unconscious habit to ask three questions when something doesn’t feel right:

  1. What is your relationship to knowledge right now? (Are you even aware of what it is?)
  2. How are you being manipulated right now? (Are you okay with that?)
  3. What is your environment doing to you right now? (How is it shaping you?)

If you ask those questions, you can’t help but recognize when something is off, and you’ll have the zest and perspective you need to do something about it.

Mike's Obsidian-Based Writing Workflow

I’ve been using Obsidian as my writing app for the past several months, and I absolutely love it. In addition to giving me a great Markdown writing environment, the community plugins allow me to craft my ideal system for tracking my writing tasks well. In this article, I walk through my system and the plugins I use to manage writing projects in Obsidian.

Here’s a video from our upcoming PKM & Obsidian course that walks through my entire process.


There are two specific plugins that make this work for me:

  1. The Kanban plugin
  2. The Dataview plugin

(For more info on using the Dataview plugin, see YAML & Dataview.)

The Kanban Plugin

To install the kanban plugin, first click on the Settings button in the left sidebar.


Next, click on Community Plugins and search for Kanban.


Click the Install button, then click enable. Make sure that the plugin is toggled on by going back to the Community Plugins section in the settings.


Next, you need to create your kanban board. To create a new Kanban board view, all you need to do is right-click in a folder and then select New Kanban board.


Once you have the board set up, you need to add some categories. Click the Add a list button to create a new swim lane and give it a name.

I use three separate lists: ToDo, Doing, and Done. I also toggle on the option to Mark items in this list as complete for the Done column.


Next I add cards for the articles I’m working on. Click Add a card to create a new todo in that column, and give the card a name. I always create the blank note first in my Articles folder and link to the note using double brackets.


Then I can move the card from left to right by dragging it to the appropriate column. And behind it all is a simple Markdown-formatted text file.



I also add some YAML metadata to the top of every article which includes the status and document tags. I’m playing around with different ways to use the status currently, but one thing I like is the ability to use a status and filter everything in my Articles folder by that staus using the Dataview plugin.

Just like the Kanban plugin, Dataview is a third-party plugin. So click the Settings buttone, go to Community Plugins, and serach for Dataview.


Install and enable the plugin, and you’re ready to go.

For example, I have a note in my library called Articles Status. It’s a blank note that filters all the notes in my Articles and displays them in a list view by status in the YAML metadata.

Here’s the code I use:

table Status
from "Articles"

Here’s what this code is doing:

  • The first line tells Obsidian to use the Dataview plugin
  • The second line tells it to make a table with a Status column
  • The third line tells it to look in the Articles folder
  • The last line closes the code block

When I click on Preview, here’s what it looks like:


I have the names of all of the articles that are currently in my articles folder on the left, which are links that I can use to jump straight to those articles. And I have the status fields, indicated by those things that I marked in the YAML frontmatter, which aren’t actually part of the article. But Dataview is taking those and it is sorting them in reverse alphabetical order, which allows me to see very quickly which articles I’ve completed, which ones I’ve not started and which ones are in progress. And if I wanted, I could add more to this to sort these in a specific order.

This is a simple example, and you can extend this obviously a lot further if you wanted to include due dates and things like that. But Dataview is a great way to query everything that you want to look at in a specific location, and then give you all sorts of information based on that.

Journaling in Obsidian with QuickAdd

Obsidian is a great place to do your digital journaling, thanks to the daily notes core plugin. But with the addition of the quick add community plugin, you can quickly capture journal entries into specific categories using the command palette.

(If you’re looking for the Daily Questions part of my journaling workflow, check out Daily Questions in Obsidian.)

Setting Up the Daily Notes

First, we need to make sure that Daily Notes core plugin is in fact toggled on. To access the Settings, click on the gear icon in the lower left.

Next, click on Core Plugins and make sure that Daily Notes plugin is toggled on.

Next, go to the sidebar of the settings and scroll down to the Daily Notes section. Here you can configure the new file location which tells Obsidian where to store the new Daily Notes files and the location of your template file.

I have this set to capture new Daily Notes to a Daily Notes folder using my Journaling template inside of my Templates directory. This will take the contents of that file and insert it into the new Daily Note when I create it. So let’s close our settings, and take a look at our journaling template.

I have three different sections here:

  • one for learnings,
  • one for journal entries, and
  • one for gratitude.

So when I click on the new Daily Notes button over here on the left, those three sections will automatically be added to today’s Daily Note.

Once we have our Daily Notes configured, we’re ready to set up QuickAdd plugin.

Setting Up the QuickAdd Plugin

Go back to the Settings, select Community plugins, and click Browse.

Next, search for QuickAdd.

Click Install, then click Enable.

Once we’ve installed and enabled the plug in, go over to the left and scroll down to the QuickAdd settings. QuickAdd can do a lot of different things, but we’re going to be using it to quickly capture text that we want to add to specific sections in our journal. So let’s create a section here for Learnings. And instead of a template, we’re going to select Capture, then click Add choice.

Now click on the gear icon for the Learnings action that we just created and configure the settings.

First we can set what file we want to capture this information to we can choose either the active file or a specific file. Capturing to a specific file allows us to capture to the file from anywhere in Obsidian, so that’s what we’ll use (Daily Notes/{{DATE:gggg-MM-DD}}.md)

This selects the Daily Notes folder, uses a date token to insert today’s date, and adds a .md for the file extension.

This will translate to the same date format we use for our Daily Note.

Next, scroll down and select Insert after and add ## Learnings to insert our added text after the second level header for Learnings.

Next, we need to put in the value for what we want to capture. So toggle on Capture format and then use - {{VALUE}} #journal/learnings \n.

This will create a bullet point with the captured text, then automatically add the tag journal/learnings and then create a new line.

We can repeat this process for the other sections, resulting in 3 different QuickAdd entries. And we can enable these directly from the Command Palette (without having to launch QuickAdd first) by clicking on the lightning bolt icons. next to the choices we want to enable.

Using QuickAdd

Now from anywhere in Obsidian, we can hit Command - P to invoke the Command Palette, search for QuickAdd, and to select the one that we want to use (i.e. Entry)

Then we just type out our text, hit Enter, and the text that we just typed gets pasted into the appropriate section in our Daily Note.

QuickAdd also works on the mobile version of Obsidian, which is great way to journal from my iPhone at the end of the day.