Blog › Tools comparison

Linear vs. HourTab for retainer client hours visibility

July 11, 2026 · ~14 min read

Linear is the issue tracker of choice for hundreds of freelance developers and small dev shops. Its clean UI, fast keyboard shortcuts, and thoughtful cycle planning model have made it the tool that replaced Jira for many indie developers and boutique software teams. If you’re building software on a client retainer, Linear is probably where you manage that work.

But if that client is on a monthly retainer with a hours cap — “20 hours per month at $175/hr” — Linear cannot answer the question they will ask every week: “How many hours do we have left this month?”

That is not a criticism of Linear. Linear was designed to manage software work items, not billing relationships. The gap is architectural: Linear tracks what was done, not how much of the client’s pre-purchased time was consumed. This post explains the distinction clearly, walks through how a developer who uses Linear for work management can add retainer hours visibility without changing their workflow, and compares the two tools directly.

What Linear actually tracks

Linear is built around four primitive objects: issues, cycles, projects, and teams. Issues are the unit of work — a bug, a feature, a chore. Cycles are sprint windows, typically one or two weeks long, that group issues and let you measure velocity (how many issues, or story points, the team completed per sprint). Projects group issues under a larger initiative. Teams segment the workspace by function or by client.

None of these objects has a concept of billable hours or a monthly hours budget. Linear does not ask “how many hours did this issue take?” — it asks “what’s the priority and status of this issue?” Linear’s velocity metrics are measured in issue count or story-point estimates, not clock hours. An issue estimated at 3 story points might take 2 hours or 6 hours; Linear does not track which.

There is no Linear field for “monthly hours cap.” There is no Linear view that shows “12 of 20 hours used · 8 hours remain · resets August 1.” There is no Linear report the client can open to see their retainer status. Linear’s design philosophy — fast, focused, minimal — deliberately excludes billing infrastructure.

Linear cycles vs. retainer billing cycles: a critical distinction

The naming overlap creates confusion. Both Linear and retainer billing use the word “cycle.” They mean completely different things.

A Linear cycle is a sprint planning window. A team might run two-week cycles, starting Monday and ending Friday two weeks later. Issues get assigned to a cycle; at the end of the cycle, Linear shows cycle completion rate (how many issues were completed vs. planned). Cycles are about planning discipline and velocity tracking. They are not tied to billing dates and do not carry a financial budget.

A retainer billing cycle is a calendar period — almost always one month — during which the client’s pre-purchased hours are consumed. The cycle starts on the billing date (e.g., the 1st of each month) and ends when the next bill is issued. Within that window, the client has a finite budget (say, 20 hours) that depletes as the freelancer logs time. When the cycle closes, unused hours may roll over or expire, and the budget resets.

These two cycles do not align. A freelance developer might run two-week Linear cycles that cross month boundaries. The client’s retainer cycle might reset on the 15th of each month. There is no automated mapping between “cycle completed” in Linear and “billing period closed” in the retainer relationship. The two concepts live in separate systems serving separate purposes.

Does Linear have time tracking?

Linear does not have native time tracking. There is no built-in timer. There is no way to log “I worked 2.5 hours on this issue” directly in Linear and have that number aggregate into a billable hours total.

Linear integrates with some time-tracking tools through community-built integrations and the Linear API. Developers have built integrations that let them start a timer in a separate app (Toggl, Clockify) from a Linear issue. But the hours never live in Linear itself — they live in the time tracker. The integration is a convenience shortcut to start the timer without context-switching; the actual time data stays in the external tool.

This matters for retainer billing because the hours total — the number that determines whether the client’s monthly budget is consumed — only exists in the time tracker, not in Linear. A developer who uses Linear for work management needs to also run a time tracker to capture billable hours, and that time tracker is where the retainer math happens.

Linear’s guest and viewer access model

Linear does allow external guests. A client can be added as a viewer to a Linear workspace, giving them read access to issues, projects, cycles, and roadmaps. In principle, this gives the client visibility into the work being done on their project.

