Billable hours are the ones a client pays for. Non-billable hours are everything else that still has to happen — internal meetings, admin tasks, estimating work you haven’t won yet, rework nobody’s paying for. Both are work. Only one ends up on an invoice.
Jira doesn’t know the difference. It logs time, and that’s where it stops. No billable flag, no rates, no client.
So every team that bills by the hour builds the split themselves. There are three ways project managers track billable hours in Jira, and all three are in use right now by teams of every size. Here’s what each one costs you.
Option 1: Do it natively, with a custom field
You can get surprisingly far with nothing but Jira Cloud. There’s a workaround that’s been going round the Atlassian Community for years:
- Create a custom field of type Select — call it Spent Hours Type — with options for billable and non-billable work.
- Create a second select field for the correct client, if you work with more than one.
- Tag your Jira issues with both.
- Build a filter on the field value, and there’s your report.
It’s free, it’s searchable with JQL, and for a team running one client per project it genuinely works for billable hour tracking.
Where it falls over: : the flag sits on the issue, not on the hours. 🙄
The moment one ticket holds both — three hours building the client’s feature, one hour in an internal review — you pick one and the number stops being true. Teams respond by splitting assigned tasks, which means creating admin work to fix a reporting problem.
It also relies on everyone remembering to set a field that has nothing to do with finishing their work. And the setup isn’t entirely free of admin: custom fields come out of a shared pool with a maximum number per instance, time tracking can be switched off or the field hidden from the screen, and who sees what still runs through your permission scheme.
Option 2: Use a Marketplace app
The workaround mentioned above isn't ideal, so many teams resort to marketplace apps to track billable vs non-billable hours. The main difference between all such apps lies in the following: where the flag lives.
Some apps put it on the project — everything logged there counts as billable, with exceptions marked one by one. Tempo Timesheets puts it on a separate account you log against, with its own Billable hours field whose visibility depends on a permission, so expect some timesheets configuration before anyone logs a thing. ActivityTimeline, built by another Atlassian partner, surfaces it in the time tracking dialog where people record what they worked on.
All of these work, and all of them get awkward the moment a single project mixes billable and non-billable time.
In Planyway for Jira, the flag sits on the time entry itself, and the reasoning is simple: people don’t work on billable projects and non-billable projects.
They work on a ticket, and part of what they did on it is chargeable. Three hours building the client’s feature and one hour in an internal review can sit on the same Jira issue without anyone splitting tickets or picking a side.
The point of flagging it, though, is reading it back. The billable split runs through the time tracking reports, so you can pull the time spent for a period and see billable and non-billable side by side — grouped by person, project, epic or date, filtered to whatever you’re invoicing for.
Here's what the Tracked time report looks like in Planyway:
➡️ Try Planyway free
Same place you’d already go to answer “what did the team spend time on”, now with the time data finance needs in the same view. Export it to Excel or CSV when it’s time to raise the invoice.
And every entry is still a standard Jira worklog, so nothing lives in a parallel system.
Worth saying plainly what this doesn’t do. If what you need is rates, budgets, and invoices generated out of Jira, there are billing-focused apps built for exactly that, and they’ll serve you better than we will. The split is the foundation — it isn’t the whole finance stack.
Option 3: Export it and finish the job in a spreadsheet
Say what you like about this one. It’s what most teams are actually doing.
Export the worklog hours, paste in everyone’s rate, sum by epic or by client, build the timesheet report, and send it. We heard the same routine from a bank’s PMO, a 40-person outsourcing team, and a product agency. All three log time in Jira, all three finish the month in Excel or Sheets.
And here’s the part nobody mentions: you end up in a spreadsheet even with an app. Tempo’s own tutorial ends with the report exported, so accounting can build the invoice from it. The question was never whether a spreadsheet is involved — it’s how much typing happens inside it.
What it costs: roughly a day a month of somebody’s time, and it’s time consuming in a way that’s easy to normalise. It’s also error-prone in ways nobody notices. A rate that didn’t get updated. A person who logged nothing that week. A line pasted under the wrong client. Every one of those is either undercharging clients or a number you’ll defend to a client later.
If this is your setup, at least start from a sheet that already has the structure — hours, rate, billable flag, client — instead of rebuilding it monthly.
So which one?
- One or two clients, small team, simple billing. Custom field plus a monthly export. Don’t overbuild it.
- Several clients, billable and non-billable time mixed inside the same work. An app, and specifically one where the flag sits on the time entry.
- Rates, budgets, invoices, project profitability. A billing-focused app. The split alone won’t get you there.
Whatever you pick, the numbers are only as good as the logging — which deserves more attention than the tooling does.
Make the numbers worth looking at
- Write clear definitions before you need them. Is a client call billable? A bug you introduced? Scoping future projects? Agree it once instead of re-litigating it every month.
- Give internal work somewhere to go. If there’s nowhere to log a team meeting, it lands on whatever client ticket was open. Worse than not tracking it, because now your total billable hours are wrong and nothing shows it.
- Log work when you switch tasks. Reconstructing Thursday on Friday is where rounding starts, and rounded time entries are how an invoice drifts from what happened.
- Compare estimated hours with logged hours. Not to grade team members — to find where your expected hours and the real ones part company. That’s what makes the next quote closer to the truth.
- Put a light approval workflow in front of the invoice. A team lead who can confirm billable hours catches the entry logged against the wrong client before your client does. Cheap insurance for client trust.
- Send two reports, not one. Clients want something readable. Finance wants detailed billing reports with every line. One team we spoke to kept sending clients a progress view so granular that nobody opened it.
- Regularly review the ratio, not the total. Billable hours tell you what to invoice. The share of billable work tells you whether the delivery model works. If it slides month after month, the problem is upstream — estimates, scope, or rework you keep absorbing. Put it next to your delivery metrics: when cycle time and lead time stretch at the same time as the billable share drops, you’re not looking at a billing problem, you’re looking at a process one.
That last one also matters beyond billing. If a third of your team’s time goes to non-billable tasks, your resource allocation is built on a number that was never real, and every planning decision after that inherits the error — which is why the billable data belongs next to the timeline view you plan from, not only in the finance folder.
Over to you
Which of the three are you on? And for anyone who moved from a spreadsheet to an app: did the manual work disappear, or just move somewhere else?
Drop a comment below — you’ll need to sign in or register to post, and it takes about ten seconds to register and get started.
