This article is all about making your developers more productive. You should mesaure productivity to ensure that they're getting work done in the most efficient way.
Tech companies are constantly searching for new ways to improve their software developers’ productivity.
That shouldn’t surprise anyone—more productive developers produce better results in less time, which means happy clients, satisfied stakeholders, and a better business overall.
However, instead of searching for the next big thing in boosting productivity, you might turn your attention to the common factors that can hold your developers back.
In this article, we’ll examine some of those factors and challenges they pose, as well as explain how to minimize their influence on developers’ productivity.
Table of contents
The ability to work on multiple projects and with many tools simultaneously is often regarded as a valuable skill.
However, relying on that kind of work process long-term can be detrimental to the productivity of software developers.
Context switching requires developers to switch between unrelated tasks.
Whether alternating between multiple projects or between code review and communicating on Slack, the effect is similar—impaired attention and drained productivity.
That’s because the human brain needs time to shift focus from one task to another. In computer lingo: the system needs to load the new context.
However, there is more to it. According to Sophie Leroy, there’s a phenomenon called attention residue.
As you can see, Leroy indicates that switching between contexts has consequences. After all, developers’ brains aren’t computers to reload at will.
She describes that attention residue causes poor performance. Those experiencing it don’t process information carefully, and the quality of their decisions goes down.
As a result, for example, a developer can spend an entire hour on a task that usually takes them 20 minutes to complete—which is not exactly peak productivity for anyone.
Furthermore, take a look at the chart below created by Gerald Weinberg. It shows how much time is lost switching between projects.
The situation is clear—the more context switching, the less time is spent on productive work.
The solution for that is also clear—try keeping your developers on one project or task at a time as much as possible.
You can do that by tweaking the work schedule. For example, as Vinicius Monteiro, software engineer at Hewlett-Packard, advises, it could be beneficial to nominate the Person of the Day.
In his team, that meant that each day, one person was in charge of customer support and infrastructure, the team’s two main activities.
The rest of the team could focus on other tasks, and the Person of the Day dealt just with those two activities. Lack of context switching resulted in more productive work overall.
The benefits of focusing on one task at a time are something that Synapse Studios experienced in their app development process.
As Kim Stearns, their Director of Product, explains, they usually assign a developer to one project at a time.
“Though many agencies dedicate developers to multiple projects in order to bill more time to more clients, we’ve found this comes at too great a cost to our team members and client outcomes to justify any short-term financial benefits.”
In short, context switching can seriously undermine software developers’ productivity. If you manage to minimize it, the speed and quality of their work will undoubtedly rise.
There isn’t a developer who’s fluent in every programming language or knows how to use every tool; that’s just common sense.
However, if they have big knowledge gaps, that could prevent them from achieving the desired results in the appropriate time frame.
Knowledge gaps can happen for several reasons.
Perhaps a developer is highly specialized in one area and nothing else. It might be that they don’t like to learn.
Or it might be because software development moves fast, and they didn’t catch up.
For example, the popularity of programming languages changes rapidly. Take a look at the video below, which shows the changes from 2004 to 2022.
Notice, for instance, how Python exploded in popularity in 2015. Developers who paid attention likely did what it took not to fall behind and became proficient in the language.
In other words, to stay productive, developers should learn and expand their knowledge continuously.
How can you then take advantage of your developers’ willingness to learn and close the knowledge gaps in your team?
You can start by identifying the areas where the knowledge gaps exist.
For example, with a tool like Vectorly, you can collect data on your team’s skills and then find them mentors and courses, as well as follow recommendations for improving productivity.
Also, you can provide opportunities for your developers to learn by allowing them to attend bootcamps.
Although bootcamps are typically seen as places where beginners can learn skills through intense learning, they can also be beneficial to more experienced developers.
The Quora user below can testify to that.
With fresh knowledge and new skills, the productivity of your developers will increase.
However, individual developers aren’t the only ones prone to knowledge gaps. They occur at the team level as well.
That can be the case when an experienced developer leaves the company.
They can take a significant amount of knowledge with them, and the rest of the team needs to adjust if they want to remain productive.
If you’re practicing pair programming in your team, you can mitigate knowledge gaps.
The more experienced developers can transfer at least a part of their knowledge to junior developers, and their productivity won’t suffer as much even if the senior partner moves on from the company.
Using tools like CodeStream, which allows annotations, feedback, and code reviews, can simplify that even more.
Developers with more knowledge and a broader skill set can do more, do it better, and deliver greater results. Therefore, closing knowledge gaps is something you should invest in.
Managers might think that meetings are essential for productivity and teamwork.
Still, the truth is often the opposite for the developers—a long and unnecessary meeting at the wrong time of the day can seriously impede their progress.
The core of the problem isn’t having meetings. In fact, if they’re well-organized and brief, they really can be very useful for everyone involved.
The issue stems from the difference between the manager’s schedule and the maker’s schedule.
According to Paul Graham, those are two types of work schedules that often aren’t aligned.
As he explains, managers tend to organize their time into one-hour blocks. On the other hand, makers, such as developers or writers, prefer larger time units—for example, half a day.
One hour is barely enough time to get them started, Graham claims. That’s why throwing a one-hour meeting in the middle of their morning will distract them and send them off course.
According to a survey by Stack Overflow, developers know that very well—they identified meetings as the second greatest challenge to their productivity.
Therefore, long and uninterrupted stretches of time where they can focus on their primary tasks are beneficial to developers’ productivity.
The easiest way to arrange that might be to reduce the number of meetings. As Henry Poydar advises, it’s important to assess if the meeting is really necessary.
“The important thing is to set some threshold for meeting necessity, share it with your team, and refine it as needed.”
Some companies are experimenting with meetings and trying out different strategies. For example, Shopify, an e-commerce giant, introduced No Meeting Wednesdays.
As David King, their Head of Diversity, Belonging, and Social Impact, explained, they did it to provide their employees with uninterrupted time for thinking, building, and creating.
Besides that, Shopify’s CEO Tobias Lütke likes to challenge the idea of recurring meetings and work routines, so he periodically deletes meetings in employees’ schedules.
Paul Dowman, the company’s Senior Engineering Manager, caused a debate on Twitter with the tweet you can see above, with many users questioning the reasoning behind that practice.
He clarified it further, as you can see below.
Even if Shopify’s experiments are too drastic for you, the thinking behind them can be valuable for your developers’ productivity—think twice about whether the meeting is necessary and if they need to be there in person.
If not, you can still engage them with the help of different tools. For instance, ZenHubs’s planning poker allows your developers to give their estimates when it’s convenient for them.
That way, you have one less item for your meetings, allowing your developers to be more productive.
Whether you make sure your meetings don’t interrupt the developers’ workflow while scheduling, use tools for checking in, or come up with a different solution, remember that meetings can disrupt the maker’s schedule—so try to plan accordingly.
Ineffective software tools
Just like handymen need their toolboxes with the essential tools, software developers need effective software tools.
Using the wrong ones can present a major challenge to their productivity.
Developers don’t like tools that waste their time, complicate their work, and simply aren’t good—and why would they?
Their job is complex enough without ineffective tools making it even more challenging.
As Ev Haus, Head of Technology at ZenHub, puts it, it can be frustrating to work while constantly overcoming various obstacles.
On the other hand, software tools that make a developer’s life and work easier, freeing up the time for more crucial tasks, are increasing in popularity more and more.
Those are the tools that automate repetitive and time-consuming tasks. For example, Pipefy is a tool for workflow optimization that automates simple tasks.
As you can see below, it uses a system that is well-known among anyone familiar with coding—if/then rules.
In the software development process, it can help by automating the statuses of tasks and projects so that everyone in the team knows who’s doing what and how it’s progressing.
For example, if a developer moves a card with a task to the “In progress” phase, the whole project automatically updates to that phase.
If/then rules can be applied that way to automate any events in the Pipefy interface.
In addition to workflow automation, fixing bugs is another important but time-consuming part of a developer’s job.
That’s where our own product, Shake, can be extremely useful.
Shake automates the often inefficient process of bug reporting.
In the past, when a user reported a bug, the process looked something like this:
- They would take a screenshot of the issue.
- They would go to their email app.
- They would describe the issue, attach the screenshot, and provide some information about the context the issue appeared in (if they could remember).
- Your developer would get a report and still need some information so that they would message the user back for clarification.
That back-and-forth could go on for some time, and it would impact productivity. With Shake, a user just shakes their phone when they encounter a bug, and the tool does the rest.
It automatically attaches all the information a developer might need, including a screenshot, their activity history, permissions, app version, etc.—over 50 pieces of information.
As you can see, effective software tools like Shake can significantly boost your developers’ productivity, allowing them to use their time on challenging tasks while removing tedious obstacles along the way.
Multiple sources of truth
An important factor in developer productivity is how easily they can access relevant information during their work.
Having essential data scattered across multiple sources can make developers significantly less efficient.
They should be able to access everything needed for their project quickly.
That’s even more important if you have a DevOps team; all the departments and people included should be on the same page if your goal is to have a productive team.
Otherwise, your developers can end up dealing with information silos, where every department works with their own data, without communication and teamwork.
Multiple sources of truth will increase confusion and time-wasting instead of productivity.
The solution for that is to go the other way and have a single source of truth.
When it comes to software development, that ensures that developers are up-to-date, have the same context, and, therefore, the speed and quality of development increases.
As you can see below, a single source of truth can include information about customers, design and development, various analytics, etc.—all of which can be valuable for developers.
How to keep all that information in one place so it’s easy to access? Collaboration tools like Confluence can be a great solution.
You can store all the information you want in it, embed Word, Excel, or Google Drive files, share work, plans, agendas, etc.—basically, have everything relevant in one place, accessible to everyone in the team.
For example, Rockwell Automation uses Confluence as a central hub for sharing best work practices.
Jim Tompkins, their Senior Test Manager, described how teams use Confluence to collaborate.
A single source of truth like that allows everyone to share ideas and suggestions, making them more productive in their work.
Many popular tools also have features that allow them to integrate with other tools, making them valuable options for establishing a single source of truth.
For example, you’re most likely familiar with Slack. It’s a great tool for communication, but it doesn’t automatically spring to mind when discussing hubs of knowledge.
However, thanks to integrations, it can be very helpful in that regard.
For instance, Free Now’s developers use Jira for project management, and integrating it with Slack provides them with a convenient source of information.
As you can see above, developers get a notification in Slack when something changes in Jira, so they’re updated, and productivity doesn’t suffer.
Carsten Wolfram, Free Now’s former Audiovisual Architect, explained that combining tools into one source of truth like this makes things much easier.
There’s no need to switch between tools and apps, and missing something important doesn’t happen anymore.
With multiple sources of truth, all of this is much more challenging. Developers unnecessarily waste time and patience searching for information while productivity takes a hit.
Software development requires complex skills, a lot of focus, and patience—and that’s just if we scratch the surface.
That’s why it isn’t easy to maximize developers’ productivity; many factors influence it every day.
Luckily, you can significantly reduce the influence of those factors.
By reducing context switching during work, closing the knowledge gaps, carefully planning meetings, providing effective software tools, and avoiding multiple sources of truth, you can raise your developers’ productivity to new heights.