Agile Practices of Effective Tech Leads
A Tech Lead or Technical Team Lead or Engineering Lead, is a common role within the software development discipline. This individual is responsible for the overall planning, execution and success of complex software solutions to meet customer’s needs. Over the last year and a half, I have dedicated a great deal of my time to coach the Tech Leads in the Engineering department at Andela. In this post, I will share what I have learned so far with respect to key practices I believe make for great Tech Leads in Agile teams.
1. Collaboration
As a tech lead, a good amount of your time is spent identifying and clearing roadblocks for your team. This requires effective collaboration skills. You need to collaborate with different business functions in order get what your team needs to move forward. From collaborating with Product Managers to ensure the backlog is fleshed out for the next development iteration, to Designers to get high fidelity designs of a particular feature, to Operations to ensure the developers on your team have the right hardware to get their job done. A great tech lead thinks ahead, anticipates risks, and addresses them before they become a bottleneck for the team.
An effective Tech Lead is also a great communicator. They find ways for non-technical people to understand technical concepts. They minimize the translation layer by bringing business terms into the development team and encouraging their use, to foster understanding and empathy with business stakeholders.
2. Team Debugging
As a developer evolves in their career from being an individual contributor to leading a team, they typically shift from debugging the software they are building, to debugging the team they are leading. A variety of blockers can impede a development team from meeting its deliverables (e.g. poor task management, unclear requirements, complex development process, etc). In order to guide team debugging efforts, Tech Leads in the Engineering department at Andela use what we call ‘Team Vitals’ to monitor the health of a team.
Similarly to how doctors might monitor a person’s white blood cell count to determine the existence of an infection, we have put in place metrics we use to monitor our team health each week:
- Cycle time of tasks
- Number of accepted points per contributor
- Number of accepted stories
- Number of outstanding bugs
- Number of introduced bugs
- Delivery date shifts
- Average daily production deployments
We set targets for each metric, and review them on a weekly basis during team retrospectives to get to the root cause of a particular shift (positive or negative) of a metric.
We use PivotalTracker , a powerful task management tool which provides in-depth analytics that make it easy to automatically capture measurements for most of the vitals. The vitals are not set in stone, but reviewed quarterly and adjusted accordingly.
3. Technical Debt Management
Technical debt is something that every development team, large or small, has to deal with. Technical debt accumulates in a variety of ways as you build software. Sometimes it accrues through explicit compromise: you deliberately choose to do something in a non-sustainable way in order to get the product to market quicker and tell yourself that you’ll clean things up later. Other times technical debt accrues because building technology is hard, people make mistakes, and you can’t predict the future which means that sometimes you build the wrong things.
A great Tech Lead manages the technical debt in effective ways to ensure it doesn’t accumulate to the point where the only thing the team is doing is servicing debt and not iterating on the product. There is no silver bullet when dealing with technical debt, but here are two practices I have seen work well:
Measure the technical debt.
If you don’t measure it, you don’t know how big it is and how fast it is growing. Anytime you encounter technical debt walking through the codebase, create a task and label it as “technical debt”.
Make technical debt payments continuously.
We have a general 80/20 rule. That is in a given iteration, spend 80% time iterating on the product, and 20% time fixing the debt. Tech Leads ensure that some amount of debt related tasks are prioritised in each iteration.
4. Task Management
Perhaps one of the most critical requirements of a good software development team is consistent velocity, and ability to deliver on its estimates. Achieving this feat, requires mastering task management way beyond simply assigning tasks to developers on the team. Here are some task management behaviours Tech Leads at Andela practice:
- Capture EVERYTHING in a tracker (e.g. TODOs, technical debt, research chores, ideas) #NoTicketNoWork
- Ensure that all team members are able to add tasks to the icebox
- Ensure the backlog always has enough work for at least 1 to 2 iterations out
- Groom the backlog daily. Look for how to break down larger tasks into smaller ones. Look for dependencies where one task is dependent on another
- Do not start development on a task unless it has been broken down to the lowest possible complexity (e.g. Developers on our teams only work on tasks that are estimated as 1 point, Pivotal Tracker’s lowest rank in its point system for complexity)
- Break down tasks based on how complex they are to the developers on your team, and not how complex they are to you as a Tech Lead. This one is particularly important if you have less experienced developers on your team
- Check on the status of a task whenever the task feels ‘stale’ (e.g. it’s been started for more than a day)
Practicing the above behaviours has helped the Tech Leads develop a 6th sense for whenever team velocity slows, and improved their ability to act quickly to get the team back on track.
5. Mentorship
Last but not least, great tech leads are great mentors. They aim to groom and mentor the developers on their team, provide feedback on their work frequently, and encourage and promote best engineering practices. They work to broaden the technical capabilities of their team by delegating problems of increasing complexity, and pair programming with the developers regularly to provide technical guidance. Great team leads remember that their success is measured by the success of their team members.
The Tech Lead is a critical role to the success of any software development team. They are the sounding board for their developers, the voice of Engineering to other business functions, and make critical technical decisions that can make or break a project. Delivering great software solutions that meet user’s needs require great Tech Leads. I believe mastering the five practices described above, can produce more of them.
Thanks to Mohini Ufeli, Nadayar Enegesi, and Ebun Omoni for helping edit this article.
