6 things that make your development team less productive

11 min read
January 20, 2023

According to the Bureau of Labor Statistics, productivity among US workers in 2022 has fallen at a rate not seen since 1947.

The most likely reason is that there are more things that can hinder productivity now than ever before—things like shorter deadlines, more workload, and distractions in the form of social media.

As a manager, it’s your job to protect your development team from these productivity killers.

Here are six that we believe can deal the most damage.

Frequent meetings

Holding regular meetings is crucial for collaborating with your development team, yet overdoing it can harm their overall productivity.

Unfortunately, having too many unnecessary meetings is quite common for organizations.

A survey by Otter showed that 67% of employees struggle to be productive because they are made to spend too much time in meetings.

And it costs businesses around $399 billion a year in the US alone.

Ineffective meetings stats

Source: Wellable

Needless to say, unnecessarily long meetings will also damage your team’s productivity because of how distracting they can be.

Meetings are notorious for interrupting developers and taking them out of their flow state.

And returning to this productive mindset after an interruption can take at least 10–15 minutes of undivided attention.

Now imagine having multiple meetings in a day, and you can quickly see how that wasted time adds up.

tech CEO 1

Learn from a software company founder.

Make your software product successful with monthly insights from our own Marko Strizic.

Thus, as managers, it’s your role to ensure that meetings are helpful and not detrimental.

The best way is to hold meetings only when really necessary.

When you put your mind to it, you’ll be surprised to find how many topics don’t require a meeting. Instead, most issues can be solved with other, less intrusive communication methods.

For example, let’s say you need to discuss a recent critical issue with your app.

Instead of holding a meeting right away, maybe you can send an email to the developers first, asking them to look into it.

Only hold a meeting when you need to discuss further or brainstorm a solution.

To help you determine if a meeting is necessary, you can use this handy decision tree from The Harvard Business Review:

Decision tree for meetings

Source: HBR

Once you’ve decided that a meeting really is required, you should set an agenda. There are two benefits to doing this.

One is that, with a clearly defined agenda, you narrow down the focus of the meeting, lessening the chance that you go off topic and prolong the meeting.

The second is that you give the participants ample time to prepare, which ensures their engagement.

Lastly, aim to keep your meetings to 30 minutes or less. If you need additional time to discuss specific matters, it’s best to set a meeting with only the relevant parties involved.

Better yet, just reschedule if the topic isn’t urgent.


If you had to avoid just one management behavior, it should be micromanagement. Nothing hurts your team’s productivity and morale more than the manager looking over their shoulder.

Micromanagement is a management style where you tightly control every aspect of your development team’s work.

It might seem a good practice at first glance because it seems to ensure you’re on top of everything in the project.

But it’s actually damaging your team’s long-term mental and emotional well-being.

Effects of micromanagament

Source: Gartner

Micromanagement communicates to your developers that you don’t trust them. Over time, this can lead to a loss of self-confidence, ultimately hampering creativity and lowering productivity.

Furthermore, micromanaging someone doesn’t just harm their productivity but yours as well.

Fretting over every little task your team does takes a lot of time, which could’ve been better spent on more meaningful tasks.

As a manager, the best approach is to give ample direction and guidance to your team members, then leave them to their own devices.

The idea here is that you should trust your team to do a great job—after all, you hired them!

Nevertheless, micromanagement can be a hard habit to break, especially if you have trust issues. To help you out, here are some tips to keep in mind.

How to avoid micromanagament

Source: Slingshot

The most important mindset is to embrace failure and let go of perfectionism. Part of trusting your team is to accept the fact that they will make mistakes.

But you should also believe any problem can be solved and tackled with the right approach.

Next, practice delegating tasks to your developers, especially critical ones. This is a great exercise in trust.

If you’re having a hard time relying on others, try delegating smaller tasks first, then work from there.

Third, have a reporting system in place. This allows you to get constant project updates from the team without bothering them constantly.

Finally, make sure to talk to your team regularly. Pay special attention to their working conditions, and watch out for any red flags.

Seagull management

Seagull management is, in many ways, the opposite of micromanagement, but it’s equally damaging to productivity.

A seagull manager is uninvolved with the project except when delivering a negative comment to the team.

It’s similar to how a seagull swoops in and makes a mess on everything below it—hence the name.

The tell-tale sign of a seagull manager is that they don’t have anything constructive to say.

All you hear from them are comments like “This isn’t right!” or “You did this wrong!” without offering any suggestions to fix them.

As you can imagine, receiving only negative feedback can damage a developer’s self-confidence.

Over time, they can become less motivated, affecting their output. And this causes the seagull manager to comment even more negatively on the developer, further lowering their morale.

It’s a vicious cycle.

Seagull management can even impact a person’s health. According to Forbes, employees subject to seagull behavior have a 30% higher chance of developing coronary heart disease.

So, how do you stop behaving like a seagull manager?

The most important thing is to make sure you always give constructive feedback. Every time you point out something wrong, you must follow it up with actionable advice.

An effective follow-up to this tip is to focus on finding the root cause of the problem.

