How To Track Your Every Single Minute

As I made public in My Every Minute With Obsidian, I tend to track my day-to-day activities in gross detail in my so-called timeline.

However, I couldn't do this with an off-the-shelf solution. Instead, it's a system I've iterated upon for the better part of two years.

There are few like it, and I am its steward. I've mastered it as it's my life. My timeline, without me, is useless. Without my timeline, I'd have more time in a day, but what about in a year?

So, if, like me, you're looking to track 9 out of every 10 minutes in your day, read along my journey, and you'll see how I do it.


Before getting to the implementation, you need to understand the underlying considerations behind it.


  • Note: a markdown file.
  • Wikilink: a link to a note.
  • Workflow: a set of actions I intend to track (i.e., to Write, Program, etc.) saved as a note.
  • Activity: a slice of time dedicated to a workflow with notes & additional data attached.
  • Daily Note: a note comprising all activities for a given day.

The Source of Truth

First and foremost, I need a place to save my timeline. It would be nice to store it in a database and display it with fancy graphics, but that's easier said than done.

Instead, I've found success in the modern features of digital notebooks. The functionality to search, define metadata, organize, and link between notes provides a base to start a timeline.

For the foreseeable future, my data will remain in a markdown-based editor.

The Components of Tracking

At its core, my implementation has three functions required to track an activity:

  1. Load the timeline's state
  2. Associate data with an activity (i.e., notes, type, etc.)
  3. Save an activity as markdown to that day's note


The Notebook

It may not suit all my needs, but ObsidianMD has been my digital journal of choice from the start of my timeline. It's a simple multiplatform markdown editor with one killer feature: custom JavaScript code.

On top of Obsidian, I make use of several plugins:

  1. Daily Notes (built-in)
    Provides painless daily note creation and navigation.

  2. Sync (built-in)
    At an additional cost, it syncs your notes between devices.

  3. Templater
    Adds support for JavaScript-based templates and the ability to run them via the Command Pallete.

  4. CustomJS
    A bandaid for Templater's poor mobile support[1].

  5. Calendar
    Creates a simple calendar UI for navigating daily notes.

  6. Various Compliments
    A text completion engine that makes it easy to input wikilinks.

  7. Supercharged Links
    Allows for making stylish links, which I use to distinguish between types of notes.

  8. Commander
    Allows a second row on the toolbar on mobile

(Smart) Devices

You need at least one device that runs ObsidianMD. In my experience, I have not had compatibility issues. However, I only use a laptop running Linux and an iPhone.


A clock in and out system has merits, but I've found a stopwatch provides better flexibility.

With a stopwatch, I can track an activity almost like clocking in/out, or pause the timer when not-so-relevant tasks appear amid an activity.

Plus, I can start an activity from anywhere as long as I have my watch.

(ObsidianMD) Implementation

An Initial Data Schema

Since markdown isn't a computer-readable format, we must implement a consistent structure to our data. For metadata, we'll use the widely supported YAML format. However, for the timeline activities, YAML isn't the right fit.

Instead, I use a personalized format composed of two activity states. The first represents an activity not yet concluded, where I'll link some data, and the latter is a completed one.

- #I ==00:00==-==00:00== (⏳ [[Writing]]) (πŸ“š ) ^id-4
    - :BEGAN: #BEG
    - :ENDED: #END
  - ==08:50==

- #πŸ‘ ==08:45==-==08:51== (⏳ [[Writing]]) (πŸ“š <Link to content>) ^id-4
    - :BEGAN: 1694353529
    - :ENDED: 1694353889
  - ==08:50== <Notes here>

Here's a break down on the activity components:

  1. #πŸ‘
    Defines an Obsidian tag based on how the activity went. It could've been normal (πŸ‘), unusual (〽️), frustrating (🀬), amazing (⭐), or whatever.

  2. ==08:45==-==08:51==
    A human-readable format showing a completed activities timeframe.

  3. (<icon> <link>)
    Defines a generic format for activity metadata. For instance, (⏳ Writting) represents the workflow, and (πŸ“š <Link to content>) references some content I'm writing.

  4. ^id-4
    An Obsidian reference to this activity based on its ID. It's also used as an anchor for enhanced wiki linking.

    An antiquated metadata format. It's only used to define the ":BEGAN:" and ":ENDED:" timestamps. These respectively represent the beginning and end of an activity.

    They each start with a placeholder tag and transition to a Unix timestamp[2] upon completion.

  6. - =08:50= <Notes>
    A section dedicated to notes. I'll usually create sub-bullets for more complex activities.

However, in code, the format is defined by configurable regular expressions. So, if you're comfortable with regex[3], I recommend trying a format of your own.

Tracking An Activity

I initiate tracking with a Templater template, which executes JavaScript without producing direct output.

Before anything, the script parses the current state of the daily note. If all activities are completed, it'll prompt to select a workflow and appends a new activity to the bottom of the daily note. However, if your last activity isn't yet completed with a duration, it'll prompt for one.

So, in practice, it's a four-step process:

  1. Start your stopwatch and wait
  2. Trigger the command and select a relevant workflow
  3. Add your notes and metadata
  4. Trigger the command and define the duration from your stopwatch

Issues In My Experience


As you may have suspected, this system isn't designed to track simultaneous activities. However, this is a feature, not a bug.

I could create some complicated system, but instead I simplify and force myself to focus on one thing. Of course, I exercise tolerance when relevant (usually podcasts) and will break from my focus when necessary, but I keep it brief.

Syncing Conflicts

Due to the nature of offline editors, you will have conflicts merging notes from multiple devices.

From my experience (and other reports), Obsidian Sync handles issues the best; however, expect issues when quickly switching devices quickly (or after losing internet). My systems aren't responsible for a poor merge, so they're handled manually.


This implementation isn't precise, but it's usable. There's a balance to strike, so I expect each activity (plus notes) to be accurate +/- 30s. In other words, I round each duration to the nearest minute.

A more accurate approach may be the aforementioned clock-in/out method, but that's not for me.

Moving Forward

My implementation is complex, so if you're interested, I suggest starting slow. I began with a simple bullet list and a timestamp command.

Finally, my scripts and templates are available here on my Github. Please note that these are a work in progress; however, you can expect frequent updates based on quality feedback.


Thank you, @Duifkruid, for encouraging me to release this article promptly.

And, of course, I appreciate the time of my crazy or curious readers. I hardly even know why I do this, so it's hard to imagine somebody else doing so.

  1. This may have changed since Templater v1.15.3. β†©οΈŽ

  2. A Unix Timestamp is a number that represents seconds since January 1970. β†©οΈŽ

  3. is a good resource for testing it out. β†©οΈŽ

Subscribe to

Don’t miss out on the latest issues. Sign up now to get access to the library of members-only issues.