Becoming a lead developer or technical lead on a team is a great responsibility and can be an excellent career opportunity, but the transition to this role can be a little jarring.
There is a big difference between being responsible for yourself and your work and being at least partially responsible for the work of an entire team.
Many programmers who do excellent work on their own end up flaming out when they are promoted to a developer lead position, because they are not prepared for the extra responsibility involved and the soft skills it takes to be a leading developer.
I've spent a good amount of time in my career as a lead developer, in both official and unofficial capacities, so I thought I'd share a bit of what I learned with you.
Why do you want to become a lead developer?
Before you can tackle the problem on being a lead developer, you first need to become one.
And before you can become one, you first need to answer the question of why.
Why do you actually want to become a lead developer?
Is it an ego thing?
Is it because you think you'll earn more money—or perhaps prestige?
Or, is it because you truly care about leading and inspiring people to do better work?
It's ok to have a bit of an ego thing going on, and it's ok to want to earn more money or to be in a position of power, but if you want to be successful—and retain your position—your motives really should be rooted in helping others, leading them to victory and inspiring them to do the best work possible.
If you are all about money and power, not only will you likely be a poor lead developer, but you'll probably also dislike the job, as the extra work and responsibility will be likely to be unevenly compensated by your new position.
I'm not saying this to discourage you, there is nothing wrong with ambition, it just need to be balanced and aimed in the right direction.
Strive to be the most effective lead developer you can be by making your team better and the other rewards will follow.
Strive for rewards and prestige first, and your team will suffer.
Becoming a lead developer
Ok, so you really do want to go down this path to become a lead developer—even though it might be a thankless job and you might not even get a pay raise?
Good, then here's how to do it.
First of all, you have to recognize that you can be a lead developer without being officially granted the title.
Leadership is not something that can be conveyed with a title anyway.
Leaders are leaders because people follow them, not because they are appointed to some position. Authority can be granted, leadership is earned. You can be an authority without being a leader, and you can be a leader without authority. In fact, some of the most effective leaders operate without any authority at all, because they don't need it.
With that said, becoming a lead developer is more about earning the respect and trust of your team than anything else.
In order to become a lead developer, you need to show that you are not just technically competent, but also have the capacity to foster relationship, encourage, build a sense of unity, and inspire.
A true leader, of any sort, is able to bring people together and unite them for a common cause.
Here are a few traits I think a good technical leader should possess:
- Highly technical
- Has conviction
- Good communication skills
If you want to be a leader developer, you should focus on developing those traits. You might want to invest in your soft skills.
The best lead developers are developers who you can not only count on to give good technical direction, but also to inspire you to grow and do better work, and whom you can trust to have your best interest and the interest of the team at heart.
The best leaders want to help you become more successful.
If you want to become a lead developer, you should first imagine what the ideal team lead you would like to have on your team would be, and then act as if you were already that person.
Forget the political game sand maneuvers, instead seek to render useful service to others and start acting the role, not by bossing people around and having a holier-than-thou attitude, but by being humble and genuinely seeking to help other people on your team.
What it means to be a lead developer
How to act as lead developer and how to become one are quite the same thing, so, although the following advice applies to someone who is a lead developer already, it also applies to those seeking to become a lead developer.
Now we can talk about the most important job a lead developer has…
…to make his or her team successful.
Not just to make the team successful, but to make each individual on that team as successful as possible.
If you want to be a good lead developer, your primary job—the most important thing you can do—is to make as many people around you as successful as possible.
If you can do that, you'll be successful.
But, how do you do that?
Leading by example
It starts with leading by example.
Don't tell people what to do, show them. Do what you expect other people to do, yourself, first, and then let them see why what you are doing is beneficial.
You can argue and try to cajole people until you are blue in the face, but if you really want to inspire people, if you really want to move them to action, you have to lead by first showing them the path to take and generate the results to prove that your way is best.
If you want developers on your team to write better code, you have to start writing better code yourself and you have to write such good code that the effort you put into that code is apparent. Only then can you credibly produce a set of coding standards that will help others to write good code as well. Once they see your code, they should be inspired to write code of the same quality and understandability.
If you want developers on your team to write unit tests or practice test driven development, you had better be not only doing the same, but having tangible results that show what you are recommending is the best way to proceed. This will require some commitment and pragmatism, so that you aren't just preaching something because you heard or read this was the best way to do things.
If you want developers on your team to work on developing their skills and personal development, you had better be a shining example of the same. You should spend more hours than anyone else learning new things and sharing what you have learned with others. You should be the one writing up blog posts that share what you are learning and inspiring others to do the same. (Sign up for my free blogging course, if you want to learn how to create your own successful developer blog.)
The point is, if you want people to follow you, you have to lead, and you do that by example.
(Looking for a good book on leadership? I like “The 21 Irrefutable Laws of Leadership” by John Maxwell.)
When a leader makes a mistake, guess who gets the blame for it?
That's right, the leader.
When a team member makes a mistakes, guess who takes the blame for it?
That's right, also the leader.
If you want to be a lead developer, you have to take responsibility, not only for your own mistakes, but for the mistakes made by everyone else on your team.
I know this isn't a popular sentiment. I know that most people are offended that I would suggest they should take responsibility for someone else's mistakes, but I'll put it bluntly.
If you are not willing to take responsibility—and I mean full responsibility—for the mistakes of your team, you should not be a lead developer.
That doesn't mean that you can't be a good team-member. It doesn't mean that you can't contribute to the team's success and help others along the way.
I'm just saying that if you want to be the lead developer, you have to be ready—and willing—to accept all responsibility for the failures of your team.
A good leader gladly takes this responsibility upon his or herself.
A good leader shields the team from blame, so that they can have the freedom to take risks and so that they do not waste needless time playing CYA (cover your ass) games.
Like I said before, leadership is not for everyone.
Oh, and one more note on taking responsibility.
Guess who gets to claim credit when the team succeeds?
Nope. It's a unilateral agreement of sorts.
Yes, the leader may be largely responsible for the success of the team, but he or she never takes credit.
Instead, a good leader gives that credit back to the team.
Remember how I said being a lead developer may be a thankless job?
Not only does a good lead developer take responsibility for the actions of the team, but a good lead developer also frequently acts as the mouthpiece of the team to other teams, managers, business people and whoever else the team needs to interact with.
That doesn't mean that a lead developer is the only person to communicate with anyone outside of the team, but the lead developer is often the person responsible for communicating the vision and ideas of the team to others, especially non-technical people.
As a lead developer you should be able to clearly and effectively communicate technical solutions to non-technical people and do this while avoiding conflict.
This is not an easy task, especially when bearing bad news. People often like to shoot the messenger.
The best way to communicate with “the business” is to first make sure that you, yourself, clearly understand what is going on with the software that is being built and the technical challenges you are facing.
The better you understand what is going on, the easier it will be for you to communicate that to others.
That means that you have to have a constant pulse of what everyone is working on and what challenges they are facing and you need to be able to translate all of that into non-technical terms.
This takes some practice, but it's an essential skill for a lead developer, because a large portion of building software is communicating with the stakeholders and customers that you are building the software for.
It can be especially difficult when you have to present why an idea that “the business” has is not feasible or is not the right solution for the problem at hand.
It's tempting to either cower down to the authorities that be and promise something that either can't be delivered or to agree to a suboptimal solution, or to defiantly stand against any who would oppose your technical superiority, but you have to have a way to walk the line.
A good lead developer can sympathize with, and understand business requirements and the non-technical reasoning behind a decision or position, and then present a clear, rational argument in favor of a proposed solution.
A good lead developer knows when to make a trade-off that might not be optimal, but will avoid unnecessary conflict, but also knows when to stand his or her ground and not over-commit the team or promise something that can't be delivered.
A good lead developer fosters communication between the team and the rest of the organization.
Helps others do their best
The most beneficial lead developer to have on any team is one whose very presence on the team causes other developers to perform at high levels.
If you want to be a good lead developer, you have to not only commit yourself to continual personal development, but you have to also inspire others to do the same.
As a lead developer, you should be keeping your technical skills as sharp as possible by spending time each day learning and reading up on the latest technologies and trends. You should make sure you understand the technologies your team is working with better than anyone else—if possible—so that you can be a reliable support for your team and you can lead them, confidently, in a technical direction.
Likewise, you should encourage the members of your team to grow and enhance their own skills. You should give them the resources to do it. You should share what you are learning and mentor the members of your team to help encourage them to grow professionally.
You should do everything possible to make sure your team has what they need to be successful and you should show them that you personally care about their individual successes and accomplishments.
When someone knows you care, and that they—and their work—matters, they are much more likely to perform at a higher level.
Being a lead developer isn't an easy job
This brings me back to what I said at the beginning of this article, that you should really question whether or not you have what it takes, or if you even really want to be a lead developer.
The job isn't easy, it might be thankless, and it can involve a lot of sacrifice, but if you care about seeing people succeed and you are willing to devote the time and energy to help them do it, you have the potential to become a great lead developer.
But, if you are just seeking a position of power, or the authority to tell other people what to do, or if you motives are completely based on that raise you are expecting from becoming the lead developer, you'll probably find yourself struggling in the position.
So, think carefully if you really want to become a lead developer and if you do, be humble, take responsibility and do everything in your power to make your team—and the members on it—as successful as possible.
Whether you choose the path of a lead developer or not, it's essential that you know how to market yourself as a developer. I created a course to help software developers get the career success they deserve — check it out here.