I’ve worked as a full-time freelance software consultant for around ten years, and I still don’t feel like I’ve solved the problem of how best to bill for my labor. I don’t think an hourly rate, with its built-in time-tracking overhead and its frustrating disconnect between the value of my time and the value of the deliverable, always represents the best approach. And yet I keep returning to it, however begrudgingly, in part because every client understands it. Today I use a Mac app called Timing to track my billable time, finding it the best approach to mitigating the pain of this chore, if I must continue doing it.
I began my career with a naive time-and-materials billing style, declaring a single hourly rate and billing with strict adherence to it. Those with any experience at all with this sort of thing will know why I started casting around for other billing strategies not long after. At one point I got the flat-project-rate religion, thanks to the persuasive arguments of Breaking the Time Barrier, a book that well understands how strictly hourly billing can so easily feel off-balance between work performed and work billed. But that blew up in my face! Unpracticed with drafting up larger single invoices than I’d ever created before, I ended up losing money on multiple projects, falling into painfully awkward situations with both clients and subcontractors. It burned me badly enough that I will probably never attempt project-rate billing again, at least not as my default stance towards new work.
I’ve also experimented with billing where I block out a whole week at a time and declare myself dedicated to the client for that whole week in exchange for a delightfully round-numbered invoice. This works well enough that I continue to keep it in my toolkit for those rare times when a project really does require full-time-equivalent attention for that long. My attempt to permanently “candy-stripe” my calendar into a repeating cycle of client-dedicated weeks didn’t work, though. In this scheme, Freelance Client A got the first week of every month, my nonprofit got the second, then Freelance Client B, and then personal projects enjoyed up the final week-and-change. A fine idea in theory, and I don’t regret trying it — but the lack of flexibility led me to abandon it after only a few laps. Having even only a few clients (and treating myself as one of them) requires the ability to switch contexts with more graceful speed than this plan easily allows.
The most comfortable billing pattern I’ve found is the sort of monthly retainer agreement where the client agrees to pay a pre-arranged amount month after month, and I do my best to deliver enough value to the client that they feel they get their money’s worth every time. At regular intervals — every six months or so — we revisit this arrangement to extend it, adjust it to the satisfaction of both parties, or just cancel it.
This sort of pseudo-salary brings the benefit of removing surprising variance from one’s monthly invoices, but it rolls me back into the need to track time. I still need to document my work for the client’s sake, and I also must keep the ability to justifiably claim “overtime” on months with an unexpectedly heavy work-load. Pair this with the fact that I have at least one client who has turned down all such retainer proposals from me, preferring the uncertainty but simplicity of good old hourly billing, and I find myself unable to put away my time-tracking tools.
Which brings us to Timing, and why I like it. What frustrates me so about all the timing tools I’ve used before this one? In a word, overhead. I must always dedicate a running sliver of my attention to starting and stopping that timer when appropriate, keeping it up-to-date with my current project-list, and making sure it’s always pointed at the task of the present minute, even as the many-sourced external demands on my attention roil and bubble at their usual rate throughout the workday. When it worked, it felt like a mildly buzzing annoyance all day long, and when it didn’t work — which is to say, I forgot to turn on the timer, or turn off the timer, or switch the timer’s current task, all of which are very easy to forget when I’m trying to get real work done — my annoyance would bloom into frustration.
In summary, working like this carries a subtle but very real ongoing expense, injecting unwelcome uncertainty into time-measurements while stealing a little bit of one’s attention all day long. Boy, did I not enjoy any of it.
Timing acknowledges this cost of using typical timers, and proposes an almost inverted sort of user interaction in order to mitigate it, one where you let it make and record its best guesses about how you spent your time, and you regularly — but not continuously! — check in with it to refine its output and improve its future estimates. For me, it pushes the task of accounting for my time into exactly that, a task, bounded with a beginning-time and end-time of its own. I vastly prefer this over managing with a thin paste of sticky meta-task spread over my entire day.
Timing runs in two parts: an always-on daemon process, and a front-end application. The daemon watches all your user-level Mac activity, taking especial note of things like the applications you have in focus, the titles of the webpages you read or the documents you work on, and the names in the emails you read and write, all minute-by-minute. And then when you’re ready to take stock of the day’s work — right before going home, say, or over coffee the following morning — you view a report of your activity using the graphical Timing app. It presents your day with three parallel timelines: A series of blocks representing the apps you had open, switching around in real-time; another block-series where Timing guesses which of your tasks you were working on, based on the first timeline; and then an empty line that you fill with your own task-associated time-blocks, using the first two timelines to guide you. When you finish, Timing treats only the third timeline as “canon” for the monthly per-client reports that it can generate.
During this same time-assignment view, Timing presents clever ways to let you permanently assign keywords, applications, and other cues to certain tasks. For example, I have set Timing so that when I have a Terminal window focused and logged into a certain remote Linux machine, it should consider me busy with the freelance client to whom that machine belongs. After a bit of initial setup, Timing quickly guesses your activity correctly enough — even if you bounce around among windows and applications constantly, like I do — that it takes only a few minutes of focused attention to properly fill out that third timeline for any given day. I love this. Through these methods, Timing lets me work on this stuff when I’m ready to do so, and only then.
The app also lets you assign a zero-through-five “productivity” score to each task-category, which powers a dashboard-view with lots of fun bar graphs, and a daily percentage-score of how productive Timing thinks you think you are, and so on — but I consider all that candy. It also offers some shortcuts to create invoices for you, but I don’t use that either, preferring my comfortable old FreshBooks account for that sort of direct-to-client interfacing. Per its name, meat of Timing is its timer, and the ingeniously upside-down way one works with it. I might not be able to escape time-and-materials billing as a freelancer, but with this tool I can at least scrape most of the burden of it out of my brain, and this alone I find worth every penny of Timing’s purchase price.