Get AI summaries of any video or article — Sign up free
Keeping track of your ideas- creating a blog idea pipeline through queries and processing in Roam thumbnail

Keeping track of your ideas- creating a blog idea pipeline through queries and processing in Roam

Robert Haisfield·
5 min read

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

TL;DR

Tagging ideas in Roam can quickly inflate linked references, so the workflow adds query-based filtering to keep results actionable.

Briefing

A practical Roam workflow turns scattered ideas into a manageable “idea pipeline” by using queries to separate unprocessed notes from items worth developing and work currently in progress. The core problem driving the system is simple: tagging ideas automatically creates huge linked-reference lists (the creator reports 80+), which makes it hard to find the next writing prompt and forces constant re-evaluation.

The solution is to treat Roam like an inbox plus a progressive processing queue. As ideas arise during other work, they get tagged (for example, with a “blog” tag). But instead of letting everything accumulate in one place, the workflow relies on query logic to show only what hasn’t been processed yet. The key mechanism is combining an OR condition for multiple equivalent page names with a NOT condition that filters out anything already marked as processed.

In the transcript, the OR operator is used so that different page-name references—such as “blog content” and “video”—are treated as the same category for query purposes. Then a NOT-wrapped OR clause excludes blocks that already contain any of the “processed” markers. The result is an “unprocessed” view that functions like a to-do inbox: it lists items that match the idea tag/category but do not yet appear in the processed states.

From there, the workflow splits into focused views. A “to develop” (or “develop”) view shows ideas judged worth expanding—often those with enough context to be actionable. For example, blog ideas related to onboarding frequently include a page name like a user goal (“features rarely make sense to new users without the context of user goals”), because those contexts recur in product work. A separate “in progress” view tracks what’s actively being worked on, so the linked references for a chosen idea become a starting point for outlining rather than a sprawling list to sift through.

The system also mirrors a personal content pipeline built earlier for stand-up comedy: joke premises move to jokes to develop, then to jokes to perform. The Roam version uses similar stages—premise, develop, published (mapped to “perform”), plus an “archive” bucket for blocks that can’t simply have the blog tag removed but are no longer relevant. This keeps the pipeline clean without losing historical material.

A major benefit is progressive processing. Instead of fully processing every idea before moving on, the unprocessed query lets the user process items in batches and return later, picking up where they left off. That matters most when ideas keep flowing during ongoing product research; the pipeline prevents a backlog of unprocessed items from swallowing writing time once actual blog work begins.

Underneath the mechanics is a workflow philosophy: processing notes forces review, which keeps ideas usable over time. By repeatedly filtering, deciding what’s good, and moving items through stages, the notes become a durable asset rather than content written once and forgotten. The transcript ends with a recommendation to adopt the same “unprocessed inbox” approach and to share how others handle note processing in Roam.

Cornell Notes

The workflow uses Roam queries to manage an idea pipeline so tagged ideas don’t turn into an unmanageable linked-reference pile. Ideas are tagged as “blog” content, but an “unprocessed” query filters them into an inbox-like view by using OR logic to treat multiple page-name references as equivalent and NOT logic to exclude items already marked as processed. From that inbox, separate views track what’s “to develop” and what’s “in progress,” with an archive stage for items that can’t be fully untagged. The approach supports progressive processing—reviewing and moving items in batches—so new ideas can keep entering without blocking actual writing later.

How does the workflow prevent a single “blog” tag from creating an overwhelming linked-reference list?

It keeps the tag for discovery, but uses query filtering to create an “unprocessed” view. The query treats multiple related page names (e.g., “blog content” and “video”) as equivalent via an OR operator, then wraps that OR logic in a NOT condition so blocks that already appear in processed states don’t show up. That means the user sees only ideas that match the blog category but haven’t yet been moved forward in the pipeline.

Why does the query use an OR operator inside curly brackets, and what does it accomplish?

Different page names can refer to essentially the same idea category. By placing those page names inside an OR operator, the query treats any of them as a match. So if a block contains “blog content,” “video,” or “blog,” it qualifies for the query results, even if the user used different wording while tagging.

What role does the NOT operator play in the “unprocessed” view?

The NOT operator excludes anything already processed. The query is structured so that matching the idea category is necessary, but if the block also contains any of the processed markers (the OR list inside the NOT), it gets filtered out. The user then effectively gets an inbox of items that still need review or triage.

How do the pipeline stages mirror earlier stand-up comedy note habits?

The earlier system used three folders: joke premises (starting point), jokes to develop (good ideas moved forward), and jokes to perform (ready for stage). The Roam workflow follows the same logic with stages like premise → develop → published (mapped to “perform”), plus an archive bucket for blocks that remain tagged but are no longer relevant.

Why does the “to develop” stage often include page-name context for blog ideas?

Some blog topics only make sense with specific context. The transcript gives onboarding as an example: features rarely make sense to new users without user goals. So when relevant, the user tags the page name (the user-goal context) alongside the blog idea, ensuring that when the idea reaches “to develop,” it already has enough scaffolding to outline and write.

What does “progressive summarization” mean in this workflow, and why is it useful?

It means processing ideas incrementally rather than all at once. The unprocessed query acts like a queue: the user can review a subset of ideas, move them to develop or in-progress, and leave the rest for later. This is especially helpful when ongoing product research keeps generating new ideas, because it prevents a massive unprocessed backlog from blocking writing once blog work starts.

Review Questions

  1. What specific query logic (OR vs NOT) is used to create an “unprocessed inbox” view in Roam, and what does each part filter for?
  2. How do the pipeline stages (premise, develop, in progress, published, archive) change what appears in each saved view?
  3. Why does the workflow emphasize processing notes over time rather than only collecting them when ideas first appear?

Key Points

  1. 1

    Tagging ideas in Roam can quickly inflate linked references, so the workflow adds query-based filtering to keep results actionable.

  2. 2

    An “unprocessed” view is built by combining OR logic for equivalent page-name tags with NOT logic to exclude already-processed blocks.

  3. 3

    Separate saved views (unprocessed, to develop, in progress) turn a growing idea pool into a staged pipeline for writing.

  4. 4

    The pipeline stages are modeled after a stand-up comedy process: premises → develop → perform/published, with an archive for dead ends that can’t be untagged.

  5. 5

    Context matters for blog ideas; tagging relevant page names (like user goals for onboarding) helps ideas become outline-ready.

  6. 6

    Progressive processing lets the user handle ideas in batches and return later without losing momentum.

  7. 7

    Regular processing supports long-term usefulness by forcing review and decision-making, preventing notes from becoming “lost into the ether.”

Highlights

The workflow creates an inbox-like “unprocessed” list by using OR to treat multiple tag names as the same category and NOT to hide anything already processed.
Instead of letting blog-tagged blocks accumulate, the system routes ideas through premise → develop → in progress → published, keeping writing focused.
Progressive processing prevents backlog paralysis: new ideas can keep flowing while the user still finishes current work.
Archive exists for blocks that remain tagged but are no longer relevant, preserving history without polluting active queues.

Topics

Mentioned