Blog · June 27, 2026 · ~14 min read

Trello retainer tracking: how to track retainer hours in Trello (and where it falls short)

Trello’s card-based Kanban approach attracts freelancers who want their retainer tracking inside a familiar visual tool. Its board-and-list structure can be shaped into a functional retainer tracker with the right Power-Ups. This post covers what a well-built Trello retainer setup looks like, where it holds up, and where the specific requirements of retainer tracking — especially client-facing visibility — run into limits that Trello’s architecture doesn’t resolve cleanly.

The short version: Trello works reasonably well for the internal side of retainer management when you invest in the Custom Fields Power-Up and understand the structural constraints of card-level tracking. Where it runs into friction is on the aggregation side — Trello has no native way to sum numeric field values across multiple cards — and on the client-facing side: Trello does have a public board URL option, but the public board exposes your entire workspace in a project management format, not a retainer gauge. The client-visibility problem is not solved by Trello’s public board feature; it is transformed into a different version of the same problem.

This post covers five areas: why freelancers land on Trello for retainer tracking; how to build a functional Trello retainer setup using boards, lists, cards, and the Custom Fields Power-Up; where the approach reaches its structural limits; the client-visibility gap that persists even with a well-configured Trello board; and the two-tool workflow that solves the problem without abandoning Trello.

Part 1: How freelancers arrive at Trello for retainer tracking

The path to Trello for retainer tracking follows the same pattern as Notion, ClickUp, Monday.com, and Asana: most freelancers who track retainer hours inside Trello are already using it for project management and extend it to retainer tracking because the work is already there.

Trello’s appeal is its simplicity. Unlike Asana’s projects-and-sections model or Monday.com’s database-like board with column types, Trello presents a single interface: boards containing lists, lists containing cards. A card is anything — a task, a work entry, a client, a billing cycle. The flexibility is also the limitation: Trello’s core data model has no native numeric fields, no date-range filtering, no formula columns. A card is a card.

What makes Trello feel suitable for retainer tracking is the visual Kanban model. Freelancers managing ongoing client work naturally think in terms of “what I’m working on” and “what’s done” within a given month. A Trello board with lists representing stages of work — or one list per billing cycle — feels like it captures the retainer relationship’s temporal structure. Cards move forward as work progresses; the board becomes a visual record of the cycle.

The second factor is Trello’s low setup cost. Creating a board, adding lists, and creating cards takes minutes. For a freelancer managing two or three retainer clients who wants a faster setup than building a Notion database or configuring a Monday.com board from scratch, Trello’s simplicity is the appeal. The retainer tracking setup doesn’t require understanding a new data model — boards are boards, cards are cards, and the structure feels obvious enough to start immediately.

The third factor is the Custom Fields Power-Up. Trello does support numeric custom fields at the card level when the Custom Fields Power-Up is enabled (available on all plans, free up to one Power-Up per board on Trello’s Free plan, unlimited on paid plans). A card with a custom Number field for “Hours Logged” gives each work entry a numeric value. This is the feature that makes Trello feel like a viable retainer tracker rather than just a Kanban board. It bridges the gap between “card as task” and “card as time entry with a numeric value.”

The result is that Trello users managing retainer clients often extend their existing boards to include numeric fields for hours, attempting to turn the Kanban tool into a time ledger. This works well enough for the first week. The limitations emerge over the course of the first billing cycle, when the freelancer needs to aggregate those individual card values into a cycle total and share the balance with a client.

Part 2: Building a Trello retainer setup that actually works

If you are going to track retainer hours inside Trello, there is a board-and-list structure that holds up better than an improvised card stack. This section describes the setup that makes Trello retainer tracking as reliable as possible within the tool’s constraints.

Board structure: one board per retainer client

The foundational decision in a Trello retainer setup is how to scope your boards. One board per client is strongly preferable to one board for all retainer clients. Custom Fields in Trello are board-level definitions — the same field names and types apply to every card on the board. A board with a “Hours Logged” custom field is clean when every card represents a work entry for the same client. When you put multiple clients on the same board with separate lists, the custom fields are shared across all clients’ cards with no per-client scoping, which creates ambiguity in the balance view.

With one board per retainer client, you can name and configure the board for that client’s specific retainer structure and use the lists to represent billing cycles.

List structure: one list per billing cycle

Within each client’s board, the most functional approach is to use lists to represent billing cycles horizontally. The board starts with a list for the current cycle (“June 2026”), and each new cycle opens a new list (“July 2026”). Cards in the current-cycle list represent individual work entries for the active period. When a cycle closes, that list becomes an archived record on the board — scrollable, searchable, but no longer the active tracking point.

