Get AI summaries of any video or article — Sign up free
Logseq Working Session: Approaches, potential usecases, plugins, themes, importing notes & more thumbnail

Logseq Working Session: Approaches, potential usecases, plugins, themes, importing notes & more

CombiningMinds·
5 min read

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

TL;DR

Convert legacy notes into Markdown and save them as .md files before importing, so Logseq can interpret them as blocks.

Briefing

Logseq becomes usable once notes are moved into the right text structure—then projects, meetings, decisions, and recurring concepts can be referenced across the whole graph instead of being trapped in folders or Word documents. The session centers on a practical workflow for importing messy notes, rebuilding link structure, and choosing a “node-first” mindset (pages as containers; journals as capture) so information stays searchable and filterable.

James’s frustration comes from months of trying Logseq without feeling confident—especially after switching computers and dealing with notes scattered across Microsoft Word and random files. The turning point is a workflow that treats Logseq as a system built on Markdown files: convert existing notes into Markdown, copy them into the correct Logseq folders (notably the pages and journals areas), and refresh Logseq so the graph updates. For journal-style capture, the approach is to copy bullet points into a date-based journal file using the same date naming pattern Logseq uses for daily journals; Logseq then formats the content automatically.

From there, the discussion shifts to the core conceptual hurdle: how to structure “pages vs journals” and how indentation and nesting affect what shows up where. Pages act like stable containers for a project (e.g., “Project Sainsbury’s Drop”), while journals act as a capture stream for meetings and actions. Instead of writing meeting notes inside the project page, the workflow often writes them in the journal and links them back to the project using inline tags or double-bracket links. Indenting determines whether a block belongs under a parent block—so a top-level bullet must be created correctly for it to appear as a reference from the project page.

The session also tackles the “what should the top line be?” problem. The answer is that it doesn’t have to be either “project” or “meeting.” Using combinations like “Project Sainsbury’s Drop” plus “meeting” (and then filtering by one or the other) lets the same note be discoverable from multiple angles. A key example shows meeting notes nested under a date, with actions and outcomes stored as linked blocks, enabling later traversal like a lightweight wiki.

To make the graph feel less bare-bones, the discussion highlights themes and plugins. Developer mode unlocks the plugin/theme menus, and the group recommends community-vetted additions. Examples include a journal calendar for date navigation, a random note entry point for clearing out forgotten content, heat maps for activity density, block-to-page for promoting blocks into pages, and “orphan page” cleanup to keep the database tight by removing empty or unlinked pages. A “mark map” theme supports zoomable visual mapping of the graph, and favorites provide quick entry points.

Finally, the session offers a concrete import method: open old notes in Notepad++ (or similar), convert them into Markdown blocks by adding dash bullets, save them with a .md extension into the Logseq pages folder, then refresh so they appear in the graph. The overall takeaway is that Logseq rewards a deliberate structure—Markdown first, indentation and nesting correct, and node-based linking—so knowledge becomes traversable rather than buried in one-off documents.

Cornell Notes

Logseq becomes effective when notes are captured and imported as Markdown in the right places, then linked through a node-based structure. The workflow emphasizes converting existing Word/text notes into Markdown, copying them into the pages or date-based journals folders, and refreshing Logseq so links and formatting appear correctly. Pages work as stable containers for long-running topics (like a project), while journals act as the capture stream for meetings and dated actions that link back to those pages. Indentation and nesting determine whether blocks are recognized as belonging to a parent node, which is crucial for reliable referencing and filtering. Themes and plugins (enabled via developer mode) add navigation and cleanup tools like calendars, random-note entry, heat maps, and orphan-page removal.

Why does “convert to Markdown first” matter for getting Logseq working with old notes?

Logseq’s graph is built from structured text files. The session recommends opening existing notes outside Logseq (e.g., in Notepad++), turning them into Markdown bullet blocks (adding dashes for list items), saving them with a .md filename, and placing them into the correct Logseq folder (especially the pages folder). After copying, a refresh/import step (“import changes from local files”) makes the content appear in the graph with proper block structure, so links and nesting behave predictably.

