The Balancing Act - Empirical Software Development Management
At the moment, I've got three major projects on the go for my employer. The team is small, the scopes are not.
Two projects are mobile apps. One is a backend ecosystem. All up, there are around ten discrete codebases requiring development and maintenance. This doesn't even touch upon the database implementations, CI/CD pipelines, and more.
The gig is a bit wild to say the least, but such is the life of a software development manager - a challenge at the best of times.
Here's what I've learned.
You've got any number of folks on your team and your job is to get one or more projects over the line. Good managers can pull it off without acting like a dick. To achieve this, you'll have to juggle multiple tasks at once, keep an eye on the big picture, and always be ready to step in and save the day if things go awry. It's a tightrope balancing act - you've got management in one hand, programming in the other and to make it fun, you're never quite sure which way the wind will blow.
On one hand, you have the job of managing your team. This means setting priorities, making sure everyone is on the same page, and keeping the project on track. You're the conductor of the orchestra, making sure everyone is playing the right notes at the right time. But just when you think you have everything under control, the wind shifts and you have to scramble not to lose it.
On the other hand, you're still a programmer at heart. You understand the code, the frameworks, and the tools. You know how to write code that is efficient, maintainable, and scalable. And when your team is stuck on a particularly tricky problem, you're the one they turn to for help. You're going to need to be able to dive in and out of the trenches.
It's a balancing act, and it's not always easy. Some days you feel like you're in complete control, and other days you're just hanging on for dear life. Unfortunately, it is easy to fall into some common pitfalls:
- Manager's disease: This is when a manager becomes too focused on managing and not enough on programming. They may lose touch with the code and the team, and as a result, they may not be able to provide effective guidance or support.
- Coder's block: This is when a manager becomes too focused on programming and not enough on managing. They may become bogged down in the details of a particular task and lose sight of the bigger picture.
- Scope creep: This is when the project's scope starts to expand beyond the original requirements. This can happen when the manager is not able to effectively manage the team's time and resources, and as a result, the project becomes delayed and over budget.
- Communication breakdown: This is when the manager is not able to effectively communicate with the team. This can happen when the manager is not able to clearly explain the project's goals, objectives, and timelines, or when the manager is not able to effectively listen to the team's concerns and feedback.
- Team morale: This is when the team's morale starts to decline. This can happen when the manager is not able to create a positive and productive work environment, or when the manager is not able to effectively manage conflicts and disputes within the team.
The key to avoiding these pitfalls is to find a balance between management and programming. The manager needs to be able to understand the code, and be able to communicate with the team effectively, while also being able to stay focused on the big picture and keeping the projects on track.
At the end of the day, there's no single antidote for the challenges that come with managing software teams, but a conscientious approach to the juggle goes a long way... At least it has for me! Make well-considered decisions, always (always) empower your team when opportunities arise and never ever neglect to celebrate a win. Oh and always keep an eye on the big picture but don't forget to keep an eye on the code too!