Get AI summaries of any video or article — Sign up free
Logseq DB - First impressions thumbnail

Logseq DB - First impressions

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

Logseq DB’s strongest early win is structured properties, including typed date-time fields and easier property creation.

Briefing

Logseq DB is moving toward a stable beta, and early hands-on use delivers a clear upside: properties become dramatically easier to add and structure, with task management and page layouts feeling more purpose-built than in the older markdown-based workflow. The most immediate “wow” comes from property types—status, date finished, scheduled, and other fields can be created with specific types like date-time, and relationships can point to other nodes in the workspace. That shift matters because it turns what used to be a looser tagging-and-text approach into a more structured object model, where everything is treated as a node rather than a block of markdown.

Task handling also gets a more intuitive UI. Instead of the more manual feel from the markdown version, tasks can be organized with a status field plus priority, deadline, and scheduled dates. The distinction is practical: deadline indicates when something must be done, while scheduled indicates when the work is planned to happen. On top of that, tag pages support multiple views—list, gallery, and a work-in-progress kanban-style drag-and-drop layout—plus grouping options such as grouping by producer to cluster related items.

Yet the same object-based design that powers the improvements also creates friction for anyone migrating from Logseq OG. Tags change meaning: in markdown, tags often function as concept labels that generate pages; in DB, tags define object types. A “book” tag becomes an object category, while “person,” “meeting,” and “company” become distinct objects that can be related. That conceptual flip can quickly confuse users who expect tags to behave like simple links or labels.

Where information “lives” is another sticking point. In markdown, content is straightforwardly stored in page files as blocks, and moving it around usually preserves that mental model. In DB, the transcript describes moments where books appear on a day node and also on a book tag page, but it’s not obvious where the underlying entries are edited. Even basic interactions can feel clunky: adding items in a table view sometimes requires pressing Enter twice, and opening an item may require clicking an arrow or using a specific UI control to reveal the right-side details.

The “not so good” list is mostly about teething issues and UI placement. Adding properties in the correct place can be unintuitive—status fields may be editable in the wrong context, and renaming a property can fail if it’s already used elsewhere. Status type limitations also show up: a status property set to text may only offer a small fixed set of choices, forcing awkward workarounds. Plugins are also unreliable in this early stage, with commonly used ones (like journals, calendar, and bullet threading) disabled due to loading delays.

Other rough edges include quote entry behavior differing from the markdown version, and limited editing visibility for markdown content in DB contexts. Calendar integration and publishing are flagged as still to come, with planned calendar imports and built-in calendar support described as a major future win. In the meantime, the transcript offers practical tips: system properties like external URL and publish UR URL behave differently than user-defined links, and Control+Shift+V helps paste while preserving formatting.

Cornell Notes

Logseq DB’s biggest early advantage is structured properties: users can add property types (including date-time fields), manage tasks with clearer status/priority/deadline/scheduled semantics, and switch tag pages between list, gallery, and kanban-style views. The core tradeoff is a steep mental-model shift from markdown: tags define object types, everything is treated as nodes, and relationships replace the older block-and-link expectations. That change makes some workflows—especially “where exactly is this entry edited?”—feel unclear at first. UI friction, occasional bugs (like table entry requiring extra Enter presses), disabled plugins, and quote-entry differences show the platform is still stabilizing. Calendar import/publishing is promised as a future capability.

What’s the most practical improvement in Logseq DB for day-to-day organization?

Properties become easier to add with explicit property types. For example, a “status” field can be created, and date-related fields like “date finished” can be set to a date-time type. The transcript also highlights that tasks gain a more structured UI: status plus priority, deadline, and scheduled. Deadline answers “when it must be done,” while scheduled answers “when it’s planned,” which is a clearer separation than the older markdown workflow.

Why do tags feel confusing after switching from Logseq OG to Logseq DB?

In markdown, tags often act like concept labels that map to pages. In DB, tags define what an object is. The transcript gives examples: “book” is an object category, while “person,” “meeting,” and “company” are other object types. Users can then create relationships between these objects, which is a different purpose than simple tagging/linking.

How does the “node” model change where information is edited?

Because entries are stored as nodes and relationships, items can appear in multiple places (e.g., books showing on a day node and also on a book tag page). The transcript describes difficulty figuring out where those nodes are actually created or edited. Even when items can be moved via drag-and-drop, the UI doesn’t always make the underlying node location obvious, leading to confusion about the correct editing context.

What workflow friction appears in the UI during early use?

Several small issues add up: table entry sometimes doesn’t register on the first Enter press; opening an item may require clicking an arrow or a specific control to view details on the right or on the page itself. Property editing can also be error-prone—status may be added in the wrong place, and renaming a property can fail if the name is already used elsewhere. The transcript also notes that many actions require refreshes while the interface stabilizes.

Which limitations suggest Logseq DB is still in a rough beta stage?

Plugins are disabled or fail to load in the current setup, including journals, calendar, and bullet threading. Quote entry doesn’t behave like the markdown version (the simple “greater than” quote workflow doesn’t work the same way). Calendar integration and publishing are described as not yet available, with calendar imports and built-in calendar support planned for later.

What are a couple of concrete tips mentioned for working around DB quirks?

External URL and publish UR URL are treated as system links/system properties rather than normal user-defined URL fields. For pasting, Control+Shift+V is recommended as a “paste as text” option that preserves formatting better than standard paste in some cases.

Review Questions

  1. When would you use “deadline” versus “scheduled” in Logseq DB, and why does that distinction matter?
  2. How do DB tags differ from markdown tags in terms of what they represent and how relationships work?
  3. What signs in the transcript indicate that Logseq DB is still stabilizing (e.g., plugins, editing behavior, UI refresh needs)?

Key Points

  1. 1

    Logseq DB’s strongest early win is structured properties, including typed date-time fields and easier property creation.

  2. 2

    Task management becomes more intuitive with status, priority, deadline, and scheduled, with clear semantic separation between deadline and planned scheduling.

  3. 3

    Tag pages support multiple layouts (list, gallery) and a kanban-style drag-and-drop view in development.

  4. 4

    Migrating from markdown requires relearning tags and the object model: tags define object types, and everything is treated as nodes with relationships.

  5. 5

    Some workflows are currently unclear, especially figuring out where node entries are created and edited when items appear in multiple views.

  6. 6

    UI friction and teething issues include clunky table entry behavior, refresh requirements, and property placement/renaming limitations.

  7. 7

    Plugins and calendar features are not fully reliable yet; calendar import/publishing and built-in calendar support are still planned.

Highlights

Typed properties are a standout: date fields like “date finished” can be set to date-time, and relationships can point to other nodes.
Tasks gain clearer semantics: deadline is “must be done by,” while scheduled is “planned for.”
Tags change meaning in DB—no longer just concept labels, but object definitions that enable relationships.
Where entries “live” can be hard to locate because nodes can surface in multiple places (e.g., day nodes and tag pages).
Plugins may be disabled due to loading delays, and calendar integration is still pending.

Topics