HourTab

Blog · June 27, 2026 · ~15 min read

Excel and Google Sheets retainer tracker: how to track retainer hours in a spreadsheet (and where it falls short)

Spreadsheets are the default starting point for freelancers who want to track retainer hours without adopting a new PM tool. Excel and Google Sheets support numeric fields, SUM formulas, and conditional formatting — the mechanical requirements of a retainer ledger. This post covers what a well-built spreadsheet retainer tracker looks like, where spreadsheets have a genuine advantage over the PM tools covered elsewhere in this series, and where the specific requirements of retainer tracking — especially client-facing balance visibility — run into limits that a spreadsheet’s row-and-column format doesn’t resolve cleanly.

The short version: spreadsheets do the internal tracking job better than most PM tools in this series. They have formula fields (unlike Asana and Trello), automatic SUM across rows, free entry, and no account setup. Google Sheets adds a share-with-link model that doesn’t require the viewer to create an account — genuinely the most permissive public URL option of any tool covered so far. Where spreadsheets fall short is on the client-facing side: a cell showing “6” is not a gauge. The client who opens a Google Sheet to find their retainer balance must identify the right cell in a row-and-column interface that was built for you, not for them.

This post covers five areas: why freelancers land on spreadsheets for retainer tracking; how to build a functional Excel or Google Sheets retainer tracker with formulas and conditional formatting; what spreadsheets do better than dedicated PM tools in this series; the two client-sharing patterns freelancers try with Google Sheets; and the two-tool workflow that keeps the spreadsheet for internal tracking while giving clients the dashboard format they actually need.

Part 1: Why freelancers land on spreadsheets for retainer tracking

The path to Excel or Google Sheets for retainer tracking is shorter than the path to any dedicated PM tool. Most freelancers already have Excel or Google Sheets. There is no account to create, no new interface to learn, and no integration to configure. The starting point is a blank spreadsheet with whatever column headers seem right, and the first version of the tracker is running within minutes.

Spreadsheets also have native numeric fields. This distinguishes them from Trello, which requires the Custom Fields Power-Up to add numeric values to cards, and from PM tools like Asana, which requires manual calculation because formula fields aren’t available. In a spreadsheet, the Hours Used cell is automatically the sum of the Hours column via a SUM formula. This is the core function retainer tracking requires, and spreadsheets provide it natively.

The third factor is familiarity. Every freelancer who has filed a tax return, built a quote, or tracked project expenses has used a spreadsheet. The mental model of rows as records and columns as fields is universal. A freelancer who has never used Asana or Monday.com has been using Excel or Google Sheets for years. The zero-friction entry is why spreadsheets are so often the first tool freelancers reach for when retainer tracking becomes necessary.

The fourth factor is cost. Excel is included in most Microsoft 365 subscriptions that freelancers already have, and Google Sheets is free as part of a Google account. There is no incremental cost to building a retainer tracker in a spreadsheet — no paid tier, no per-user fee, no usage-based pricing. For a freelancer who tracks two or three retainers and is not ready to commit to a paid tracking tool, a spreadsheet is a rational first step.

The result: spreadsheet-based retainer trackers are common, usually functional for the internal tracking side, and often the setup freelancers have been running for months or years by the time they consider switching to something else. The question is not whether the spreadsheet works for tracking — it does — but whether it solves the complete problem, which includes giving clients a frictionless way to see their balance without sending an email.

Part 2: Building an Excel or Google Sheets retainer tracker that actually works

If you are going to track retainer hours in a spreadsheet, there is a column structure and formula setup that holds up better than a blank sheet with improvised headers. This section describes the setup that makes a spreadsheet retainer tracker as reliable as possible within the tool’s constraints.

Sheet structure: one tab per client

The foundational decision in a spreadsheet retainer tracker is how to scope your tabs. One tab per retainer client is strongly preferable to one tab for all clients. With one tab per client, the column headers, SUM formulas, and summary cells are scoped to that client’s retainer structure. With all clients on the same sheet in different column groups, the formulas must reference specific column ranges per client, which becomes error-prone as you add clients or rename columns.

