Get AI summaries of any video or article — Sign up free
Building A Personal Time Tracker Dashboard With Notion And Timely thumbnail

Building A Personal Time Tracker Dashboard With Notion And Timely

Landmark Labs·
5 min read

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

TL;DR

Build the dashboard by linking Notion to a Google Sheets template that generates pivot-table charts from raw time entries.

Briefing

A Notion time-tracking dashboard can be built to automatically summarize where weekly hours go—by combining a Google Sheets back end with filtered charts, then optionally feeding entries from Timely through Zapier. The payoff is a single workspace that turns raw time logs into practical views: total hours over the last seven days, productive hours by project, learning goals, “limit hours” (time spent on activities meant to be reduced), and billable versus non-billable time.

The dashboard’s structure is anchored by a linked objectives database and a set of chart-driven tabs. From the main view, a seven-day hours graph updates as new entries land, and hovering over dates reveals the specific projects tracked and the hours attributed to each. Additional sections break time down in ways that map to common personal management questions: which projects drove productive work, which projects align with learning objectives, how much time went to “limit” categories like Netflix, YouTube, social media, or Twitter, and how billable time compares with non-billable time day by day. The system also supports creating new objectives directly inside the dashboard—such as a learning goal with a weekly target (e.g., “read for five reading hours per week”)—so the reporting stays tied to goals rather than just activity.

To recreate the setup, the workflow starts with a cloneable Google Sheets template. Users copy the sheet, then enter their own data into the “raw input” area, which is designed to feed pivot tables and charts. Manual logging is supported by adding rows with project, date, hours, and a billable flag (or a boolean “true/false” that drives billable versus non-billable classification). Once the data is in place, charts must be embedded into Notion: each chart is published from Google Sheets, the embed link is copied, and Notion uses that link to dynamically refresh charts as the sheet updates (typically after refreshes rather than instantly).

A key implementation detail is that filtered chart views require careful pivot-table configuration. For example, the “learning hours” chart should only include projects tagged as learning objectives (like “reading” or “Coursera”). That same filtering logic must be mirrored for productive hours and other categories, so the right project tags appear in each view. It’s described as fiddly at first, but once the project-tag filters are set, new entries automatically flow into the correct charts.

For automation, Timely acts as the time capture layer. Timely runs in the background and logs active screen time, then users tag items to projects (e.g., “product” or “freelancing submit”) to generate time entries. A pre-built Zapier automation connects Timely to the Google Sheets “raw input” sheet, mapping fields like date and client/project details into the correct columns. A Zap test creates a new spreadsheet row, and the Notion charts update accordingly—turning daily tagging in Timely into an always-current dashboard in Notion. The result is a goal-aware time system that can work either manually or fully automated, depending on how the Google Sheets and Zapier integration are configured.

Cornell Notes

The system builds a Notion dashboard that reports weekly time allocation by project and goal type. Google Sheets serves as the back end: raw time entries feed pivot tables and charts, which are then embedded into Notion via published chart links. Users can log hours manually in the sheet or automate entry creation by sending Timely data through Zapier into the same raw input table. Filtered views (productive, learning, limit, billable) depend on pivot-table project-tag selections, so the right projects must be assigned to each category. Once those filters and embeds are set, new time entries automatically refresh the dashboard’s charts and statistics.

What are the dashboard’s main views, and what decision each one supports?

The dashboard is organized into five chart-driven views: (1) an overview of total hours over the last seven days, where hovering over dates shows the projects and hours; (2) productive hours, filtered to projects tagged as “productive”; (3) learning hours, tied to learning objectives such as reading goals and specific learning projects; (4) limit hours, which track time spent on categories meant to be reduced (examples given include Netflix, YouTube, social media, and Twitter/X); and (5) billable versus non-billable time, broken down day by day. Together, they answer where time went, what was productive, what advanced learning, what consumed “limit” time, and how much time is billable.

How does the Google Sheets template feed Notion charts?

Google Sheets holds the raw input data and generates pivot tables and charts from it. After copying the template, users update the “raw input” sheet with their own entries. Then they publish each chart from Google Sheets (“Publish chart”), copy the embed link, and paste it into Notion using an embed command. Notion uses that link so the chart refreshes when the underlying sheet data changes (after refreshes rather than instant updates).

What fields matter most when logging time manually in the sheet?

Manual logging is done by adding a row with at least: project, date, hours logged (e.g., “logged hours”), and billable status. The sheet uses a billable flag (described as a boolean “true/false”) to route hours into billable versus non-billable calculations. If billable is set to true, the hours are treated as billable; otherwise they become non-billable.

Why do pivot-table filters require extra setup for the productive/learning/limit views?

Filtered views rely on pivot-table settings that select which project tags appear in each chart. For example, the learning hours chart should include only projects tagged for learning objectives (like “reading” and “Coursera”). The same process must be repeated for productive hours and other filtered charts by opening the pivot table editor and adjusting the “project” filter list. Without matching those selections, charts may show the wrong projects even if the raw data updates correctly.

How does Timely change the time-tracking workflow compared with manual entry?

Timely runs in the background and automatically logs active screen time, but it doesn’t decide the project by itself. Users tag or select items in Timely’s interface so the system assigns those time slots to the correct project (e.g., tagging items to “product” or creating an entry for “freelancing submit”). That tagging step produces structured time entries that can then be routed into the dashboard automatically.

What does the Zapier automation accomplish end-to-end?

Zapier connects Timely to the Google Sheets raw input sheet. The automation asks users to select the correct Google Sheets workspace and spreadsheet, then choose which Timely fields map into the sheet columns (such as date and client/project-related fields). A test run creates a new spreadsheet row (including client/project name and hours), which then causes the embedded charts in Notion to update based on the new data.

Review Questions

  1. When embedding Google Sheets charts into Notion, what is the required step that creates the dynamic link between the two systems?
  2. What pivot-table filter must be adjusted so that the learning hours chart includes only the intended learning projects?
  3. In the Zapier setup, which sheet area receives the Timely data, and why does that matter for chart updates?

Key Points

  1. 1

    Build the dashboard by linking Notion to a Google Sheets template that generates pivot-table charts from raw time entries.

  2. 2

    Embed Google Sheets charts into Notion using the published chart embed link so charts refresh when the sheet data updates.

  3. 3

    Log manual entries by filling project, date, hours, and a billable flag that drives billable versus non-billable calculations.

  4. 4

    Configure pivot-table “project” filters for each filtered view (productive, learning, limit) so only the correct project tags appear in each chart.

  5. 5

    Use Timely for background time capture, then tag items to projects so entries are categorized correctly.

  6. 6

    Automate the pipeline by sending Timely fields into the Google Sheets raw input table via a pre-built Zapier integration, enabling Notion charts to update automatically.

Highlights

The dashboard’s seven-day hours graph updates with new entries, and hovering over dates reveals the exact projects and hours behind each day.
Filtered charts depend on pivot-table project-tag selections—learning, productive, and limit views won’t be accurate until those filters match the intended categories.
Notion chart updates come from embedding published Google Sheets chart links, which refresh after the underlying sheet data changes.
Timely captures active screen time in the background, but project assignment happens through user tagging before entries flow into the dashboard.
Zapier automation maps Timely fields into the Google Sheets raw input sheet, so a single tested row can immediately propagate through the chart system.

Topics