In practice, this access does not answer the retainer hours question. Even with full viewer access, the client sees the issue board — a list of tasks, their statuses, priorities, and cycle assignments. There is nothing on that board that says “you have 8 hours left in your monthly budget.” The client might see that 14 issues were completed this cycle, but they have no way to translate that into hours consumed or hours remaining without asking the developer directly.

Additionally, Linear’s viewer role requires the client to create a Linear account. A client who does not want to manage another SaaS account, or whose company’s IT policy restricts third-party tool sign-ups, cannot access the Linear workspace at all. The retainer hours question — something the client needs answered every week without friction — now requires an account creation workflow that many clients won’t complete.

HourTab’s architecture inverts this: the client receives a single URL. They click it. No account. No login. No app to install. They see their hours used, hours remaining, and the work log. The URL works in any browser, on any device, and the client can bookmark it and return whenever they want.

The developer retainer workflow gap

A freelance developer on a monthly retainer typically works like this: the client pays for, say, 25 hours of development time per month. The developer works on a mix of features, bug fixes, code reviews, and technical consultation throughout the month. Every few weeks, the client wonders where they stand — not because they distrust the developer, but because they need to make decisions about what to prioritize with the remaining hours.

“We have 8 hours left this month. Should we finish the dashboard pagination or get the export feature ready for the demo?”

That is a real business decision, and it requires knowing the number. The client cannot make it well if they have to email the developer to ask first and wait for a reply. By the time the reply comes, the decision window may have closed (the demo is tomorrow; the client needed to know yesterday).

Linear cannot provide this number. The developer must export their time tracker, calculate the balance, and communicate it to the client — either by emailing an update, sharing a spreadsheet, or building something custom. All of those approaches create maintenance overhead and introduce lag between the actual hours and the client’s view.

HourTab closes this gap. The developer uploads a CSV from their time tracker (Toggl, Clockify, Harvest, or any other tool that exports time entries). HourTab calculates the hours consumed against the retainer cap and generates a live URL. The client has the URL bookmarked. The dashboard is always current. The decision question — “how many hours do we have left?” — is answered before the client thinks to ask it.

The three-tool stack for developers on retainer

The practical setup for a freelance developer billing retainer clients while using Linear:

Linear manages the work: issue backlog, sprint cycles, project roadmaps, bug tracking. The developer uses Linear for everything related to what needs to be built and in what order. Clients who want to follow along on the work can be added as viewers.

A time tracker (Toggl, Clockify, Harvest) runs alongside. When the developer starts working on a Linear issue, they also start a timer in their time tracker, tagged with the client name and project. The time tracker captures actual clock hours — the data that determines whether the client’s monthly budget is consumed.

HourTab takes the time tracker’s CSV export and turns it into the client’s hours URL. Once a week (or more often), the developer exports the week’s time entries as a CSV and uploads to HourTab. HourTab recalculates the balance and the client’s URL shows the updated number automatically.

The three tools don’t overlap. Linear knows what was built. The time tracker knows how long it took. HourTab shows the client what their remaining capacity looks like. Each tool is single-purpose, and the workflow between them is a single CSV export step.

How the hours update works in practice

On Friday afternoon, the developer finishes the week’s work. In Toggl (or Clockify, Harvest, or another tracker), they run a detailed report filtered by client for the current billing month. They export that as a CSV — a two-click operation in most trackers.

They upload the CSV to HourTab. HourTab reads the time entries, sums the hours per billing cycle, subtracts from the retainer cap, and updates the client’s URL. The client’s page now shows the updated balance: “17 of 25 hours used · 8 hours remain · resets August 1.” Below the balance, the work log lists each session with the date, duration, and description — exactly the work log the client would see in a time tracker export, but formatted for reading rather than for bookkeeping.

The developer does not email the client to say “this week we used 4.5 hours on the dashboard pagination.” The client already knows — the URL updated. The weekly retainer admin is 30 seconds instead of 10 minutes.

Linear vs. HourTab: feature comparison

Why this matters for client relationships

The “how many hours do we have left?” question is not just an admin question. It is a trust question. A client who has to email to get this number is a client who, implicitly, does not have real-time visibility into what they’re paying for. In a healthy client relationship, the client should never have to ask. They should always know.