What’s the practical difference between using pages vs journals for project and meeting notes?

Pages are treated as containers for durable context—e.g., a project page like “Project Sainsbury’s Drop” holds the project’s core information. Journals are used for time-based capture—e.g., when a meeting happens, the meeting notes and actions are written in the daily journal and then linked back to the project using inline tags or double-bracket links. This avoids stuffing everything into the project page while still keeping the project page as a hub that can reference meeting notes later.

How do indentation and nesting affect what shows up under a parent block?

Indentation determines block ownership in Logseq. A common failure mode described is writing a related bullet at the wrong level—creating sub-bullets without indenting them under the intended parent. Once the block is indented correctly, it becomes part of the parent node’s reference set and appears when navigating from that parent page. A theme that visually shows nesting levels can make this easier to spot.

How can a note be both “about a project” and “about meetings” without forcing one hierarchy?

The session argues against choosing only one top-level organizing principle. Instead, it uses combined node naming and filtering: meeting notes can be linked to both a project node and a meeting-oriented view (e.g., “Project Sainsbury’s Drop meeting”). Later, filtering by project or by meeting surfaces the same underlying notes from different angles, so the structure stays flexible rather than folder-like.

What role do tags, square brackets, and double brackets play in linking and filtering?

Inline tags or bracketed syntax are used to mark concepts so they become nodes that can be searched and filtered. Double brackets are highlighted as a way to create explicit node links (e.g., “Carl Voight” as a node). Square-bracket inline hashtags are used for concept labeling and visual organization; the session also notes that spaces inside hashtag-like tokens can require bracket formatting to avoid being treated as a different kind of markdown header.

Which plugins/themes help with navigation and database hygiene?

The session highlights several: a journal calendar for jumping across dates; a random note plugin for resurfacing forgotten entries; heat maps for seeing how many blocks were written on specific days; block-to-page for promoting blocks into pages; and an “orphan pages” feature to remove empty/unlinked pages. It also mentions mark map themes for zoomable graph visualization and favorites for quick entry points.

Review Questions

  1. When importing old notes, what specific steps ensure they become proper Logseq blocks (Markdown bullets, correct folder, and refresh/import)?
  2. How would you redesign your structure if meeting notes aren’t appearing under the project page—what should you check first: naming, linking syntax, or indentation level?
  3. What’s the advantage of filtering by both project and meeting nodes compared with forcing everything into a single folder-like hierarchy?

Key Points

  1. 1

    Convert legacy notes into Markdown and save them as .md files before importing, so Logseq can interpret them as blocks.

  2. 2

    Use pages for stable context (projects/people) and journals for time-based capture (meetings/actions), then link journal entries back to the relevant pages.

  3. 3

    Indentation and nesting level control block ownership; mis-indented bullets won’t show up under the intended parent node.

  4. 4

    Avoid folder-only thinking by naming/linking notes so they can be discovered from multiple entry points (e.g., project and meeting views).

  5. 5

    Enable developer mode to access the plugin/theme menus, and prefer community-vetted plugins to reduce risk.

  6. 6

    Use navigation and cleanup tools—calendar, random note, heat maps, orphan-page removal—to keep the graph usable as it grows.

  7. 7

    When moving content into Logseq, place files into the correct pages/journals folders and refresh so local changes propagate into the graph.

Highlights

The fastest path to “making Logseq click” is importing notes as Markdown into the pages/journals folders, then refreshing so formatting and linking work reliably.
A key structural rule: journals capture meetings and actions; pages store the project container—linking via tags/double brackets makes the project page act like a hub.
Indentation isn’t cosmetic in Logseq; it determines whether nested blocks belong to a parent node and therefore whether references appear.
Logseq’s node-based model lets the same note surface under different organizing angles through filtering, without forcing a single hierarchy.
Orphan-page removal and random-note entry points help prevent the graph from becoming cluttered or forgotten over time.

Topics

Mentioned