Strategies In Managing A Software Development Team

Prior to launching my own web development agencies over 10 years ago, I’ve jumped between the role of a senior developer and a manager multiple times – including leading and managing a software development team role.

My first stunt in management was back in 2007. We were building a Java-based distributed software for a telecom group operating in multiple countries. I spent a year and a half with the company as a developer before joining the project along with our Chief Technology Officer (CTO), and a couple of other developers.

The CTO and I spent several months working closely together on the initial architecture and some of the intermediate layers. It was fairly new technology so we had an opportunity to dive deep into technology that still lacked some basic libraries and web components. Spending evenings at the office debugging core code and building proof of concept solutions was certainly exciting – and enlightening in many ways.

A couple of new team members joined and I was involved in their onboarding. Just a few weeks later I got myself into being a development team manager until a very senior developer with a Ph.D. in mathematics joined the team and got busy rebuilding some of the web services and data caching layers.

And a couple of days later, I was invited to a management meeting with the senior management on the telecom’s side.

Long story short, my coding nights turned into drafting business requirements and coordinating milestones with the technical team. My CTO was a brilliant engineer and a great leadership model, but sucked at project management – so I had to step in and learn fast in order to get the ball rolling.

From Coding To Managing

Switching from a traditional software engineering role to a team lead or a technical manager isn’t all about coding. In fact, it rarely revolves around programming chops anymore.

When I made the leap myself, I had to come up a couple of hours earlier and I would spend the time responding to emails and updating the roadmap with the latest client updates. The time spent with my team was mostly spent discussing roadblocks and assessing the challenges we had to work on as a team. At the end of the day, I was in charge of reviewing the latest batch of changes and updating different stakeholders with the latest updates.

We managed to hit the first couple of milestones and launched a beta of the product. I left the team (which included a few more developers since) and joined another team as a developer.

Nearly 4 months later, I was assigned to another techie who switched to a business analyst role. Suddenly, I got introduced to a couple of prospects and received an internal handbook on preparing flowcharts, feature diagrams, using case scenarios for both products.

I was left high and dry and expected to handle estimates for both projects, coordinate the communication with both customers, and sync with the local dev team as well. It wasn’t a full-time project managerial role as a third of my time was still spent on R&D – researching different toolkits and frameworks for a logistics company and a suitable web framework for a petrol corporation interested in an internal ERP.

It was a weird balance and definitely different from a traditional corporate promotion with a long-term onboarding time (or converting to a PM assistant role working with a senior team of project managers). But I managed to hit some wins and work hard in order to complete the required objectives.

This was good training for my transition to full-time freelancing and, later on, founding my own company. I still juggle multiple disciplines on a day-to-day basis which is probably a habit from my earlier days.

What Makes Managing A Software Development Team Difficult?

managing a software development team

Managing a team is challenging in itself.

But handling a call center or a team with comparable skills and achievements is still different from managing a software development team.

The following are the major aspects of software team management that make the job difficult.

Handling Different Skill Sets

Software Development Lifecycle Oversight

A technical project would require a team with diverse skills.

A good example would be a high-scale web application that depends on designers, front-end developers, back-end programmers, DevOps folks, system admins, QA engineers, and more.

I recorded a video about the disconnect between project managers and software developers.

Handling different skill sets is a unique challenge that requires extensive research and adoption of the work challenges of each role in the project.

Professional managers cannot realistically cover all areas of expertise. However, studying each role is integral to building a strong team that operates successfully together. Lacking the skills to gauge experience and identify areas, where a member can chime in, will impact the balance within the department.

If you are not a technical manager, working closely with other senior technical members in the organization is mandatory. This could be the technical team lead within your own crew or the VP of engineering/CTO.

Dealing With Strong Personalities

Software developers are known to be more sensitive to certain topics than most other non-managerial roles. While not necessarily being a “rule of thumb”, the competitive landscape comes with the occasional strong opinion and a preference to solve a problem in a certain way.

Managing a team of software engineers can introduce additional challenges leading to heated discussions on the technical end.

This isn’t necessarily a bad thing. Managing a sales team isn’t trivial either. Grunt workers often require micromanagement as they primarily take a low-end job “for a living”. Understanding how software engineers think and operate will help you make a smooth transition.

