Building a PKM Workflow That Doesn’t Fall Apart Weekly

Building a PKM Workflow That Doesn’t Fall Apart Weekly

ByUS Stacked

1. Capturing research notes without breaking your browser or brain

The capture step should be dead simple, but any setup with more than two extensions or one rogue Readwise sync quickly spins into tabs, google docs, PDFs, newsletters, and an ominous pile of Notion backlinks that point to themselves. I had Highlights importing twice into Obsidian. No idea why. Filed it under “ghost of an old plugin probably” and moved on.

Here’s where I landed eventually: Quick Capture lives in one swipeable inbox — a combination of Notion’s web clipper and a custom shortcut on iOS that dumps notes to a synced Apple Notes folder. Syncing later into a more permanent spot happens with Make, not Zapier — Zapier was slow to pull updated markdown body content from Notes converted via Bear. Painful discovery: Apple Notes API doesn’t reliably register text formatting from shortcuts exports unless duplicated first. Still no idea why.

An edge case I didn’t expect: PDFs clipped through Notion often embed the text content as an image preview, not a readable text layer. Search breaks entirely unless you manually highlight some portion. Using Zapier to OCR that was clunky — ended up running it through n8n + Tesseract via a hosted Docker container, which sounds excessive but honestly worked better than any off-the-shelf solution.

2. Normalizing notes that come in fifty different file formats

Once stuff’s in, it needs translation. Markdown, plain text, PDF, HTML, .docx – they all hit differently inside Notion or Obsidian. Initially tried letting Notion be the aggregator but lost too many structures (especially with nested lists from HTML-to-Markdown conversions). Eventually bailed to plain text + YAML into Obsidian for everything that wasn’t immediately actionable.

Zaps helped more than expected here but only after a workaround: Zapier Formatter doesn’t handle HTML > Markdown translation cleanly. Its regex breaks on multi-paragraph quotes and header levels. My workaround was turning it into a Zapier + Make tag-team event:

  1. Zapier catches incoming note content
  2. Zapier Webhook pushes raw HTML to a Make scenario
  3. Make processes with a Markdownify module (custom-coded)
  4. Feeds back into Obsidian via Dropbox + Obsidian Sync

Quote blocks with blank lines in the middle? That alone crashed one parser. Fixed it but still breaks if the line ends with a special character plus space. Fun.

3. Tagging systems that stop working after ten minutes

I’ve built around five tag systems. None lasted. Most died from human error — too many overlapping terms like #focus-project and #project-focus — which started to matter once I tried to build filtered views. Obsidian’s Dataview plugin started returning zero results for half my queries until I realized it treats tags inside YAML as case-sensitive, unlike Notion.

