Developer Time Tracking: VS Code, WakaTime and Billing
Time tracking for developers breaks in a specific way: the work is fragmented, deep, and spread across a dozen tools, so the start/stop timer (the thing most time trackers are built around) is the first casualty of a focused coding session. You sit down to fix a bug, surface three hours later, and the timer either never started or has been running since lunch. Good developer time tracking doesn't ask you to remember; it records what you did and sorts it afterward. The honest fix is a method that captures your work whether or not you remember to.
Why timers fail for software developers
A coding day is a stack of interruptions, and the research on what they cost is sobering. Gloria Mark's work at UC Irvine found it takes an average of about 23 minutes to return to a task after an interruption (23 minutes and 15 seconds in the original study). In her later studies, the average time someone spends on a single screen before switching attention has fallen to roughly 47 seconds (down from about 2.5 minutes in 2004) documented in her 2023 book Attention Span. And the interruptions aren't all external: Mark's research found we interrupt ourselves roughly as often as others interrupt us.
For a developer, that translates into dozens of context switches a day: VS Code to the terminal, terminal to a failing test, test to a Stack Overflow tab, tab to a Slack ping, Slack to a Jira ticket, and back. Psychologist Sophie Leroy named the lingering cost of those jumps attention residue: part of your mind stays on the previous task after you've moved to the next one. A start/stop timer asks you to add one more deliberate action (remember to click) to a day already defined by not remembering where the last twenty minutes went. It's close to the worst possible tool for the job.
What developer time tracking actually has to capture
Here is the part most tools get wrong. A software developer's billable time covers far more than the minutes spent typing code. It's the PR review in the browser, the architecture discussion in Linear, the debugging session in a terminal, the deploy you watched in a CI dashboard, the client call on your calendar. If a tracker only sees one of those windows, it undercounts the work, and undercounting is a revenue leak that always rounds in the client's favour.
So the real requirement for time tracking for software developers is coverage: it has to see every window you cycle through, not only the editor. Then it has to do something useful with that raw timeline (sort it into the right client or project) without becoming a surveillance dashboard your manager reads.
Automatic time tracking for programmers: the main approaches
Most developer-friendly trackers are some flavour of automatic, but they differ in what they watch and what they do with it. Here is how the common options compare. Pricing shifts often, so confirm the current number on each vendor's page before you commit. Prices here were checked September 5, 2026.
| Tool | How it captures | Scope of capture | Sorts time to clients/projects | Free plan |
|---|---|---|---|---|
| WakaTime | Automatic, editor/IDE plugins | Coding inside the editor only | Coding stats; invoices on Premium | Yes (limited history) |
| RescueTime | Automatic, background | Every app and website | Productivity reports, not client billing | Yes (Lite, individuals) |
| Timely | Automatic ("Memory") + AI | App and website activity | Yes, AI-drafted project time | No (trial only) |
| Memtime | Automatic, fully local/offline | All computer activity, on-device | Yes, manual project assignment | No (trial only) |
| Toggl Track | Start/stop timer (+ private Timeline) | Timer entries; Timeline is a memory aid | Yes, timer-based | Yes |
A few honest notes on each:
- WakaTime is the developer-native option, and it does its job well: automatic coding stats pulled straight from plugins for 80+ editors and IDEs, with no timer to start. The trade-off is scope: it measures activity inside the editor, so the browser PR review, the Jira ticket, and external terminal tools aren't counted as time. Its free plan keeps only a short window of recent dashboard history; unlimited history and invoices live on the Premium plan (around $12/month billed monthly, or $99/year. Confirm current pricing on WakaTime's site).
- RescueTime captures everything automatically (every app and website in the background) but it is built around productivity reporting and focus scores, not mapping hours to clients and projects. It does have a free tier (RescueTime Lite) for individuals; paid Premium for one person runs roughly $6.50 to 12/month depending on billing, with a 14-day trial of Premium. Confirm the current numbers on RescueTime's site.
- Timely uses automatic capture (its "Memory" feature) plus AI categorisation to draft project time for you. It is a capable per-user tool priced from $11/user/month (Starter) up to $28/user/month (Unlimited), with a free trial but no free plan.
- Memtime records all computer activity automatically and keeps the raw data offline on your own machine rather than in the cloud: a strong privacy stance. It has no free plan and costs $18 per user per month billed annually (checked September 5, 2026).
- Toggl Track is worth naming because it is popular with developers, but it is fundamentally a start/stop timer. It does offer an optional desktop Timeline that privately records your app and website use as a memory aid (useful for reconstructing a day) but that data is private to you and does not bill by itself. It has a free plan and paid tiers at $9 and $18 per user per month.
The pattern is clear: the tools that don't depend on you remembering (RescueTime, Timely, Memtime, and active-window trackers generally) all use passive, automatic capture precisely because it survives a deep-work session. The ones built on timers are accurate only when your discipline is.
Developer time tracking without timers
The approach that fits a coding day is passive time tracking: a lightweight desktop app records the active window (the app and window title in the foreground, and how long it stayed there) and reconstructs your hours from what you actually did. There is no timer to start, so a three-hour debugging tunnel doesn't vanish from your records.
Passive time tracking for coders only earns its keep if it does two more things after capture:
- It categorises automatically. Raw windows aren't billable hours until they're sorted into the right client or project. Keyword rules handle the deterministic cases (a repo name, a ticket prefix, a client's domain) and AI can sort the fuzzy remainder.
- It respects the data. A developer's window titles are sensitive: branch names, file paths, client names, private tabs. The right tool lets you keep titles on-device and records the active window only: no screenshots, no keystrokes. That is the line between personal tracking and surveillance.
Done that way, the output is a complete, sorted record of where your time went, built with zero timer clicks.
VS Code time tracking without an extension
You don't install anything inside the editor. The desktop app is a background automatic time tracker that reads the active window title the operating system already exposes, and VS Code writes a useful one: auth.ts - billing-service - Visual Studio Code. That single string carries the file you had open and the workspace folder around it, which is usually enough to know which client the hour belongs to.
The sorting runs on a keyword rule. Every project holds a list of keywords, and when the folder or repo name in a title matches one, the time lands on that project on its own. Add the billing-service folder as a keyword on your Acme project, and every VS Code window from that repo bills to Acme with nothing left to click. Cursor, Windsurf, Zed, and any JetBrains IDE behave the same way, because the capture is the window title, not a plugin. It runs identically on Windows, macOS, and native Linux, so the editor and the operating system you code on don't change the method.
Here is the honest limit. Because it reads the title and not the editor's internals, it attributes time to the editor and usually the file and project, but it cannot break the hour down by programming language, git branch, or commit. There is no per-language chart. If you want one, an editor-plugin tool is the right pick; if you want the hour on an invoice, this is.
Tracking coding time across terminal, browser and editor
A coding hour is rarely one window. You read a failing test in the terminal, check a library's docs in the browser, review a pull request on GitHub, then drop back into the editor. A tracker that only watches the editor bills the smallest slice of that hour.
The desktop app already sees the terminal, because it captures whatever app is in the foreground by name, so iTerm, Windows Terminal, or a plain shell all count as worked time. For the browser, the Chrome extension reports the domain of the active tab (github.com, the docs site, your staging URL) and nothing else by default, so research and PR review get sorted to the right project instead of falling through the cracks. Map a domain to a project the same way you map a folder name, and those tabs bill themselves.
Once the hours are approved they can travel onward. The Jira integration pushes tracked time back to the matching issue as a worklog, so the ticket and the invoice tell the same story without you entering the numbers twice.
WakaTime alternative for freelancers who bill
WakaTime and CodeTime are good at a job BillNotch doesn't do. Their editor plugins read from inside VS Code and JetBrains and report per-language, per-file, per-branch stats, leaderboards, and streaks. If you want proof that you wrote Rust for six hours this week, use one of them. Neither one sends your client an invoice.
That is the split worth stating plainly. WakaTime is an analytics dashboard for how you code; BillNotch is a billing tool for what you're owed. It captures coding time automatically across every editor and app, sorts it into client projects, and turns the approved hours into a PDF invoice with an optional payment link. The trade is real: you give up the per-language breakdown and you get the hour on a bill.
For a freelancer, that second half is usually the one that pays rent. Sanity-check what a project's hours are worth with the billable hours calculator first, then let the tracker keep the running total so you're not rebuilding the month from memory. And if the language stats still matter to you, nothing stops you running WakaTime for the insight and BillNotch for the billing at the same time.
From captured time to a paid invoice
Capturing time is only half the value for anyone who bills. Once a tracker already knows what you worked on and which project it belongs to, it can total the billable hours and turn them into an invoice: no re-typing, no spreadsheet at month end.
BillNotch is built for exactly this loop, and for the way developers actually work. It runs on Windows, macOS, and Linux (native Linux included, which many trackers skip) and records the active window automatically with no timer to start. Keyword rules plus optional AI sort your activity into client projects; billable status is inherited per project, so the live billable total is always current. That total becomes a PDF invoice or a CSV export in a click, and the Revenue Leak Finder flags billable time you tracked but never invoiced: the hours that usually slip away. On privacy, window titles can stay on each device, you connect every machine with an API key you issue and revoke, and keyword matching runs on the device while the similarity check runs on our own servers. Only when you ask for AI suggestions on the review screen can genuinely novel activity reach a language model, and titles are never sold or used to train models. The privacy policy has the full detail.
It isn't the cheapest option on this page. Pro is $9/month for one seat and Team is $12/seat/month, with a 14-day free trial and no card required, and tools like WakaTime or RescueTime do their narrower jobs well. The case for BillNotch is the whole loop: automatic capture across every window, auto-categorisation into billable projects, and an invoice that writes itself, on flat pricing with no usage fees.
If you are weighing options, it is worth reading what passive time tracking is, how automatic tracking software works, or how BillNotch compares to an automatic tracker like Rize. The right tracker for a developer is the one you never have to think about, because the work already demands all the thinking you've got.
Frequently asked questions
Can you track VS Code time without an extension?
Yes. A desktop tracker reads the active window title the operating system already exposes, and VS Code writes a useful one that carries the open file and the workspace folder. A keyword rule on the repo or folder name sorts that time to the right project on its own, so nothing is installed inside the editor and no plugin has to run.
Does developer time tracking capture terminal and browser time?
It should, because a coding hour is rarely one window. An active-window tracker sees whatever app is in the foreground by name, so the terminal counts as worked time alongside the editor. A browser extension can report the domain of the active tab, so pull-request reviews and documentation get sorted to the right project instead of falling through the cracks.
Is BillNotch a good WakaTime alternative for developers who bill?
They solve different problems. WakaTime reads from inside your editor and reports per-language and per-file coding stats, but it does not send an invoice. BillNotch captures coding time automatically across every editor and app, sorts it into client projects, and turns the approved hours into a PDF invoice. If you bill clients, BillNotch fits; if you want language charts, keep WakaTime.
Does automatic time tracking work on Linux for developers?
Yes, though the field is thin. Most automatic trackers skip a native Linux desktop app, so Linux developers end up on a web timer. BillNotch ships a native Linux tracker alongside Windows and macOS and records the active window the same way on all three, so the operating system you code on does not change the method.
Does BillNotch have a VS Code or WakaTime plugin?
No. BillNotch installs nothing inside your editor and ships no VS Code extension or WakaTime-style plugin. Its desktop tracker reads the active window title the operating system already exposes, which for VS Code carries the open file and the workspace folder. That means no per-language or per-commit charts the way WakaTime does them, but also no editor plugin to maintain, and it captures every app you use, not only the editor.
What is the best time tracking software for engineers?
It depends on what you need from the data. WakaTime is best for per-language and per-file coding stats inside the editor, but it does not invoice. If you bill for the time, BillNotch captures coding hours automatically across editor, terminal and browser, sorts them into projects, and turns them into a PDF invoice.
How to track developer productivity?
Editor plugins like WakaTime measure coding activity per language and file, which is useful for personal insight. For billable output rather than keystrokes, an active-window tracker records time across the editor, terminal and browser and sorts it into client projects, so you see the hours that turned into deliverables.
What is the best way to track time on projects?
The reliable way is passive capture, not a timer you must remember. A desktop tracker reads the active window, so time in the editor, terminal and browser is recorded automatically and sorted to a project by a keyword rule. You review the drafted entries and confirm them, so nothing is forgotten.