Managing Resources

Resource management in software engineering is one of the trickiest aspects of them all. In fact, resource management issues are referred to as the reason behind 40% of failed projects.

Agile projects introduce short sprints and delays (or leaves) that may impact the milestones. Waterfall projects occasionally come with unexpected surprises that would eat up extra time.

Team members who switch between a couple of projects may also have a hard time focusing on the project at hand or handling all of the workloads at once. It is a fine balance, especially when you account for energy management, bringing some diversity, and creativity to the job profile, and handling motivation effectively.

Oftentimes, the challenges involved in resource management include:

  • Responding to the increasing demands of the team and the client
  • Delivering maximum value out of the bare minimum resource
  • Getting the most out of scarce resources

What Donna Fitzgerald, president of Nimble PM and the former research VP at Gartner, suggests is that businesses must create a capacity planning strategy that involves the following steps:

  • Find out the roles needed to complete a project
  • Specify the number of people needed for these roles
  • Determine the bottleneck resources of the entire project
  • Cut demand to fit the supply depending on the project’s value

The capacity planning specifics may vary by industry. It is also just one of the steps you can take to effectively manage resources. The illustration below from Wrike provides a better understanding of the responsibilities involved in resource management.

According to Wrike, effective resource management helps avoid future problems and burnout, provides a safety net, shows transparency, and gives you a better idea of what works in your planning and the ROI. 

Hacking Quick Turnover

The competitive market leads to a quick turnover. Software engineers usually stay with a company for about 2 years (the number may be higher for more reputable companies offering better perks).

But, turnover is somewhat common. A report shows that the tech industry has the highest turnover. 

See the breakdown of rates below.

Image source: LinkedIn

Handling a quick turnover requires a multitude of hacks when it comes to hiring and onboarding, managing a software development team working on other projects, and handling the ever-changing scope of work.

You can reduce turnover by providing a competitive compensation package with other employee perks on top, allowing flexibility and a sense of freedom, improving your company culture, ensuring a healthy work environment, and investing in the career development of your team. 

But in cases where you have to facilitate onboarding new team members, the complexity of the engineering job combined with short retention cycles commands the need for additional documentation and onboarding. Plan your monthly or quarterly schedule and ensure that technical documentation, commit messages, your project management system — everything is kept clean and easy to follow by the new team

Compensating for Lack of Technical Background

I’ve met development team managers with a purely business background that did well at the job – but the majority of the non-technical managers may have a hard time understanding feedback or complaints from their team.

Accepting client requests lightly that may be complex on the technical end may build up pressure, too. Nagging team members without understanding the underlying layers will also cause some extra tension.

Our head of PM is not an engineer herself. But she’s investing a good chunk of time in reverse-engineering business requirements, understanding the high-level caveats that the tech team meets, identifying ambiguous areas that would otherwise contribute to scope creep.

Simplifying Ambiguous Requirements

Ambiguous Requirements

Unlike other, more straightforward roles, software engineering is about turning business requirements into practical applications.

Most roadmaps and specifications are up for interpretation. Therefore, 10 different engineers may easily build 10 different versions of a product – with varying flexibility, stability, scalability, and workflows.

Being unable to manage those upfront will impact the milestones and lead to consecutive iterations of back and forth.

Keeping Up With The Dynamic Nature of the Industry

Assembling a software development team often includes roles with different levels of skills and experience.

Due to the dynamic nature of the industry, assigning the right people to the right assignments is quite a challenge. Junior developers may handle repetitive and somewhat easy work.

But this may also require additional layers in-between in order to simplify the business process.

Failing to design the right architecture from day 1 results in technical debt that keeps creeping up during the ongoing development of the project.

Maintaining Variety and Excitement

Software developers often leave companies due to poor management, but some “job hop” for more exciting opportunities. Engineers want to evolve and progress without sticking to the same boring job over and over again.

When I say “boring job” I’m not referring to a single company. Maintaining a variety on the job with interesting projects, career opportunities, collaborating with new team members may be more than enough to keep your engineers sharp and help them develop new skills on the way.

Project managers need to be proactive in monitoring mood swings or keeping a developer on the same type of activity for too long. Juniors need to progress slowly and seniors need to undertake different types of challenges. It’s an art in itself.