An alternative approach uses the horizontal Kanban flow differently: lists represent stages of work within the cycle (“To Do,” “In Progress,” “Done”) rather than billing periods. Cards move across the board as work progresses. This is the more common Trello usage pattern, but it is worse for retainer tracking because it separates your cycle-aggregate view from the board’s visual structure. With stage-based lists, you lose the ability to see all work from a specific billing cycle in one place without filtering.

The cycle-as-list pattern is less natural Kanban but more useful for retainer tracking, because your primary question is not “what is the status of each task?” but “what is the total for this billing period?”

The Balance Card: a fixed card for cycle metadata

With individual work-entry cards in the current cycle’s list, you have card-level numeric values but no automatic aggregate. Trello does not sum custom field values across cards in a list. The practical solution that most freelancers arrive at is a dedicated “Balance Card” pinned to the top of each cycle’s list. This card carries the cycle-level metadata:

Number — Hours Allocated: the contracted monthly cap for this client.
Number — Hours Used: a manually maintained aggregate of hours logged across all work-entry cards in the list.
Number — Hours Remaining: a manually calculated value (Hours Allocated minus Hours Used plus any rollover from the prior cycle). You update this each time you add or change a work-entry card’s Hours Logged value.
Date — Cycle Start: when the current cycle opened.
Date — Cycle End: when the current cycle closes and the fee period ends.
Number — Rollover Balance (optional): unused hours carried forward from the prior cycle, if your retainer agreement includes rollover.

The Balance Card is the core artifact that makes a Trello board a retainer tracker rather than just a work log. Without it, you have card-level time entries with no aggregate. With it, you have a manually maintained running total that gives you (and potentially your client) the cycle balance at a glance.

The manual maintenance requirement is the central operational constraint of this approach. Every time you log work, you must open the current cycle’s list, find the Balance Card, and update both Hours Used and Hours Remaining. There is no formula that does this automatically.

Custom Fields Power-Up: what it enables and what it costs

The Custom Fields Power-Up is what makes numeric tracking possible in Trello at all. Without it, cards contain only a title, description, due date, members, labels, and checklist items — none of which are numeric and none of which support the kind of structured data entry retainer tracking requires.

With Custom Fields enabled, you can define card-level fields of type Number, Text, Date, Dropdown, and Checkbox. For a retainer tracker, the minimum useful set on work-entry cards is:

Number — Hours Logged: the time spent on this specific work entry.
Dropdown — Category: the type of work performed (Strategy, Content, Development, Admin, Research, Calls). Useful for the monthly category review that supports scope discipline in long retainer relationships.
Date — Work Date: the date the work was performed, distinct from any Trello card due date.
Checkbox — Billable: distinguishes billable retainer time from non-billable goodwill additions or internal overhead.

On Trello’s Free plan, each board can use one Power-Up. If you’re already using a Power-Up for another integration (Harvest, Toggl, GitHub, Google Drive), adding Custom Fields would require removing the existing Power-Up or upgrading to a paid plan. On Standard plan and above, Power-Up limits are removed and you can use Custom Fields alongside any other integration.

This Power-Up limit is worth noting because it affects the setup decision for freelancers on the Free plan: the choice between Custom Fields (for numeric tracking) and a time tracker integration (for timer functionality) is a forced one if you only have one Power-Up slot. Most freelancers who track retainer hours seriously will find the paid plan necessary, which puts Trello’s entry cost at $5/month per user on Standard — still significantly less than Monday.com’s Standard ($10/user/month) or Asana’s Premium ($13.49/user/month billed annually), but not free.

Time tracking in Trello: Power-Up integrations

Trello has no native time tracking. If you want to log time against cards rather than manually entering hours, you need a Power-Up integration. The most common options are the Harvest Power-Up and the Toggl Track Power-Up, both of which add a timer button to Trello cards.

The Harvest Power-Up adds a Harvest timer to each card. Clicking it opens the Harvest time entry dialog pre-populated with the card name. When you stop the timer, the entry is recorded in Harvest against the configured project. The time is in Harvest’s records, not automatically transferred to a Custom Fields “Hours Logged” value on the Trello card. You still need to enter the time in the Custom Fields field if you want the card to carry its own numeric value for balance tracking.