Within a single-client tab, the two structural approaches are: a flat log (all entries in one table, cycling across months) and a monthly-tab structure (one sub-tab per billing cycle, with a summary tab across cycles). The flat log is simpler but requires SUMIF filtering by date range to calculate the current-cycle total. The monthly-tab structure keeps each cycle’s entries isolated, with a simple SUM at the bottom of the hours column, and the monthly-reset is a matter of starting a new tab at cycle open.

For most freelancers managing a small number of clients, the monthly-tab structure within a client-scoped workbook is the cleanest approach: one spreadsheet file per client, one tab per month, summary row at the top of each tab.

Column structure: what goes in each column

The minimum useful column structure for a retainer time log is:

With this column structure, the Hours column is a series of decimal values that a SUM formula can aggregate automatically. This is the key structural advantage of a spreadsheet over Trello, which requires manual addition of card-level numeric values because there is no native cross-card aggregation, and over Asana, which requires manual calculation of Hours Remaining because there are no formula fields.

Summary row: the cycle-level balance in one place

At the top of each monthly tab (or at a designated “summary” row), you maintain the cycle-level balance. The structure:

The Hours Used and Hours Remaining cells in the summary row update the moment you enter a new row in the entries table. This is what spreadsheets do better than any PM tool covered in this series: the aggregate is automatic. In Trello, updating the Balance Card requires manual addition of card values and a separate manual entry. In Asana, Hours Remaining requires manual recalculation after every log entry. In a spreadsheet with a SUM formula, the balance is always current without any additional action.

SUMIF for category breakdowns

A SUMIF formula on the Category column gives you an automatic breakdown of hours by work type. For example: =SUMIF(C4:C100,"Strategy",D4:D100) sums all hours in the D (Hours) column where the corresponding C (Category) value is “Strategy.” Running this for each category type in a separate summary block gives you the category breakdown that answers the other question retainer clients ask: “what did you actually work on this month?”

The SUMIF category breakdown also serves the freelancer’s own scope management. A retainer agreement that allocates 20 hours per month with the understanding that most of it goes to strategy and delivery can drift if admin and calls start consuming 8 of those hours. A SUMIF breakdown makes the drift visible immediately — you see the category totals update as you add entries, and you can flag a category imbalance before it compounds across multiple cycles.

Conditional formatting for threshold alerts

Conditional formatting applies a visual signal — a color change, a bold style, an icon — when a cell value meets a condition. For a retainer tracker, the most useful conditional formatting rule is on the Hours Remaining cell or on a percentage-used indicator: when the Hours Used value exceeds 80% of Hours Allocated, the cell turns yellow or orange; when it exceeds 95%, it turns red.

The formula for a percentage-used indicator: =B3/B2 (Hours Used divided by Hours Allocated) gives you a decimal from 0 to 1 (or above 1 if the retainer is over). Apply a three-color scale format to this cell, or add a conditional rule: “If this cell is greater than 0.8, apply yellow fill; if greater than 0.95, apply red fill.”

This is a passive alert — it changes when you look at the sheet, not when you’re away from it. Unlike Trello’s Butler automation, which can post a comment to the Balance Card when a threshold is crossed, conditional formatting doesn’t generate a notification. It is useful for at-a-glance status when you open the sheet, not for catching threshold events between sessions. For active notification, a Google Sheets Script that emails you when the percentage-used cell exceeds a threshold is possible but requires setup beyond the base spreadsheet.

Pivot table for multi-client overview

If you use a flat log structure (all clients in one spreadsheet, differentiated by a Client column), a pivot table can produce a multi-client overview: rows as clients, columns as month, values as sum of hours used, with a calculated field for hours remaining. This is the multi-retainer overview equivalent of Monday.com’s Portfolio or Asana’s Portfolio (Business plan), available in a spreadsheet without additional cost.

The pivot table approach requires consistent data entry (the Client and Date columns must be clean for the pivot to filter correctly), but for a freelancer managing five or more retainers who wants a single view, a pivot table on a flat log is an efficient alternative to maintaining one tab per client.

Monthly reset: the cycle-close workflow