Mario Peshev

Get personalized leadership advice and monthly goal assessment

Juggling Responsibilities

Bringing the right attitude to the team is not easy.

A great project manager should juggle the team’s workload, the senior management’s requirements, and the client’s wishes.

It’s a fine balance that aims to boost morale in-house while getting the work done.

Using Proven Management Processes

Collaborating with experienced technical leads is always the best possible way to move forward. Project managers can team up with CTOs or tech leads, what about senior management though?

I always advise non-technical executives to find a technical co-founder, a reliable external consultant, or appoint a person in the team who could take that role accordingly.

The thing is, programming is executed primarily behind the scenes. It’s not something that you can evaluate visually. It is comprised of software architectures and different layers in charge of stability, performance, compatibility, security.

If you are unable to find the right person who can conduct independent code reviews or assess code quality, I would focus on two separate areas:

  1. Defining actionable requirements and use cases
  2. Setting measurable and practical KPIs upfront

The first part revolves around creating a process in terms of defining a feature set and the expected behavior.

It’s easy to point your team in the right direction if you are a technical person. Still, you can leverage some proven processes for creating assignments or reporting bugs and usability issues.

Here’s the bug report template that our technical team uses in-house:

Bug Report Teamplate

Our technical leads and technical project managers are required to fill out all fields before assigning the task to a developer. While you may omit some of the areas, providing as much context as possible is paramount.

  • Explain the business case in detail.
  • List down your steps to reproduce and outline the expected behavior as well.
  • Point to screenshots, note your browser and OS, attach screenshots.
  • If you feel like it’s a minor bug, you can suggest an estimated completion time which is up for discussion.

Use Cases and Use Diagrams

When creating new tasks as a non-developer, pick a use case template that would define that context in a systematized manner. There’s a great collection of use case templates available at 40 Use Case Templates & Examples (Word, PDF) – Template Lab, for example:

Use Case Template

More complex use cases may benefit from use case diagrams as well:

Use diagram

Note how different roles are involved with (and have access to) different features and components of the applications.

Developers who are not familiar with the complete context may misunderstand the initial requirements without a detailed brief discussing the available use cases. This sort of diagram may help them define the feature set in a more optimal manner, designing the right routers and validation layers under the hood.

It’s all about providing as much context, details, and required constraints as possible.

Measuring KPIs

A developer needs to know what should be built and what are the desired limitations of the solution. You want the full feature set covered without exposing features to certain scenarios.

The second part requires setting technical KPIs that don’t require a programming background.

For instance, we have three core pillars of development in DevriX that we focus on in every step of the way:

  1. Stability
  2. Security
  3. Speed

While these can’t always be measured without a complete code review, there are ways to define some future KPIs and gauge them during the development process.

For example:

  • The system needs to work without interruptions with 5,000 registered users.
  • 50 registered accounts should be browsing the backend simultaneously without crashing the application.
  • The code base has to comply with X coding standards.
  • I want the platform to handle 500,000 monthly visitors.
  • The knowledge base should load for under 5 seconds when we have 80,000 published articles.
  • The system should pass Y security test or a review by Z security team.

The good news is that most KPIs can be measured without reaching the peak point at the end of the process.

  • There are load/stress testing tools online that you could run independently. They report on load times, maximum concurrent users, or any technical errors with system outages.
  • A test with multiple simultaneous users working with the platform is feasible when you invite a group of friends and ask them to help for an hour.
  • Various static testing tools and scripts can run your codebase and ensure that the best practices are followed.
  • The same goes for security applications (like penetration testing tools) or agencies that charge a flat fee for an external black box review.

It’s not ideal, but it works.

The Core of Effective Management

handling different skill sets

Being a development team leader is all about effective communication.

From understanding mood swings to gathering technical caveats, monitoring for tension between team members, or noticing cases of low energy due to external factors, you must:

  • Make sure that you define your requirements properly by providing the context your technical team needs.
  • Set realistic expectations that could be measured externally.

You should be good to go until you start scaling your business a bit and can allocate resources to a technical consultant or partner up with a technical co-founder.

For more management tips, head to this management guide for executives that we have prepared for you.

Leave a Reply

Your email address will not be published. Required fields are marked *