Little things in software development are important, sometimes really important. Little things can seem so small that they don't deserve attention, tiny little tasks that can take seconds to do. If however these tasks a repeated over and over again, that time can add up.

Let's have an example: an internal application at your company is used by front line support staff, the phone rings, they go to the application, then:

• Move the mouse cursor to the search box and click it (1 second)
• Type in the customers name (3 seconds)
• Move the mouse cursor to the search button and click it. (1 second)

That whole process takes 5 seconds, which isn't long at all.

Lets assume the following:

• There are 20 staff and they each take 50 calls a day, that means this process happens 1,000 times a day.
• Each member of staff works 5 days a week, 47 weeks a year, so 235 days a year
• 1,000 times per day * 235 days a year makes 235,000 times per year
• Doing a 5 second process 235,000 times gives 1,175,000 seconds, or 19,583 minutes, or 326.38 hours
• A day of work is 8 hours, so the equivalent of 40.8 days of work go into doing this process per year

Now lets tweek the user interface just a little.

First, we change the initial screen so that the search box defaults to having focus instead of the user having to click it.

Second, we make it so that hitting the return key does the search so that the user doesn't have to click the search button.

Typically these changes would take minutes to make to your user interface.

Our user journey then becomes:

• The search box already has focus, user doesn't have to click on it (0 seconds)
• type in the customers name (3 seconds)
• Press return from the search box. (0.5 seconds - key presses here are quicker than mouse clicks)

The process goes from taking 5 seconds to taking 3.5 seconds. 3.5 seconds * 235,000 times gives 822,500 seconds, or 13,708 minutes, or 228.47 hours, or 28.55 days of work (at 8 hours work per day). That's a saving of 12.25 days work across a year. Cool.

Take away points

Sometimes very small and simple changes can actually have a large effect. The big things are important, but don't forget the importance of the little things.

The example here is geared towards creating a user interface that saves time, but really the point is that if you find yourself repeatedly doing a task, then it's worth looking to see if you can do it more quickly. As a developer, there are lots of other things that can save time in repetitive tasks:

• learning shortcut keys instead of relying on the mouse
• making your local builds happen more quickly (Like by turning off code analysis)
• making your automated tests run more quickly by focusing more on unit tests and less on integration tests ( e.g. Agile test pyramid )
• creating batch files to perform actions that you regularly do (or regularly forget how to do)

Got any more time savers? Let me know!