Managing developers has a lot in common with managing anyone else. Most want a manager who will help them solve business problems, protect them from office politics, and help achieve their personal career goals. However, developers also require a few special management techniques to encourage their productivity.
Zach Holman nails it:
At GitPrime, we want to help you be great at managing software development teams, which means knowing how to lead a technical team effectively. Here are seven tips specific to managing a team of software engineers:
1. Allow Developers to Do Their Jobs
One of the most common desires among developers is a manager who willrecognize their abilities and trust they’ll get their work done. Allow developers to write code – they love doing it.You just need to find a way for developers to do this in a way that benefits the company.
Part of trusting is giving developers time to think outside of coding. By giving developers an opportunity to develop solutions on their own will help them to stay creative.
2. Handle Non-development Work
Activities that don’t involve writing code are unimportant to most developers. Your most important job for many developers is to protect them from time sinks such as non-technical meetings and administrative paperwork.
Developers want a manager to provide them with a list of prioritized tasks with meaningful priorities. No developer enjoys an unrealistic deadline, and one of the only ways to mitigate this is to really drill out requirements beforehand. Be militant about good requirements. It’s the only way to truly understand the scope and manage expectations around deliverable dates in a way that’s reasonable. When deliverables are significantly different from expectations, this creates operational load. The best time to solve this is by investing effort up front and making sure stakeholders are asking for work in a responsible way.
3. Listen and Respond
No matter how well you think you may have communicated the specifications, developers will still have questions. Development is an iterative process.
This is another place where up front effort pays dividends: once you’ve gathered requirements that make sense, get developers involved before starting work. Engineers should have the opportunity to critique, extend, or outright reject the requirements if they don’t make sense.
Once work has started, the same logic applies: the best requirements are essentially a sort of living document which evolves during development. Just as “no battle plan survives first contact with the enemy,” no set of requirements should be expected to survive implementation without a little bit of flex.
4. Encourage Progress
The best developers are continually trying to improve their skills. The most successful managers facilitate growth. To do this, find one specific, actionable thing for them to focus on.
That might sound like: “Focus on breaking your work into smaller pieces,” or, “I’d like to see you step up and take on more refactoring legacy code.”
Use a personal development plan to suggest areas of research the developer can conduct during down time. Taking an interest in your engineers’ professional development will help you refine your technical direction, ultimately benefiting your company. Offer guidance for their projects, even when it isn’t directly related to their work.
5. Emphasize Quality over Quantity
An inexperienced manager may believe that throwing more developers on a project will increase productivity. This practice is rarely useful, since new developers will slow down development until they get up to speed on a project.
A better solution to improving your developers’ productivity is to reorganize your team to perform small tasks, typically those that can be done within a few days or week. Assign each team member specific roles such as coding, testing and implementation. Ensure that the developers in each team have a variety of experience levels, including journeymen, mid-level, and senior developers.
6. Review the Right Metrics
Performance reviews provide the most appropriate opportunity to measure a developer’s performance and identify possible problems. However, it’s vital to select only those metrics that are applicable, as many managers collect all available metrics just to show that the project is still under development. Check out our previous postfor more information on the best metrics to use in periodic feedback.
Ask a developer directly about the problems they see in the project and the metrics they believe best reflect the project’s actual status. Review the project’s open tickets on a weekly basis, but don’t focus solely on closing them out. It may be better to leave a ticket open for a while to ensure the associated bug fix.
7. Avoid Task Switching
Many jobs require multi-tasking, but this practice is a detriment to effective software development. Your team spends their attention juggling tedious conceptual problems in their head. Any disruption to this comes at a tremendous cost—one untimely interruption could set someone back half a day.
Context switching is expensive and the cognitive overload from multi-tasking results in poor performance. When working on multiple projects, some managers require their developers to work on one project in the morning and another project in the afternoon.The best solutionto handling multiple projects is often to redistribute your developers into small groups dedicated to a particular project.
The key to retaining top developers is to treat them well and manage them fairly. They’ll adjust if you miss one of the above points occasionally, but they’ll begin searching for better opportunities if you consistently miss one for too long.