Get AI summaries of any video or article — Sign up free
Obsidian for non-coders (no plugins) thumbnail

Obsidian for non-coders (no plugins)

Nicole van der Hoeven·
5 min read

Based on Nicole van der Hoeven's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Obsidian’s “no-coding” workflow still depends on a small Markdown toolkit: headings, links, and basic formatting shortcuts.

Briefing

Obsidian can be used effectively without writing any code, but the real unlock comes from learning a small set of Markdown syntax rules for formatting and for pulling information back out. The core message is practical: even “non-coders” can make notes readable, linkable, and searchable by mastering headings, links, embeds, and a handful of formatting shortcuts—then using Obsidian’s built-in search and query embedding to turn scattered notes into a navigable system.

Markdown drives most of the formatting. Headings are created with hash symbols followed by a space: one hash for the largest heading, two hashes for the next level, and so on. Links inside Obsidian use double square brackets with the target note’s filename; selecting the note name creates a clickable reference, and holding Command (or Control on Windows) while hovering reveals the linked page. Obsidian also has three modes—live preview, reading view, and source mode. Live preview renders formatting while hiding the underlying symbols when the cursor leaves the line; source mode shows the raw Markdown; reading view is for consuming notes and blocks editing.

Linking becomes more powerful when the text and destination can be separated. A pipe character lets users change what appears in a link while keeping the same target note (e.g., linking to “Grimoire of the Grave” but displaying “this artifact”). External links use square brackets for the label and parentheses for the URL, producing an outbound link indicator. For precision navigation, Obsidian supports linking to sections and even specific paragraphs: adding a hash (#) jumps to a section header, while a caret (^) targets a specific paragraph. Obsidian can also embed those targets directly into another note by adding an exclamation point to the link—embeds aren’t editable in place, but they can be clicked to jump to the source.

Formatting shortcuts cover the essentials: bold (Command+B or **text**), italic (Command+I or *text*), strike-through (double tildes), highlight (double equals), and block quotes (a right-angle marker). Images are added via drag-and-drop, with Obsidian copying the file into the vault so the note references the local asset. For longer notes, horizontal rules (three dashes) and structured lists—bulleted, nested (tab), numbered, and checklists—help organize content. Checklists can be created manually or faster with Command+Enter (or Control+Enter), and toggling is supported via the same shortcut.

When raw text needs to stay visible—such as commands or code-like snippets—inline code uses backticks, while multi-line code blocks use triple backticks and can specify a language like Python. Callouts provide visually distinct “question,” “warning,” or other panels and can be inserted through the command palette (Command/Ctrl+P). Collapsible callouts are created with a minus sign after the callout header.

Finally, Obsidian’s built-in search becomes a reusable tool. Search supports quoted phrases, boolean-like operators using minus signs (exclude terms), path scoping to folders, and tag filters. Those results can be embedded into a note using a vanilla `query` code block, letting users save recurring searches as living dashboards. The takeaway: a small Markdown and search toolkit is enough to build a powerful, non-coder-friendly note workflow in Obsidian—without plugins or custom coding.

Cornell Notes

Obsidian can be used without coding by relying on Markdown syntax for formatting and navigation, plus built-in search for retrieval. Users create headings with hashes, link notes with double square brackets, and can customize link text using a pipe while keeping the same destination. Precision jumps use `#` for sections and `^` for specific paragraphs, and adding `!` embeds those targets into another note. Formatting shortcuts cover bold, italics, strike-through, highlights, block quotes, images via drag-and-drop, lists, checklists, and code blocks using backticks. Search supports phrases, exclusions, folder scoping, and tags, and results can be embedded with a `query` block to save recurring searches.

How does Obsidian handle formatting so that non-coders can still write clean notes?

Obsidian uses Markdown. Headings are made with hash symbols followed by a space (e.g., `#` for the biggest heading, `##` for the next level). In live preview mode, formatting symbols like hashes and link brackets are rendered visually while the raw syntax disappears when the cursor leaves the line; source mode shows the underlying Markdown; reading view hides syntax and prevents editing. For most users, live preview is recommended because it keeps notes readable while still allowing quick editing.

What are the main ways to link inside Obsidian, and how do they differ?

Basic internal links use double square brackets with the note’s filename. External links use square brackets for the label and parentheses for the URL, producing an outbound link indicator. To change link text without changing the destination, use a pipe (e.g., `[[Target Note|Displayed Text]]`). To jump to a section, append `#` plus the section name; to jump to a specific paragraph, use a caret `^` plus the paragraph identifier. Adding `!` to a link embeds the referenced section/paragraph into the current note (embeds aren’t editable in place, but clicking opens the target).

How do paragraph-level linking and embedding work in practice?

After creating a paragraph link target with a caret (`^`) and an identifier, Obsidian inserts marker characters at the end of the sentence. In preview mode, those marker characters don’t show, but in live preview they appear so hovering with Command reveals the exact sentence-level destination. Embedding uses the same link target but adds an exclamation point, which renders the referenced purple section or specific paragraph inside the new note.

Which Markdown shortcuts are most useful for everyday note formatting?

Bold uses `**text**` or Command+B; italics uses `*text*` or Command+I; strike-through uses double tildes (keyboard-dependent); highlight uses `==text==`. Block quotes use the right-angle marker and can be multiline. Lists use hyphen + space for bullets, tab for nested bullets, and `1.` + space for numbered lists. Checklists use `- [ ]` (or faster creation via Command+Enter / Control+Enter), and toggling can be done by clicking or repeating the shortcut.

How can search results be turned into reusable content inside notes?

Obsidian search can filter by terms, quoted phrases, exclusions using a minus sign, folder scoping using `path`, and tags using `tag`. To reuse a search, embed it: create a code block with triple backticks and use `query` (vanilla, no plugin required), then paste the search query. The note will display the search pane and results, with options like sorting and hiding the title.

Review Questions

  1. What’s the difference between live preview, source mode, and reading view in Obsidian, and why does it matter for editing Markdown?
  2. Give an example of how you would link to (1) a note, (2) a section within a note, and (3) a specific paragraph within a section.
  3. How would you embed a saved search into a note using the `query` block, and what search features (quotes, minus, path, tags) can you combine?

Key Points

  1. 1

    Obsidian’s “no-coding” workflow still depends on a small Markdown toolkit: headings, links, and basic formatting shortcuts.

  2. 2

    Live preview, source mode, and reading view change whether Markdown symbols are hidden and whether editing is allowed.

  3. 3

    Internal links use double square brackets; pipe syntax changes the displayed label without changing the destination.

  4. 4

    Precision navigation uses `#` for sections and `^` for paragraph targets, and adding `!` embeds those targets into another note.

  5. 5

    Inline code (backticks) and fenced code blocks (triple backticks) keep commands/snippets visible instead of being rendered as normal Markdown.

  6. 6

    Lists, nested lists, and checklists can be created manually or faster with Command+Enter / Control+Enter, and checklists can be toggled.

  7. 7

    Obsidian search supports phrases, exclusions, folder scoping, and tags, and results can be embedded via a vanilla `query` code block for repeatable dashboards.

Highlights

A single pipe character lets users change what a link says while keeping the same underlying note destination.
Caret (`^`) paragraph links enable sentence-level navigation, and adding `!` embeds that exact section or paragraph into another note.
Search can be embedded into notes using a `query` block, turning repeated lookups into persistent, clickable panels.
Callouts can be inserted through the command palette and styled by type (e.g., question vs warning), with optional collapsing via a minus sign.
Inline code with backticks is the go-to way to show Obsidian commands or syntax exactly as typed without affecting the rest of the formatting.