The Toggl Track Power-Up works similarly: one-click timer start and stop from the card, with the entry recorded in Toggl. Again, the Toggl entry and the Trello Custom Fields value are separate records. You either choose Harvest/Toggl as the authoritative time source (and manually enter values in Trello for balance tracking), or you use Trello Custom Fields as the authoritative source (and enter hours manually without using the Power-Up timer).

For most freelancers, the practical workflow is: use Harvest or Toggl for time tracking (because they handle precise timer functionality, reporting, and CSV export well), and treat Trello as the project management and work-log layer. The Harvest or Toggl CSV export at cycle end is the authoritative record; the Trello Balance Card is the internal running total maintained during the cycle.

Butler automation for threshold alerts

Butler is Trello’s built-in automation tool (available on all plans, with execution limits on the Free plan and no limits on Standard and above). For retainer tracking, the most useful Butler rule is a threshold alert: when the Hours Used field on the Balance Card is updated to a value above a specified threshold, Butler can post a comment on the Balance Card or create a checklist item prompting you to notify the client.

Setting this up requires a Butler rule that triggers on card field changes. The rule structure is: “When the custom field ‘Hours Used’ on a card in the current cycle’s list is updated, if the value exceeds X, post a comment to the card.” This works and requires no external automation tool.

Butler can also automate cycle-start scaffolding. A rule triggered on a calendar date can create a new list (“July 2026”), add a Balance Card to it, and pre-populate the custom fields with the contracted Hours Allocated and reset Hours Used to zero. This eliminates the manual cycle-open workflow for the list creation and Balance Card setup, though you still need to manually carry forward any rollover balance from the prior cycle.

The Card Aging Power-Up is worth mentioning as well. It gives cards a visual fade based on how long they’ve been on the board without activity. For a retainer board, it can serve as a passive signal that work entries are stacking up without the balance card being updated — fading entries suggest hours are being worked but not logged, which is a useful visual cue in a manual tracking system.

Part 3: Structural limits of the Trello approach

The setup described above handles the freelancer’s internal needs reasonably well for simple retainer structures. The structural limits appear at three points: the absence of aggregation, the cycle-reset problem, and the client-access model.

No sum across cards: the fundamental aggregation gap

The most significant structural constraint of Trello for retainer tracking is one that distinguishes it from every other tool in this series: Trello has no native mechanism to sum a custom field value across multiple cards in a list.

In Asana, the List view’s column footer automatically sums any Number field across all tasks in a section — you can read the total hours logged in the current billing cycle from the section footer without adding them yourself. In Monday.com, the Group footer provides the same aggregation across all Items in a Group. In Notion, rollup properties on a linked database provide exactly this function. Even in a Google Sheet, a SUM formula does it automatically.

In Trello, there is no equivalent. The only way to see the total Hours Logged across all work-entry cards in a list is to open each card individually and add the values yourself, then enter the total on the Balance Card. Butler can help with some automation here — a rule that triggers when any card is updated and recalculates the running total by querying other cards in the list — but this requires careful rule design, consumes Butler executions, and is prone to edge cases when cards are moved, duplicated, or archived.

The practical consequence is that the Balance Card’s Hours Used value is a manual entry, not a live aggregate. If you forget to update it after logging work on a card, the balance is wrong. In Asana or Monday.com, a delayed update is a cosmetic problem because the section/group footer still shows the live total. In Trello, a delayed update is an accuracy problem: the Balance Card’s Hours Remaining value is stale until you manually reconcile it.

This is the key differentiator between Trello and the other PM tools in this series. It doesn’t make Trello unusable for retainer tracking, but it requires significantly more operational discipline per work-logging session.

No formula fields: manual Hours Remaining calculation

Like Asana, Trello has no formula field type in its Custom Fields Power-Up. The Hours Remaining value on the Balance Card cannot be defined as “Hours Allocated minus Hours Used plus Rollover Balance” and automatically updated when Hours Used changes. You calculate it manually.

Unlike Asana, which at least provides the section footer sum as an automatic reference for the Hours Used update, Trello requires you to add up the card values yourself before you can update the Balance Card. The manual overhead is compounded: first calculate the new Hours Used total from individual card values, then update the Balance Card’s Hours Used field, then recalculate Hours Remaining, then update the Hours Remaining field. This is four steps instead of two.

Monday.com’s Formula column and Notion’s Formula property both eliminate this overhead for users on those platforms. Trello’s Custom Fields Power-Up supports Number and Date field types but no computed fields. This is a known limitation of the Power-Up architecture — computed cross-card values would require a significantly more complex data model than Trello’s card-centric design accommodates.

