Why developers procrastinate and how to help them

We’ve all been there—there’s a huge task to finish, but instead of diving right in, we find ourselves doing other things instead.

Before we know it, hours have gone by, and nothing has been done except for maybe some Reddit browsing—and then panic sets in as stress levels shoot through the roof.

Procrastination happens to everyone, and it’s not necessarily a bad thing, especially when we’re in need of a break and have to recharge.

But for developers, procrastination represents an ever-present threat and can be a big detriment to their productivity.

Developers, like any other professionals who rely on creativity, mental focus, and problem-solving, find themselves challenged by procrastination on a daily basis.

That’s why in this article, we’ll talk about the most common reasons why developers get distracted and how tech leads can help them focus.

Why developers procrastinate

Many developers are habitual procrastinators, putting off projects until the last minute and then scrambling to get them done before a deadline.

However, it’s important to note that this isn’t a sign of lack of self-discipline, as it’s often considered.

Developers procrastinate for a variety of reasons, which can typically be divided into a few
broad categories:

• lack of interest
• discomfort
• fear of failure
• excessive bureaucracy
• confusion regarding exactly what needs to be done

In the following five sections, we’ll discuss how each of these categories can contribute to a developer’s tendency toward procrastination.

Disinterest in their task

When developers find the tasks they’re working on uninteresting, it can be difficult for them to stay motivated, and easy to get distracted by things outside of work.

This can lead to a decrease in productivity and quality of work, as well as an increase in their tendency to procrastinate.

In fact, one study found that about 50% of people procrastinate because they think the task is boring or unpleasant, or that the rewards and punishments it incurs are far off in the future.

The same goes for developers—if they don’t feel connected with their work, procrastination is much more likely to happen.

For example, if they’re given the task of fixing a bug in an app developed by another team, it may not be interesting enough to motivate them.

Or, if they’re asked to add features to an application that they think will never be used, they also won’t be very inclined to do it.

Adam Nathaniel Davis, a front-end software engineer at Amazon, is on the same page with this when he states that procrastination has little to do with self-discipline, laziness, or lack of character and more with interest and motivation.

The author points out that when people are invested in something or passionate about it, they tend to dive right in with eagerness and enthusiasm.

But when a project doesn’t appeal to them, it can be tempting to avoid it altogether and do something else instead.

All in all, procrastination and lack of interest often go hand in hand, particularly when the task doesn’t get the developers’ creative juices flowing.

Avoidance of discomfort

For some developers, the prospect of having to work on difficult or unpleasant tasks can be so uncomfortable that it becomes easier for them not to do anything at all.

For example, legacy code—code whose functionality has been changed many times by different developers—can be a nightmare for developers.

Because of this, developers may be reluctant to tackle the work of refactoring and may pursue activities that feel more pleasant instead.

For example, in his blog post Overcoming Procrastination as a Developer, web developer John Amiscaray describes how he had been putting off refactoring a large part of the project that he was working on.

Although he understood the importance of refactoring and how it would improve his code, he kept postponing it because the job seemed simply overwhelming.

On the other hand, Adam Nathaniel Davis, whom we’ve already mentioned earlier, found that he had a tendency to procrastinate when his colleagues were causing him discomfort.

For instance, once, he had to start working on a new CI/CD process, but the coworker who was in charge of setting it up didn’t respond to his emails and Slack messages.

Although the project excited him and seemed important, he was putting it off as long as possible because he struggled with dealing with that particular coworker.

The bottom line here is that discomfort can be a huge roadblock to developers’ productivity.

If a developer feels uncomfortable about anything—a project, a task, someone or something else—it can be really hard to get started working on it, and then procrastination easily sets in.

Fear of failure

Fear of failure is one of the most common reasons why people, not just developers, put off doing things.

The link between fear of failure and procrastination has been well established.

People often use procrastination to avoid facing the prospect of failing. If they never start the project —they’re guaranteed not to fail!

However, this is a vicious cycle—the more people procrastinate, the more likely it is that they’ll make mistakes.

And then those mistakes increase the fear of failure, and thus the motivation to avoid doing things increases.

