Get AI summaries of any video or article — Sign up free
How I use Logseq to track my tasks thumbnail

How I use Logseq to track my tasks

Tools on Tech·
6 min read

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

TL;DR

Use Logseq task states (later/to do/doing/done) to separate planned work from what’s actively being worked on.

Briefing

Task management in Logseq works best when tasks are labeled for fast retrieval at the moment they matter—then filtered into a short, daily “do list” rather than a sprawling inbox. The core workflow centers on using Logseq’s task states (later, to do, doing, done), lightweight time tracking, and a query system that pulls the right subset of tasks based on priority, schedule, and context like location, people, or projects.

Instead of treating task capture as the main goal, the approach treats it as a means to produce results when the day’s constraints hit. Tasks get assigned labels that reflect real-world context. For example, “errands” and “proxies” (a DIY store in the Netherlands) act like location-based buckets: once the person is out, a query surfaces everything tied to that location so errands don’t require re-planning mid-trip. The same idea generalizes beyond places—tasks can be linked to projects, people, or reading materials so the right work appears when a specific context becomes active.

Logseq’s built-in task workflow provides the operational backbone. Tasks can move through planned and active states: “later” for planned work, “to do” for upcoming items, and “doing” for what’s currently in progress. Switching a task into “doing” can also enable time tracking, showing how long the task took. Navigation through the workflow is streamlined with Ctrl + Enter, and tasks can also be placed into a “waiting” mode using /waiting—useful for tracking items dependent on someone else’s response. Priority is handled with slash commands (/a, /b, /c), mapping to an Eisenhower-style urgency/importance split: A items are “needs to be done now” and important, B is important but not immediate, and C is less important.

Scheduling and repetition keep tasks from vanishing. With /schedule, tasks are marked for a future date and can repeat; when a repeating task is checked off, the scheduled date advances while the task remains active for the next cycle. For retrieval, Logseq queries act as the “search engine” for tasks: “now” surfaces items in doing/to do, “next” looks ahead seven days, and “overdue” flags missed scheduled tasks.

The most important query pattern is a filtered task list that combines task state with priority and then narrows further by context using page or link references. In practice, this produces a reusable “top tasks” view: tasks that are still open and priority A float to the top, and additional queries slice tasks by the current page/link context—such as a person’s page for outstanding follow-ups or a location tag for errands.

Daily execution stays minimal. The day starts with a small set of focus points and a task list page built from queries, typically organized into priority A, then overdue/important, then remaining to-dos in time order. A key efficiency feature is reference copying: Ctrl + C copies a reference to a task line rather than duplicating it, letting the same task appear across multiple daily lists while still pointing back to the original details. Marking it done updates everywhere it’s referenced. The result is a system that keeps planning lightweight, reduces distraction, and makes it easy to jump into the right work without rebuilding context each time.

Cornell Notes

Logseq task management is built around fast retrieval: tasks are labeled by context (location, people, projects) and then pulled into a short daily list using queries. Tasks move through a workflow—later, to do, doing, done—with Ctrl + Enter, and “doing” can include time tracking. Priority is assigned via /a, /b, /c (mapped to urgency/importance), and /schedule supports future dates and repeating tasks. The most useful payoff comes from combining task state + priority in queries, then narrowing results using page/link references so the right subset appears when you’re in the right situation. Reference copying (Ctrl + C) lets the same task appear in multiple lists while staying linked to one source of truth.

How does the workflow (later/to do/doing/done) support day-to-day task execution in Logseq?

Tasks are moved through planned and active states: “later” for planned work, “to do” for upcoming items, and “doing” for what’s currently in progress. Ctrl + Enter advances the task through the cycle (for to do/doing: to do → doing → done; for later: later now → done). When tasks are placed on “doing,” Logseq can track time for that task, showing how long the work took. This makes it easier to keep the active list clean and measure effort without extra bookkeeping.

Why use context labels like “errands” and “proxies,” and how do they change what shows up?

Context labels let tasks surface at the moment they’re relevant. “Errands” and “proxies” act like location-based buckets: when the person is heading to the DIY store, a query tied to that location shows everything needed for that trip. The same mechanism works for other contexts—tasks can be assigned to projects, people, or reading materials—so the daily list becomes situation-aware instead of requiring manual searching.

What role do priority commands (/a, /b, /c) play, and how are they mapped to decision-making?

Priority is assigned with slash commands (/a, /b, /c), functioning like a quick tag but designed for ordering. The scheme is tied to an Eisenhower-style split: A is “needs to be done now” and important, B is important but not urgent, and C is less important. In queries, this lets priority A tasks rise to the top of planning lists, ensuring the most consequential work gets attention first.

How do scheduling and repeating tasks work, and what’s the practical implication for checking them off?

Using /schedule marks a task for a future date. That scheduled day then appears on the to-do or overdue lists if it’s late. Repeating tasks are handled automatically: when a repeating task is checked off, the scheduled date moves forward by the repeat interval, but the task remains active (not finished). The practical implication is that repeating tasks should be placed where it’s acceptable for them to stay unchecked and keep reappearing.

What makes the “main query” pattern powerful for daily planning?

The key pattern combines task state and priority, then narrows by a page/link reference. The result is a query that pulls only tasks that are still open (e.g., to do/doing) and match a priority level (like A), then filters further to a specific subset such as a person, a location, a project, or a book. This produces targeted lists—e.g., outstanding tasks for a specific person when having a conversation, or tasks for a specific location when running errands.

How does reference copying (Ctrl + C) reduce duplication while keeping daily lists useful?

Ctrl + C copies a reference to a task line rather than duplicating the task. Putting those references into different daily lists means the same task can appear in multiple places while still pointing back to the original details in the graph. Clicking the reference jumps to the full task context. When the task is marked done, it updates everywhere the references appear, preventing inconsistent status across lists.

Review Questions

  1. What are the differences between later, to do, and doing in Logseq’s task workflow, and how does Ctrl + Enter change a task’s state?
  2. How would you design a query that surfaces only priority A tasks relevant to a specific context (like a person or location)?
  3. What tradeoff does the system create by adding tasks to the official daily plan with friction, and how does that support consistency?

Key Points

  1. 1

    Use Logseq task states (later/to do/doing/done) to separate planned work from what’s actively being worked on.

  2. 2

    Label tasks by real-world context—locations, people, projects, and reading—so the right subset appears when you need it.

  3. 3

    Assign urgency/importance with /a, /b, /c and build queries that float priority A tasks to the top.

  4. 4

    Use /schedule for future tasks and repeating tasks, understanding that repeating items remain active after being checked off.

  5. 5

    Rely on queries (now/next/overdue plus custom filters) to retrieve tasks instead of maintaining long manual lists.

  6. 6

    Build a short daily task list from a small set of query-based focus points rather than browsing an ever-growing task graph.

  7. 7

    Use reference copying (Ctrl + C) so tasks can appear in multiple daily lists while staying linked to one source of truth.

Highlights

Location-based labels like “errands” and “proxies” turn Logseq into a just-in-time checklist when leaving the house.
Priority commands (/a, /b, /c) map directly into query ordering, making “top tasks” a repeatable daily view.
Reference copying (Ctrl + C) avoids duplication: one task can be referenced across multiple lists and marked done everywhere at once.
Repeating tasks advance their scheduled date when checked off, so they behave like recurring commitments rather than finished items.

Topics

  • Logseq Task Workflow
  • Priority Queries
  • Context-Based Task Lists
  • Scheduling and Repeats
  • Reference Copying