The cycle-reset problem

Trello has no billing-cycle primitive. There is no concept of a recurring monthly allocation that opens on a defined date, accrues against a cap, and resets automatically. The cycle-as-list pattern described above works around this absence, but closing a cycle and opening the next one requires manual action every month.

At cycle end, the workflow is: review all work-entry cards in the current cycle’s list, confirm the Hours Used total on the Balance Card matches the sum of card values, archive or retain the old list as a historical record, create a new list for the next cycle, add a new Balance Card with the correct starting values (Hours Allocated for the new cycle, Hours Used reset to zero, any rollover balance carried forward), and begin logging work-entry cards in the new list.

Butler can automate the list creation and Balance Card scaffold. It cannot automatically calculate rollover from the prior cycle’s final balance — that calculation requires reading the closed cycle’s Balance Card values and applying the rollover policy, which Butler cannot do without external scripting or a Power-Up that has access to historical card values.

For a freelancer with three retainer clients, the cycle-close and cycle-open workflow is a manageable monthly task across three boards. For a freelancer with eight clients on staggered cycle dates, cycle-close tasks arrive continuously and the cumulative overhead is significant.

Part 4: Trello’s public board — what it does and doesn’t solve

Trello is the only tool in this series with a public board option. Unlike ClickUp, Monday.com, and Asana — which require all viewers to create an account — Trello boards can be set to public visibility, generating a URL that anyone can open without a Trello account. This is worth examining carefully because it sounds like the solution to the client-visibility problem. It is not, but understanding why reveals what the client-visibility problem actually requires.

How Trello’s public board works

Making a Trello board public requires navigating to the board’s Settings and changing the Visibility setting from “Private” or “Workspace” to “Public.” Once public, the board has a stable URL in the format trello.com/b/[board_id]/[board_name] that anyone can open in a browser without creating a Trello account or logging in. The URL is stable for the lifetime of the board — it doesn’t change if you rename the board or add cards.

A client who receives this URL can open the Trello board and see the full board: all lists, all cards, all card titles, all labels, all due dates, all attachments, and all custom field values. They can see the Balance Card’s Hours Used and Hours Remaining fields. They can see all work-entry cards with their Hours Logged values and Category labels. They can read card descriptions and see the card creation dates.

At first glance, this seems to solve the account problem. The client doesn’t need a Trello account to open the URL. The URL is stable and bookmarkable. The Balance Card’s Hours Remaining field is visible.

Why the public board doesn’t solve the client-visibility problem

The problem is what else the client sees when they open the public board.

A Trello board set up for retainer tracking is a project management board. The cards represent work entries, yes — but they are also your internal work log. Any card description you wrote for your own reference (“spent extra 30 min on revisions because client feedback was unclear, absorbed as goodwill”) is visible. Any internal notes you added about the work’s context are visible. Card comments are visible. Labels you use for your own categorization scheme are visible. If you have attached files to cards, those attachments are accessible.

A public Trello board is not a filtered view of selected information for a specific audience. It is the full board, publicly accessible. There is no mechanism in Trello to show a public viewer only specific lists, specific cards, or specific custom field values while hiding others. Public visibility is binary: the board is either private (no external access) or public (everything accessible to anyone with the URL).

This creates an information exposure problem that is more severe than the guest-access problem in Asana, ClickUp, and Monday.com. Those tools at least require the client to create an account, which creates a deliberate access relationship and limits access to workspace members. Trello’s public board gives access to the full board to anyone who finds the URL — a client, a competitor, anyone the client forwards the URL to, anyone who stumbles on it through search engine indexing of public Trello boards.

Public Trello boards are indexed by search engines. If your board contains your client’s name, project details, or internal notes, those details may appear in search results.

The interface problem on the public board

Even setting aside the information exposure problem, the public Trello board does not present retainer balance information in the format a client needs.

When a client opens the public board URL, they see a Kanban board with lists of cards. They must:

Understand that this is a project management board, not a balance dashboard.
Identify which list represents the current billing cycle (if you have multiple cycle lists on the board from prior months).
Find the Balance Card at the top of the current cycle’s list.
Click on the Balance Card to open it and read the custom field values.
Find the Hours Remaining field value and interpret it against the Hours Allocated total.

That is four to five steps between opening the URL and reading the number the client came to find. The target experience for a client checking their retainer balance is zero navigation steps: open a URL, see the gauge, see the work log, close the tab. The public Trello board cannot produce this experience because it presents a project management Kanban interface, not a balance gauge.