In a monthly-tab structure, cycle-close is a matter of duplicating the current month’s tab, renaming it to the new month, clearing the entry rows (keeping the column headers and summary formulas), and updating the Hours Allocated value and Cycle Start/End dates for the new period. If the prior cycle had unused hours, copy the Hours Remaining value from the closing cycle’s summary and paste it as a constant (not a formula) into the new cycle’s Rollover cell — pasting as a value breaks the reference to the closing cycle, which prevents the rollover from updating retroactively when you add late entries.

This cycle-reset workflow is a manageable monthly task for a freelancer with three or four retainer clients. The spreadsheet approach requires it manually; there is no automated cycle-open process equivalent to Trello’s Butler calendar-triggered list creation. For a freelancer with eight or more clients on staggered cycle dates, the cumulative monthly overhead is significant and is one of the signals that a dedicated retainer tracking tool is worth considering.

Part 3: What spreadsheets do better than PM tools for retainer tracking

The Pile O series covering PM-tool retainer tracking has documented the specific structural limits of each tool. Spreadsheets have a genuine advantage in several areas that the PM tools do not match.

Automatic aggregate: the SUM formula vs. manual aggregation

The most important structural advantage of a spreadsheet over Trello is the SUM formula. In Trello, the Hours Remaining value on the Balance Card is a manual calculation: you sum the Hours Logged values across individual cards in the cycle’s list, then update the Balance Card’s Hours Used field, then recalculate Hours Remaining, then update that field. Four manual steps per work-entry session. In a spreadsheet, a SUM formula in the Hours Used cell means you add one row to the entries table and the balance updates automatically. Two fewer manual steps, every time.

Asana’s section footer provides an automatic sum of Number fields in a section, so Hours Used is always visible as a live aggregate. But Asana still requires manual calculation of Hours Remaining because there are no formula fields — you must read the section footer total and subtract from the contracted hours yourself. A spreadsheet formula eliminates this step: the Hours Remaining cell is defined once as Hours Allocated minus Hours Used and updates automatically.

Formula fields: automatic Hours Remaining

Spreadsheets are the only tool in this series with native formula fields. Monday.com’s Formula column and Notion’s Formula property are the nearest equivalents in the PM-tool world, but both require configuring the formula within the tool’s interface and are only available on paid plans. In a spreadsheet, any cell can contain a formula referencing any other cell, at no additional cost and with no plan restriction.

For a retainer tracker, the formula field advantage means: add one row (the new work entry), and both Hours Used and Hours Remaining update without any additional action. This is the most automated internal tracking experience of any tool in this series. The PM tools that come closest are Monday.com (Formula column on paid plans) and Notion (Formula property on any plan, including free). Asana and Trello require additional manual steps every time.

Free and no account required

Excel requires a Microsoft 365 subscription (which most freelancers already have for other purposes) and Google Sheets is free. Neither requires an additional account or paid tier for the retainer tracking functionality described here. The SUM formula, conditional formatting, SUMIF breakdowns, and pivot tables are all available in Google Sheets on the free tier. Monday.com, Asana, and ClickUp all require paid plans for the features that make retainer tracking functional at scale (formula columns, automations, guest access without login). A spreadsheet provides these features at no incremental cost.

CSV export is native and clean

Every spreadsheet row is natively exportable as a CSV. Excel exports to CSV via File → Save As → CSV. Google Sheets exports via File → Download → Comma Separated Values. The exported CSV is a clean tabular file with one row per entry, matching the standard format that retainer tracking and time-reporting tools expect.

This matters for the two-tool workflow described later: if you use a spreadsheet as your primary time log (rather than a dedicated time tracker like Harvest or Toggl), the CSV export path from your spreadsheet to a client-facing retainer tool is the same one step. You don’t need a time tracker as an intermediary. This is a distinct advantage over tools like Trello, whose board-level CSV export is a full board snapshot that requires reformatting before it can be used as a time log import.

Part 4: The client-sharing problem — Google Sheets’ two patterns

The part of the retainer tracking problem that spreadsheets don’t solve cleanly is client-facing visibility. The requirement is a frictionless way for the client to see their hours balance without sending an email. Spreadsheets have exactly one native sharing mechanism: sharing the spreadsheet itself. Two variations exist, and both come with the same fundamental problem.

Pattern 1: share the whole spreadsheet