Linear gives the client visibility into the work — they can see what issues were completed, what’s in progress, what’s planned. That is genuinely valuable. A client who can see the issue board has much better context for product decisions than a client who just receives a monthly invoice.

But seeing the work is different from seeing the budget. Both matter. A client who sees that “12 issues were completed in the last cycle” still cannot answer “should we use our remaining hours on the export feature or the performance bug?” without knowing whether they have 3 hours left or 12.

Adding HourTab to a Linear-based workflow takes the client from half-visibility to full visibility. They can see what was built (Linear) and they can see what capacity remains (HourTab). Those two pieces together eliminate the chronic admin of retainer status emails and the trust erosion that comes from clients feeling like they don’t know where they stand.

What type of developer benefits most from this combination

The combination of Linear + time tracker + HourTab is most valuable for:

Freelance software developers on monthly retainers. The typical pattern: one to five clients, each on a monthly hours retainer (15–40 hours per month), billing $100–$200/hr. Client conversations happen on a weekly cadence. The developer uses Linear for all work management. The missing piece is real-time hours visibility for clients.

Small dev shops with client retainer relationships. A two or three-person shop might run multiple client retainers simultaneously, each with its own Linear team and hours budget. Each client’s lead contact needs to know their team’s hours status without digging through project management software. HourTab gives each client their own URL with their own balance.

Developer-consultants who advise and build. Some developers sell both advisory time (architecture reviews, code reviews, strategic calls) and development time under a single retainer. Linear tracks the development work; advisory hours need to be captured in the time tracker and aggregated in HourTab alongside development hours, giving the client a single hours view regardless of which type of work was done.

The common thread is a monthly hours budget, a client who deserves to see it, and a gap between the developer’s work-management tool (Linear) and the client’s information need. HourTab fills that gap with a single URL.

FAQ

Can Linear track retainer hours for freelance clients?

Not in the retainer-billing sense. Linear tracks issues, cycles, and project velocity — not billable hours against a monthly cap. There is no monthly hours budget field, no billing cycle reset date, and no report that shows a client how many hours remain in their current retainer period. A developer who uses Linear for work management still needs a separate time tracker and a separate tool like HourTab to give clients a live retainer hours view.

What is the difference between a Linear cycle and a retainer billing cycle?

A Linear cycle is a sprint planning window — typically one or two weeks — used to group issues and track velocity (issues or story points completed per sprint). A retainer billing cycle is a calendar period (usually one month) during which the client’s pre-purchased hours are consumed. They don’t align with each other, serve different purposes, and are managed by different tools. Confusing the two leads to retainer relationships where the client doesn’t know their budget status because the developer is using the wrong concept as a proxy.

Does Linear have a public client view for retainer hours?

No. Linear has a viewer role that requires the client to create a Linear account. Even with viewer access, the client sees an issue board — not a retainer hours balance. Linear has no concept of a monthly hours cap, so there is nothing on the viewer screen that answers “how many hours do I have left this month?” To give a client a no-account, no-login hours URL, you need a tool built specifically for that purpose.

How do I give a retainer client their hours balance if I use Linear?

Run a time tracker (Toggl, Clockify, Harvest) alongside Linear to log billable hours. Export the time tracker’s CSV and upload it to HourTab. HourTab generates a public URL the client can bookmark. The URL shows hours used, hours remaining, cycle reset date, and the work log. The client checks the URL whenever they want to know their balance — they never need to email you to ask.

Can I use Linear and HourTab together?

Yes. Linear manages the development workflow — issues, cycles, roadmaps, bug tracking. A time tracker runs alongside to record actual hours. HourTab takes the time tracker’s CSV and turns it into a client-facing hours URL. The three tools cover three different jobs: what to build (Linear), how long it takes (time tracker), and what the client’s budget looks like (HourTab). They don’t overlap and they don’t conflict.

HourTab gives retainer clients a live hours URL from a time-tracker CSV — no login required. Works alongside Linear, Toggl, Clockify, Harvest, or any tool that exports a time-entries CSV. Free tier covers one client. Start free →