Additionally, the Balance Card’s custom field values are only visible when the card is opened. In the board view, cards show their title and any attached labels. The Hours Remaining value on the Balance Card is not visible in the board view — the client must click through to the card. A client who doesn’t know to look for a “Balance Card” may not find the balance information at all on their first visit.

Guest access: the account-required alternative

Trello also supports workspace guest access for users who create a Trello account. On Trello’s paid plans, workspace members can invite guests to specific boards. Guests must create a Trello account (Atlassian account) and accept the board invitation before they can access anything.

The guest access model creates the same account-friction problem as Asana, ClickUp, and Monday.com: the client must create an account, verify an email address, navigate a new platform, and log in on every subsequent visit. A guest who has accepted a Trello board invitation faces the same login overhead as a guest on any other PM tool.

The practical difference between Trello and the other tools in this series is that Trello’s public board option offers a way to skip the account requirement — but at the cost of exposing the entire board without any filtering or access control. The choice in Trello is: force the client through account creation (same as Asana, ClickUp, Monday.com) or expose the full board publicly without filtering (unique to Trello, but creates its own set of problems).

Neither option produces the experience a retainer client actually needs: a URL that requires no login, shows only the hours balance and work log for their specific retainer, and presents the information in a gauge format rather than a project management interface.

Part 5: The client-visibility gap

Understanding why the structural limits described above matter requires being precise about what client-facing retainer balance visibility actually requires. The requirements are different from what project management tools — including Trello — are designed to provide.

What a retainer balance check requires from the client

When a client wants to know their retainer balance, the behavior they are trying to perform is simple: open something and read a number. The ideal experience is: client opens a bookmarked URL, sees “11 of 20 hours used · 9 hours remain · resets July 1,” reads the work log of what has been logged so far this cycle, and closes the tab. Total time: under a minute. Zero emails sent.

The Trello public board fails this requirement at every point. The client opens a Kanban board (not a balance gauge). They must navigate to the Balance Card across potentially multiple lists (not immediate visibility of the number). They must click through to the card (not visible in the board view). They see your full internal work log including any internal notes (not a filtered client-facing view). They see the board in a project management interface (not a purpose-built retainer gauge).

The Trello guest access model fails at the zero-login requirement. And neither option filters to show only the client’s specific retainer information if you are using one board for multiple contexts.

Why the email persists even with a well-configured Trello board

Freelancers who have set up a well-configured Trello retainer board — Balance Card, Custom Fields, Butler automation, public board URL shared with the client — report that the client email frequency does not decrease substantially. Clients who received the public board URL check their balance less often than clients who have a purpose-built URL that requires no navigation.

The mechanism is the navigation overhead. A client who must: remember the Trello URL, open the board, identify the current cycle’s list, click the Balance Card, and read the Hours Remaining field value — will send an email instead when the question arises, because the email is faster. This is not a problem with the specific freelancer’s setup; it is the structural mismatch between a project management board and a retainer balance dashboard.

The information exposure concern adds a second deterrent. Many freelancers who have set up public Trello boards for client access eventually restrict them back to private after realizing that internal card comments and work notes are visible to anyone with the URL. The security risk outweighs the client-visibility benefit when the two are actually weighed against each other.

The comparison to other PM tools in this series

Trello’s public board feature is genuinely unique in this comparison. Notion’s Share to Web is similar but at the page level — the same information-exposure trade-off applies, and Notion pages lack the native numeric aggregation features that would make a retainer gauge functional. Asana, ClickUp, and Monday.com have no public URL option at any plan tier; all access is account-required.

But having a public URL is different from having a useful public URL. Trello’s public board is useful as a backup to the primary problem (requiring the client to create an account). It is not useful as a substitute for a purpose-built retainer balance dashboard because it cannot present information in the required format and because the full-board exposure creates security and professionalism problems that offset the account-friction benefit.

Part 6: The two-tool setup

The two-tool setup for Trello users is structurally identical to the approach described for Asana, ClickUp, Monday.com, and Notion in this series. Trello handles the internal project management layer; a dedicated retainer visibility tool handles the client-facing layer.

What stays in Trello

Trello continues to serve its primary function: internal project management and work logging for the freelancer’s own use. The board structure described above — one board per client, lists per billing cycle, cards per work entry, Balance Card for running totals, Butler automation for threshold alerts — works well for the freelancer’s internal tracking needs.

The Harvest or Toggl Power-Up timer functionality stays in Trello as well, giving you one-click time tracking directly from Trello cards. The time entries flow into your time tracker and can be exported as a CSV at the end of each billing cycle.