Google Sheets allows you to generate a share link with “Anyone with the link can view” permission. This link does not require the viewer to create a Google account — the sheet is accessible to anyone who has the URL, on any device, without login. This is the most permissive sharing model of any tool covered in this series. Asana, ClickUp, and Monday.com have no public URL option at any plan tier; all viewer access requires account creation. Notion’s Share to Web requires a Notion account for editing but not for viewing. Trello’s public board is similar to Google Sheets’ “Anyone with the link” option. In Google Sheets, the share-link model is available on the free plan and requires no configuration beyond changing the sharing settings.

The problem with Pattern 1 is what the client sees when they open the link. The client sees your entire spreadsheet: all sheets (tabs), all formulas, all internal notes in cell comments, all historical data from prior cycles (if you keep them in the same workbook), any auxiliary calculations you added for your own reference, and any other content you have on any tab. The spreadsheet is your internal tool. Its column headers (“Billable,” “Category,” “Rate Override”), internal notes, and formula-visible auxiliary cells were written for you, not for a client audience.

Unlike a filtered view, a shared Google Sheet shows the viewer exactly what you see. There is no tab-level access control that lets you expose one tab (the current cycle summary) while hiding others (the prior months, the internal notes tab, the formula workings). The entire workbook is either shared or not.

The information exposure problem is compounded by context: a client who opens a spreadsheet sees a row-and-column table, not a dashboard. The Hours Remaining cell is present, but it requires identifying the correct cell among all the other cells on the sheet. A client who does not know which cell to look at must read column headers, find the summary row, and interpret the value in context. If the sheet has multiple tabs, they must determine which tab is the current one.

Pattern 2: create a separate “client view” tab

The second pattern attempts to solve the exposure and interface problems by creating a dedicated tab in the workbook that presents only the client-facing information. The client view tab contains a simplified layout: the client’s name, the cycle dates, a large Hours Remaining display, and a formatted list of work entries for the current cycle. The main tracking tab stays hidden (via right-click → Hide Sheet, which prevents the tab from appearing in the tab bar for viewers).

Pattern 2 is more sophisticated than Pattern 1, but it introduces maintenance overhead. The client view tab is a mirror of the main tracking tab’s data, either via cell references (=MainTab!B3) or a manual copy-paste workflow at cycle end. If cell references are used, the client view automatically reflects any change in the main tab — but hidden sheets are still accessible to determined viewers via the Sheet Settings menu, so the “hide” mechanism is a cosmetic deterrent, not an access control. If copy-paste is used, the client view is a static snapshot that goes stale the moment you add a new entry to the main tab without refreshing the client view.

Both Pattern 1 and Pattern 2 share the interface mismatch problem: the client sees a spreadsheet, not a gauge. Even a well-designed client view tab is a grid of cells. The Hours Remaining value is present, but the format that a retainer client needs — a large gauge showing the balance against the monthly cap, with a clear reset date, and a readable work log — is not the native output of a spreadsheet cell. The cell shows a number; a gauge communicates a number and its context simultaneously.

The interface mismatch: why a cell is not a gauge

The distinction between a number in a cell and a gauge with a number is not cosmetic. It is a display-design choice that affects whether the client internalizes the information without cognitive overhead.

A gauge communicates multiple facts at once: the current value, the scale (how much is possible), and the rate (how much is used relative to the cap). A cell showing “6” communicates one fact: the current value. The client must hold in mind the contracted cap (20 hours, or 10, or 40 — depending on the deal) to interpret what “6 remaining” means. Is 6 comfortable? Tight? Already over? The gauge answers this question before the client has to ask it.

The work log presents the same problem. A spreadsheet’s entry table is formatted for data management, not for reading. Rows with a Date column, a Description column, a Category column, a Hours column, and a Billable column give the client all the fields, in whatever order they appear in your internal layout. A purpose-built work log shows the date, the description, and the hours in a readable format, in reverse-chronological order, without exposing internal columns. The difference matters for the client’s experience: a client who can read the work log without interpreting a spreadsheet column layout will check the balance more frequently, because the friction of opening the URL and reading the information is lower.

The behavioral pattern that matters: when checking the balance is frictionless, clients check it rather than emailing. When checking the balance requires opening a spreadsheet, identifying the right cell, and reading the value in context of a column-heavy layout, clients send an email instead — because the email is faster. The spreadsheet can be shared; it cannot be a gauge.