Fear of failure is often accompanied by a perfectionist attitude.

In today’s information age, a lot of developers see perfection as an attainable goal and often strive to write the perfect code.

But perfect code is a myth as even the best developers produce code that includes a certain degree of bugs and errors.

Szymon Adamiak, the co-founder of HYPE4 Mobile, puts it this way:

Regularly striving to be the best is admirable, but constantly demanding that everything reaches a certain standard can delay or prevent the completion of tasks—and often leads to procrastination.

All in all, when developers fear failure and strive for perfection, it can be detrimental to their productivity.

They may be inclined to avoid work and distract themselves with unimportant activities—rather than buckling down and doing what’s necessary.

Confusion regarding their task

Procrastination can also be caused by a lack of clarity about what needs to be done.

Developers might feel unsure about how to proceed, or they might not grasp the instructions given to them when first assigned the task.

When instructions are unclear and confusing, developers may feel frustrated or demotivated. This can cause them to put off the task altogether rather than tackle it head-on.

But it’s not just a lack of information that can contribute to procrastination. Too much information can also overwhelm developers and cause them to wander off track.

For example, if developers are asked to build a mobile app, and they’re given a long list of features that need to be included, they might get lost in the details and lose sight of what they were supposed to accomplish.

As a result, they get stuck in a loop of feeling overwhelmed, which causes them to put off their assignment until they are able to find clarity on it.

Remember, keeping developers informed with the right amount of information, meaning not too much or too little, can make all the difference in how they approach their tasks.

An excess of bureaucracy

Although most developers spend their time writing and testing code, they are regularly asked to do other tasks.

For example, they may be requested to respond to helpdesk tickets or attend meetings that aren’t directly related to their work.

They may also have other red tape tasks on their plate, such as updating project documentation or checking if the code is in line with compliance standards.

Developers can be asked to do these things in the name of company efficiency.

The problem is that they’re rarely seen as a priority by developers themselves.

This can lead to procrastination because it’s hard to get excited about tedious tasks when you’re naturally motivated by solving problems.

Or, as Adam Nathaniel Davis poignantly puts it:

“If you’re like me, this task gets put to the very end of your list of priorities. I avoid it like the plague.”

Another problem is that to create the best possible code, developers need to be in a flow state—a mental state coined by psychologist Mihály Csíkszentmihályi that describes a complete focus on an activity.

And according to Chris Parnin, who is a principal researcher at Microsoft, developers need 10-15 minutes to regain their focus after something interrupts them.

Even if developers manage to complete a lengthy list of bureaucratic tasks, they may not immediately return to coding.

They’ll need some time to get in the flow, which can be fertile ground for procrastination.

Therefore, an excess of bureaucracy can lead to a decrease in developer productivity, especially when coupled with interruptions.

How to help them

Tech leads can play a significant role in helping developers overcome their procrastination.

By removing obstacles, providing support and encouragement, and enabling them to better manage their productivity, they can help them get back on track.

Here are five ways in which team leads can assist developers in curbing their tendency toward procrastination.

Start with a meeting

Meetings may seem like a hindrance, but starting the workday with a meeting can help developers stop procrastinating.

Scrum meetings are already an ingrained part of most developers’ work culture.

The benefits to productivity that result from such meetings—setting clear expectations, keeping everyone on track and focused, and sharing knowledge between team members—are well documented.

Therefore, harnessing the power of daily scrum meetings can be an excellent way to help developers overcome procrastination.

If there is no meeting in place, the developers will have to determine which items are most important by themselves.

This process of prioritizing tasks takes time away from actually developing software and leads to wasting time on unnecessary things.

For example, when developers have no sense of priority and are uncertain about what to do first, they may put off the hardest or most important tasks until the last minute and engage in other activities in the meantime.

In a daily scrum meeting, however, the team gets a clear understanding of what needs to be done and how long it will take.

This empowers each developer in their own workflow, allowing them to focus on tasks rather than procrastinating until the last minute.

Urge them to begin

When team leads notice that some of their developers frequently tend to put things off, the best approach is often to simply encourage them to begin.

