In Praise of the Timebox

You may have heard before that when you work in software development, you eventually build up a sort of "mental toolbox." The more you try out different tools, the more you familiarize yourself with them and know when to apply the right tool for a specific task at hand. One of the most valuable tools I've found myself reaching for over the years is to use the technique of timeboxing.

The concept of timeboxing is extremely simple - within a given task, you limit the maximum amount of time that you're willing to spend on that task.

For example, I may dedicate an hour to adding extra flourish to a congratulatory screen after a user signs up for a product. Once that hour passes, it's "pencils down" mode. If I'm done, great! But if I'm still working on it, too bad. I can save my progress and potentially come back to it in a future task, but for now I've spent all the time I'm willing to allocate to this request.

Given that this concept is so simple, why is it so powerful? I think it's because writing software involves a lot of uncertainty. Software developers are notoriously terrible at providing estimates for code, and timeboxing allows for freedom of exploration within a task that may seem daunting.

Let's take a look at some of the types of tasks I frequently find myself timeboxing:

• Front end designs. If a designer has a mockup with an unusual interaction or layout that I suspect is difficult to implement, timeboxing lets me say "let me give this a shot for an hour or two" rather than a flat out "no, we can't do this". Sometimes I'll surprise myself and the interaction is easier to implement than I expected. Other times I'll have to forgo this request and either abandon it altogether or save it for another day.
• Refactor suggestions from code reviews. There are many code review comments I receive where teammates have suggestions for refactoring a particular piece of code, but they don't consider it a blocking suggestion for the code review. These suggestions can fall anywhere on the spectrum of impact: from having little/no side effects to refactoring critical areas of the system. If I'm unsure of the impact, timeboxing lets me investigate this difficulty without being beholden to polishing every bit of code to pristine levels before being able to merge it.

What do both of these examples have in common? In general, they're tasks that are nice-to-haves rather than need-to-haves in terms of importance, as well as being fuzzy in terms of amount of effort they'll take to solve. These qualities directly tie into why exactly I find timeboxing so useful:

• Focus on what's truly important within a request. Just because the design of the submit button on the form isn't 100% implemented to spec, that shouldn't prevent all of the rest of the work from the form from being shipped. By timeboxing more fringe aspects of a feature request, you're finding that right balance between "we've done our due diligence on this and have decided to delay/forgo it" and "this can't ship until it's absolutely perfect according to the spec."
• Embrace unexpected ease of implementation. I happily admit that I don't always know how difficult a task may be. I'm pleasantly surprised when implementing I thought was going to be difficult turns out to be easy. This saves me from giving up on a task too eagerly. Sometimes when you say "we'll do this in another task" that day never comes, especially on teams where tackling tech debt is viewed as a luxury rather than a necessary practice within software development.

And there we have it, timeboxing! Drop a comment to let me know what you think - do you use timeboxing yourself? If so, what has your experience been like?