Excel: no built-in share-with-link

Excel does not have Google Sheets’ “Anyone with the link can view” sharing model natively. Sharing an Excel file requires either attaching it to an email (which sends a file, not a URL the client can bookmark) or using OneDrive to generate a share link (which requires a Microsoft account to edit, though view-only links can be created). OneDrive’s share link for view-only access is possible but is less commonly known and requires storing the file in OneDrive rather than locally.

For freelancers using Excel rather than Google Sheets, the client-sharing problem is more severe: there is no direct equivalent to Google Sheets’ “Anyone with the link” permission. The most common workaround is to export the client’s cycle data to a PDF (via File → Export) and send that by email at the end of each cycle, which is a report rather than a live balance view and does not give the client a URL they can check at any time.

Part 5: The two-tool setup

The two-tool setup for spreadsheet users keeps the spreadsheet for internal tracking and adds a dedicated retainer visibility tool for the client-facing layer. This approach preserves the spreadsheet’s genuine advantages — formula fields, automatic SUM, SUMIF breakdowns, free entry, CSV export — while giving clients the gauge format and frictionless URL they need.

What stays in the spreadsheet

The spreadsheet continues to serve as the authoritative internal time log. The column structure, SUM formula, SUMIF breakdowns, conditional formatting threshold alerts, and monthly-tab cycle structure all remain exactly as described above. Nothing in the internal tracking workflow changes.

What you give up is the client-sharing patterns described in Part 4 — the “Anyone with the link” share and the client view tab. The spreadsheet stays private.

The CSV export path: one step from spreadsheet to client URL

The two-tool setup for spreadsheet users has a distinctive advantage over the same setup for PM-tool users: the export step requires no intermediary time tracker. Freelancers using Trello, Asana, Monday.com, or ClickUp alongside a dedicated time tracker (Harvest, Toggl, Clockify) use the time tracker as the export source for the client-facing tool, because the PM tool’s export is either a full board snapshot or a task list, not a per-client time log in the format a retainer tool expects.

A spreadsheet whose rows are time entries — one row per work session, with Date, Description, and Hours columns — is already a time log in the format a retainer tool expects. Exporting the current cycle’s entries as a CSV (Google Sheets: File → Download → Comma Separated Values; Excel: File → Save As → CSV) gives you exactly the file that the client-facing tool needs to import. No time tracker required as an intermediary. No reformatting. No filtering of a full-board export.

If you also use a dedicated time tracker (Harvest, Toggl, Clockify) alongside the spreadsheet, the time tracker’s CSV export is an equally clean source — and if your spreadsheet serves as the master copy of the tracker’s export (a common workflow where you paste the tracker CSV into a spreadsheet for formatting and annotation before sending invoices), the spreadsheet’s CSV export at cycle end gives you the same content.

What the client-facing tool does

A dedicated retainer visibility tool takes the CSV export from your spreadsheet (or time tracker) and generates a public URL that the client can bookmark. When the client opens the URL, they see:

No spreadsheet access required. No Google account required. No column-header interpretation. The client sees the balance and the work log — exactly what they came to find, in the format a retainer client actually needs.

The workflow

The two-tool workflow for spreadsheet users is:

  1. Log work in the spreadsheet as you always have. Add one row per work session with Date, Description, Category, and Hours. The Hours Used and Hours Remaining cells in the summary row update automatically via the SUM and formula cells.
  2. At the cadence that makes sense for your client communication — weekly, at a threshold crossing, or at cycle end — export the current cycle’s tab (or the current cycle’s row range) as a CSV.
  3. Import the CSV into the client-facing retainer tool. The client’s bookmarked URL now shows the updated gauge and work log.

The export and import step is the only additional overhead vs. sharing the Google Sheet directly. For most spreadsheet-based retainer trackers, the CSV export takes ten seconds. The import is similarly fast. The client never needs to know the spreadsheet exists.

What the two-tool setup eliminates

The information exposure problem. Your spreadsheet stays private. The internal columns, prior-cycle tabs, formula-working cells, internal notes, and category breakdowns are not visible to the client. The client-facing URL shows only the entries from the CSV import — the Date, Description, and Hours for the current billing cycle.