For instance, if you notice that your app is always crashing, talk to your developers to find out why instead of assigning blame right away.

Next is to communicate with your team regularly. This shows them that you’re involved throughout the project.

Better yet, get to know them by hosting fun team-building activities. Doing this can help foster trust and improve job performance.

Finally, do your best to give your team clear directions and expectations. This sets them up for success and lessens the chance you’ll call them out for making mistakes.

Scope creep

Scope creep is a phenomenon where a project’s requirements change drastically throughout development.

This burdens your development team with unnecessary work, putting a strain on their productivity.

What makes scope creep dangerous is that it usually starts very subtly. Maybe the client requests a minor change or two in a way that’s easy to accommodate.

But when this happens regularly throughout the development process, that’s when trouble begins.

Your budget suddenly starts to go over. Deadlines are missed, timelines are stretched, and the team finds itself overworked without accomplishing anything.

Scope creep causes

Source: Chisel

The main culprit of scope creep is that the project’s requirements aren’t clearly defined.

When this is the case, it’s easy to pile new goals and objectives until the project becomes unmanageable.

Another cause of scope creep is a lack of effective project management.

A good manager can protect the project’s requirements, firmly saying what can or can’t be added. They can also prioritize critical features, so the team doesn’t get sidetracked.

Sometimes, scope creep can also arise from miscommunicating the project requirements to the development team.

So, how do you avoid scope creep?

The best way is to discuss requirements at the beginning of the project and ensure that it gets buy-in from everyone.

You should also lay out timelines, milestones, and task lists. Then make sure to document everything in a contract.

Next, always prioritize core features before the project begins. This helps your team finish the essential parts of the app first, even if some work gets added in.

Finally, constant communication with the development team is critical to avoid scope creep, as it allows you to put the team back on schedule or anticipate changes if absolutely needed.

Technical debt

Technical debt refers to the additional cost of revising software later.

It’s caused by the development team picking the quickest solution versus the best option in a rush to meet deadlines.

While it might speed things up in the short-term, technical debt can add unnecessary workload to your team, affecting their productivity.

Now, not all technical debt is bad. Some kinds are actually beneficial to the project, as you can see below:

Technical debt

Source: Asana

The best kind is prudent and deliberate debt.

It occurs when it’s riskier to delay the app than to refine it. What’s good about deliberate debt is that you can anticipate it, so the hit on your productivity can be managed.

For instance, you can hire more developers or stretch your deadlines.

What you want to avoid is reckless, unintentional technical debt, which happens due to miscommunication, mistakes, or a general lack of skills.

This type of debt will often blindside your team with additional work.

So, how do you avoid technical debt?

The best approach is to set reasonable deadlines for your project team. Make sure to include developers in the discussion so you can arrive at a workable timeframe for everyone.

Ideally, meeting your deadlines should only require your team to work 35 hours a week.

Beyond that, you’ll see a dramatic drop in productivity, increasing the chances of accruing technical debt.

Work hours per week productivity

Source: Existek

If technical debt is unavoidable, the next best thing is to manage it properly.

You can do this by maintaining a debt list. Each time you choose the quicker option over the most efficient one, schedule the tasks needed to pay off the resulting debt.

For instance, let’s say you implemented a login feature with only basic security to meet deadlines.

To compensate for this, you determine that you need to incorporate two-factor authentication when the next version rolls out.

The key to technical debt is to use it strategically, as you would a business loan. Just make sure you have a plan to pay it off eventually.

Inadequate hardware and software

The best craftsman requires world-class tools to create world-class work. The same is true with your development team.

If they don’t have access to the right hardware and software, it can slow them down or reduce the quality of their work. As a result, productivity nosedives.

That’s why you should determine your project’s tech stack at the beginning of the project, then ensure that developers get it.

A recent Claromentis survey revealed what employees need to excel in their work. It sheds light on what software you need to provide your development team.

Tools to improve working conditions

Source: Shake

Of the factors above, having streamlined tools is noteworthy.

That’s because switching between different tools and platforms can hamper productivity by as much as 45%, according to a recent Qatalog report.

Apart from the software, developers should have access to the best hardware to support their work.

Multiple monitors, extra workstations, or even a comfortable chair can do wonders for their productivity.

Need more productivity tips?

We hope you’re now aware of what you must avoid to protect your team’s productivity.

However, that’s not enough. You also need strategies that can make them more productive.

To help you out, check out this article on how you can improve your team’s productivity—or you can also read our primer on the top ten productivity tools every development team should use.

Written by

Marin Luetic


A seasoned software engineering executive, Marin’s role combines his in-depth understanding of software engineering processes (particularly mobile) with product and business strategies. Humbly boasting 20+ years of international experience at the forefront of telecoms, Marin knows how to create and deliver state of the art software products to businesses of all sizes. Plus, his skills as a lifelong basketball player mean he can lead a team to victory. When he’s not hopping from meeting to meeting, you’ll find Marin listening to indie rock, or scouring the latest IT news.

Related articles