The most sustainable thing I found was this:

  • Short tags only (#project, #reference)
  • One prefix per intent (#p- for projects, #t- for topics, #s- for sources)
  • Absolutely no emojis (Obsidian hates them, mobile typing hates them more)
  • Tag rules linted daily using AutoHotKey on Windows and Raycast script on Mac

Useful aha: you can build a Notion database filter that excludes all tags except those in a picklist, but the same trick fails if even one of the selectable tags includes capital letters and non-breaking space characters — those copy-paste weirdos from Slack quotes. Found that out while matching tags between a database and synced meeting notes copied out of Zoom transcripts.

Adding tag validation inside the note template metadata helped a bit. Still not bulletproof but now I at least know why something’s not showing up.

4. Connecting related notes without leaking relevance everywhere

In theory, backlinks should solve this. In practice, Obsidian links too aggressively (every lowercase match turns into a page link if you’re not careful), while Notion barely links at all unless you build a formula that references a page ID explicitly.

I had a weird one where two completely unrelated notes—one on cognitive load, one on timeboxing calendars—kept linking each other because I reused the word “chunking” in both. That double backlink spawned a whole graph that made zero sense until I annotated the references manually with footnote logic. No existing systems do that gently — I had to write a custom YAML block that holds contextual linking notes which Dataview can query but the visual graph view ignores.

Undocumented edge case: if you use Obsidian’s “Linked Mentions” feature and then delete a note, any plugins referencing that note may continue to display phantom links in their preview UIs — especially true for Obsidian Linter and Advanced Tables. Found it by accident when a deleted stub still affected a suggestion dialog two days later.

5. Staying sane while building spaced repetition prompts from notes

I experimented with flashcards before, but going full spaced repetition from PKM notes adds friction from every angle. I used the Obsidian plugin that converts headings + cloze deletions into Anki decks but got stalled when the synced decks randomly mis-sorted new additions. The bug turned out to be from duplicate UUIDs inside the same sync session — very uncool and not logged visibly unless you run Anki in debug mode.

Simplest fix: embed custom field for UUID and make it derive from note filename + timestamp hash. Pain in the neck? Yep. Worked? Also yep.

Helpful extract:

%%front%%
What is the main function of spatial working memory?

%%back%%
It maintains and manipulates visuospatial information temporarily for decision making.

Turns out: Obsidian’s card plugin chokes on colons or bullets in cloze deletions. If you’re embedding definitions, use plain text or it silently ignores them.

6. Handling conflicting sources without burning the whole graph down

This one’s more of an interpersonal edge case — someone will eventually point out that the productivity study you annotated contradicts another you captured last year. For a while, I tried threading conflicts using “counterarguments” YAML properties, but it got messy fast. Ended up switching to daily note context tags instead.

The new way:

  • Each research note can include a “bias” field (“industry funded,” “small sample,” etc.)
  • Any quote that gets pulled into a synthesis doc includes clickable context back to the original note
  • Embedding side-by-side views inside Notion gives more visibility, weirdly easier to parse than multi-pane Obsidian setups

I also learned that if you export Notion databases to Markdown+CSV and then re-import into Obsidian via Pandoc, any unicode smart quotes in footnotes mutate into question marks. That small glitch wrecked four entries until I ran a bulk sanitizer script.

A thing that helped: prefix conflicting study notes with `#tension-` and link them to each other manually inside a dedicated “theories in conflict” section. Ugly but super usable later.

7. Archiving or deleting notes without destroying dependencies

Obsidian has no trash folder unless you configure it. I learned that the hard way after deleting four notes with backlinks — which instantly broke two workflows I’d completely forgotten about. One was feeding a Dataview block into my weekly review log. The other was used by a spaced-repetition filter that expected a minimum deck size.

Now I use a custom “graveyard” folder with auto-tagging that warns if any node has 1 or more backlinks. Raycast script does that pre-delete check. Notion’s version isn’t better — it lets you delete pages that are synced across roll-ups, and then auto-removes the source silently. You don’t get broken views; you get wrong ones.

The worst behavior I found though: Make scenarios that try to sync with a now-deleted Notion page will fire soft errors — they succeed in HTTP terms but do nothing. Unless you check return payloads down to every field, you can’t tell the update failed. The only fix is manually scanning logs or adding GUID validations to every page touchpoint.

I tried building a “note checker” that scans dead ends weekly. Still flaky, but here’s the script snippet I trust most right now:

if (note.backlinks.length === 0 && note.updatedAt < Date.now() - 1000 * 60 * 60 * 24 * 30) {
  archiveQueue.push(note);
}

8. Surfacing research connections without turning into a concept map

The final step should pull ideas up — seeing patterns or linking threads. But “graph view” tools tend to oversell this. Half of Obsidian’s links look exciting zoomed out but useless when clicked. I had better luck with filtered Dataview tables that only show notes tagged with both #p-longterm and #s-scientific.

I also pulled quotes into daily notes using a make.com scenario that picks one random note matching a set of filters and injects its quote + link into my morning scratchpad. A discovery worth mentioning: at least three times, that random surfacing re-triggered ideas I’d dropped. Almost like memetic resurfacing from the void. But useful void.