This straightforward approach can help developers deal with avoidance by committing their energy to start what they have been postponing for so long.

For example, team leads can introduce them to a simple yet powerful technique.

Whenever they feel their brains switch over to autopilot during a task and start to procrastinate, they should simply start counting down 5, 4, 3, 2, and 1.

In the video below, you can see how this simple technique can be used to help change the mindset from avoidance to action.

Within five seconds of doing this exercise, the frontal cortex will be activated, and developers will gain control over their brains.

Then they can get back to what they were supposed to be doing.

This approach is helpful because it draws attention away from procrastination and enables developers to regain control over their thoughts.

Using this method, they can start doing their tasks immediately and complete them without allowing procrastination to slow them down at any point in the process.

Suggest switching between tasks

If developers start spending more time procrastinating than actually writing code, it might be helpful to suggest that they switch between tasks.

This can allow them to work on something else for a while and then come back to the original task with a fresh perspective.

For example, if developers are stuck on a problem and can’t seem to get past it, they may try something else, like fixing bugs or testing code.

Once they’ve had some time away from the troublesome task, they can come back with fresh eyes and be able to see how to solve it.

It should be noted that although it’s beneficial for developers to switch between tasks, the constant act of switching should be kept at minimum levels.

If done too often, the constant change in focus can make completing projects more difficult.

However, in scenarios when tech leads notice that developers tend to wander off frequently, this technique can be very useful.

Recommend setting personal deadlines

Given the many demands on their time and a large number of tasks in their queue, it can be easy for a developer to feel overwhelmed and fall behind on a project.

One way they might cope with this is through procrastination.

When this happens, they may have to work overtime in order to make up for the lost time, which can reduce productivity by introducing burnout and reducing focus.

In light of these considerations, team leads should recommend that developers set personal deadlines for themselves when they feel behind schedule.

For example, Lauren Maria Ferreira, a software developer at X-team, uses Trello to make daily to-do lists and create long-term task boards.

This enables her to manage time and stay on top of things while also reducing the possibility of distractions and procrastination.

She also uses Toggl Track to measure how much time she spends on different types of assignments.

That allows her to identify which projects are taking up the most of her time and pushes her to prioritize those that require more attention.

As you can see, setting personal deadlines will allow developers to better manage their workload and allocate time more effectively, which can do wonders when overcoming procrastination.

Advise using time management techniques

To help procrastinators in their teams, team leads should also encourage developers to use time management techniques.

For example, the Pomodoro technique—named after a tomato-shaped timer—is often recommended as an efficient way to manage tasks and work on projects without getting distracted.

The technique is quite simple: it involves setting a timer for 25 minutes to work on a project (called a Pomodoro) with a five-minute break between each Pomodoro.

After four Pomodoros, a developer should take a longer break (15-30 minutes).

The idea behind Pomodoro is that it is easier to remain alert for short periods of time, separated by short breaks, than it is to maintain focus for extended periods of time.

This can be especially helpful when developers get easily distracted by interruptions such as other team members’ conversations, ringing cell phones, people passing by, and so on.

There are several other time management techniques that tech leads can recommend to developers.

One of them is called Timeboxing, which is similar to Pomodoro, except developers here don’t have an assigned time limit for their work period.

Instead, they simply set aside a specific amount of time (such as an hour or half-hour) to focus on one task without distraction or interruption.

By setting aside time for each of their various tasks, developers can avoid procrastinating by always having something to work on.

Time management techniques like these can help developers increase productivity and decrease the urge to procrastinate.

By working on tasks instead of getting distracted by endless possibilities for procrastination, they ensure that developers are always doing what needs to be done.

Conclusion

There are many reasons why developers procrastinate. It could be that the task at hand feels too daunting or is not something they enjoy doing, for example.

It could also be that the deadline is too far away to feel any sense of urgency—whatever the case may be, most developers deal with procrastination on a daily basis.

There’s nothing wrong with taking a break once in a while, but the problem arises when developers allow themselves to get immersed in distracting activities that take them away from their assignments.

Hopefully, this article has shed some light on the issue and will serve as a helpful resource for tech leads who want to help their developers deal with it in a more efficient way.