What you give up is the public board URL for client sharing. The board stays private.

What the client-facing tool does

A dedicated retainer visibility tool takes the CSV export from your time tracker (Harvest, Toggl, Clockify, or any tracker that produces a per-client time report) and generates a public URL that the client can bookmark. When the client opens the URL, they see:

A gauge showing hours used and hours remaining against the monthly allocation.
The cycle reset date.
A work log of what was logged this cycle, in plain language with dates.

No Trello account required. No Trello interface to navigate. No internal card comments or notes visible. No board structure to interpret. 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 Trello users is:

Manage work tasks in Trello. Log time using the Harvest or Toggl Power-Up timer on each card, or update the Hours Logged custom field manually.
Maintain the Balance Card’s Hours Used and Hours Remaining fields throughout the cycle as your internal running total.
At cycle end (or on whatever cadence makes sense for your client communication), export the time report from Harvest or Toggl for the client and billing period.
Import the CSV into HourTab. The client’s bookmarked URL now shows the updated balance and work log.

The export and import step is the only additional overhead vs. the pure Trello approach. For most freelancers already using Harvest or Toggl for time tracking, this is not additional work — you are already producing this export for invoicing purposes. The HourTab import takes the same CSV and turns it into the client-facing URL.

What the two-tool setup eliminates

The two-tool setup eliminates three problems at once:

The information exposure problem. Your Trello board stays private. The client-facing URL shows only the work log entries from the CSV import — no internal card comments, no label schemes, no board structure, no notes you wrote for your own reference.

The interface mismatch. The client sees a gauge, not a Kanban board. The hours remaining figure is the dominant element on the page, not a value buried inside a card behind a click.

The account and navigation friction. The client opens a bookmarked URL. No login. No account. No navigation across lists and cards to find the balance. The balance is immediately visible.

The behavioral outcome that matters: when the balance is this easy to check, clients check it rather than emailing. The “how many hours do I have left?” email stops being a recurring support task.

A note on Trello CSV export

Trello does offer a board-level CSV export (accessible from the board’s menu under More → Export → Export as JSON, which can then be converted, or directly to CSV through third-party tools). However, the Trello board export produces a snapshot of the entire board — all lists, all cards, all custom field values at the moment of export. It is not a per-cycle time log filtered by date range and client.

For HourTab import purposes, a Harvest or Toggl CSV export filtered by client and billing period is a much cleaner source than a Trello board export. The Harvest or Toggl export gives you exactly the time entries for the relevant period in the format that a retainer balance tool needs; the Trello export requires filtering and reformatting. If your workflow uses Harvest or Toggl alongside Trello, use the time tracker CSV as the HourTab import source rather than the Trello export.

Conclusion: Trello as the work-log layer, not the client-visibility layer

Trello is a capable internal project management tool for freelancers managing retainer clients, especially for those who prefer its visual simplicity over more structured tools like Asana or Monday.com. The board-and-list structure maps reasonably well to the billing-cycle shape of retainer work, the Custom Fields Power-Up adds numeric tracking at the card level, and Butler automation can handle threshold alerts and cycle-open scaffolding.

Where Trello reaches its limits is on the side of the retainer that the client needs to see. The public board feature is unique among project management tools in this series and genuinely eliminates the account-creation barrier — but it exposes the entire board without filtering, presents a Kanban interface rather than a gauge, and creates information security problems that most freelancers eventually determine outweigh the visibility benefit.

The absence of cross-card numeric aggregation is the internal limitation that separates Trello from Asana and Monday.com for retainer tracking. Asana’s section footer sum and Monday.com’s group footer aggregate give those tools an automatic running total that Trello cannot match without manual calculation or Butler scripting.

The two-tool setup resolves both problems by separating the internal tracking function (where Trello’s simplicity is an advantage) from the client-facing visibility function (where a purpose-built retainer dashboard is the right tool). The client gets a bookmarked URL with a gauge. You keep your Trello board for internal work management. Neither workflow changes substantially; you add one export step at cycle end to push the time log into the client-facing tool.

If you run retainer clients and you're already using Trello for project management, you don't need to switch to a different PM tool. You need to add the right tool for the job that Trello isn't designed to do: giving your clients a live, frictionless view of their hours balance without exposing your internal board.

HourTab takes a CSV from your time tracker — Harvest, Toggl, Clockify, or any tool that exports a per-client time report — 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 Trello board access required. Start free with one retainer →