The interface mismatch. The client sees a gauge with a percentage bar and a clear hours-remaining number, not a spreadsheet with a cell that shows “6.” The gauge is the dominant element; the work log is secondary. The format is built for a reader who came to find one number, not for a user who is managing a data table.

The account and navigation friction. The client opens a bookmarked URL. No Google account required. No spreadsheet to navigate. No column headers to interpret. No tab switcher to find the right sheet. The balance is immediately visible.

The stale-view problem of Pattern 2. A client view tab in a shared spreadsheet goes stale between cycle updates if you use copy-paste. A client-facing URL backed by a CSV import is updated when you choose to update it — at the frequency that is correct for your client relationship, not whenever the spreadsheet’s cell references happen to refresh.

The CSV import advantage vs. PM-tool users

A freelancer who uses Trello for internal tracking needs to export time entries from a dedicated time tracker (Harvest, Toggl) because the Trello board’s CSV export is a full board snapshot, not a per-client per-cycle time log. A freelancer who uses Asana needs to export from Harvest or Toggl for the same reason: the Asana project export is a task list, not a time log in the format a retainer tool imports.

A freelancer who uses a spreadsheet as their primary time log is already one step away from the client-facing URL. The spreadsheet is the time log; the CSV export of the spreadsheet is the import source for the client-facing tool. No time tracker required as a middle layer. This is the most direct workflow of any tool in this series for the subset of freelancers who track time directly in a spreadsheet rather than in a dedicated tracker.

If you use a time tracker alongside the spreadsheet (which is common — the time tracker for precision timer functionality, the spreadsheet for invoice-ready formatting and annotation), the time tracker’s CSV export is also a valid import source. Either path works; the spreadsheet’s native CSV export removes the time-tracker dependency for freelancers who don’t need the tracker for any other purpose.

Conclusion: the spreadsheet as the right internal tool, and what it is not

A well-built Excel or Google Sheets retainer tracker is the most capable internal tracking setup of any tool covered in this series for freelancers who want formula-backed automatic aggregation without a paid PM tool. The SUM formula gives automatic Hours Used totals that Trello cannot match. The formula-based Hours Remaining cell eliminates the manual recalculation that Asana requires. SUMIF category breakdowns and conditional formatting provide the operational visibility that helps freelancers manage scope discipline across multiple retainer clients. And the entry cost is zero.

Google Sheets’ “Anyone with the link” sharing model is also genuinely better than what any PM tool in this series offers for account-free access: no Google account required, stable URL, accessible from any device. Asana, ClickUp, and Monday.com have no public URL at any tier. Trello’s public board is the closest equivalent, with the same information-exposure trade-off: full-board exposure, no filtering, no gauge format.

The spreadsheet reaches its limit on the client side. A cell with a number is not a gauge. A shared spreadsheet exposes internal data that was written for the freelancer, not the client. A “client view” tab is maintainable but requires ongoing effort to stay current and still presents a spreadsheet interface rather than a balance dashboard. And the repeat-open habit that stops the “how many hours do I have left?” email depends on the client experience being immediate — open the URL, see the number, close the tab. A spreadsheet, even a well-organized one shared via a clean link, does not deliver that experience for a client who does not live in spreadsheets.

The two-tool setup keeps what the spreadsheet does well — internal time logging with automatic formula aggregation — and adds the layer the spreadsheet cannot provide: a gauge format at a client-bookmarkable URL, updated from the same CSV the freelancer already exports for invoicing. The client gets the experience that stops the emails. The freelancer keeps the tool they know.

If you run retainers and you’re already tracking time in a spreadsheet, you don’t need to switch tools for the internal tracking side. You need to add the right tool for the job that a spreadsheet isn’t designed to do: giving your clients a live, frictionless view of their hours balance in a format that was built for a reader, not a data manager.

HourTab takes a CSV from your spreadsheet or time tracker — one row per entry, Date, Description, Hours — and turns each retainer into a public URL the client can bookmark. Opening the URL shows the hours gauge, the cycle reset date, and the work log. No client login. No spreadsheet access required. Start free with one retainer →

More on PM-tool retainer tracking