Seniority is not a candy cane!

As managers and executives in Software Development, one of our primary challenges is building and retaining high-performing development teams. As demand for software developers increases every year, this challenge is becoming immensely difficult to tackle. Many moons ago, I wrote a blog on different ways to retain talent here.

In recent years, however, another strategy is being employed more and more to overcome this challenge. Companies are giving away ‘Senior’ titles abundantly like a candy cane and promoting their developers to senior roles hoping that they will take on more responsibility and lead their teams to success. Also, seniority is being used to pay candidates more than the range they fall in. It is my opinion that promoting people to a senior level too soon can be a major mistake that can ultimately harm both the developer and the company.

Seniority Levels in Software Development

I consider junior, mid, and senior as the developer mastery levels and remove from titles such as software developer, engineering manager, software architect, or tech lead. These levels are not solely achieved by technical proficiency and knowledge that can be acquired through traditional means such as classrooms, books, or videos. There is an artisanship aspect of software development that strongly benefits from a Master-Apprentice relationship, where experienced developers can pass on their knowledge and experience to the next generation of developers. Your roles or pay grade in a company may change often but the mastery level is not something that should be taken so lightly.

Let’s consider these seniority levels for software developers. The way I usually look at them and what I expect from the developers at these levels are as follows:

• 🐈 Junior Software Developer: Someone new to the field and has very limited experience. Juniors have many gaps in their skill set and are still in the process of learning the particulars of certain programming languages. They may work on a limited part of the system code but most of the time, they have no idea how the coded part is being used in real life. Design patterns and SOLID principles may not be so obvious to them yet. Code quality is subpar and the focus is usually on fixing something quickly. They are more prone to the Dunning-Kruger effect so they have no idea how much they do not know. It is essential for them to have a good mentor to help them achieve their potential.

  As I look at Software Development not only as an engineering discipline but also as an artisanship, it is very important to honor the time-tested method of apprenticeship here. When it comes to junior developers, I expect them to be like curious kittens. They are eager to explore and learn about their new environment and are not afraid to make mistakes along the way. Like kittens, they are full of energy and enthusiasm and are willing to take on new challenges with a sense of playfulness and creativity.

  As they gain experience and knowledge, they will become more confident and self-assured, but they will always retain that sense of curiosity and willingness to learn. They are a vital part of any software development team, bringing fresh ideas and perspectives to the table, and helping to drive innovation and growth.

• 🐕 Mid-Level Software Developer: These folks have gained significant experience in designing, building, and maintaining complex software systems. They have a deep understanding of programming principles and best practices and are able to apply this knowledge to create effective and efficient code. They have a keen eye for detail and are able to identify issues and bugs through careful testing and debugging. They are able to work independently but also work effectively with their team. However, without senior oversight, sometimes they may cause timeline slippage or extensive work while trying to create the ‘perfect code’.

  They don’t always know where to make the tradeoff since they may be attached to their solution and lose sight of the end goal. They are also able to work closely with junior developers and provide guidance and support to help them grow and develop their skills. If junior software developers are like kittens, mid-level software developers should probably be loyal, reliable, and diligent hound-dog with a strong sense of purpose. They are able to track down issues and resolve them with precision and accuracy.  

• 🦉 Senior Software Developers: Seniors have been working in the field for several years and have extensive experience in designing, building, and maintaining complex software systems. They are the masters of their domain and they train the junior software developers and share their experiences and trade secrets. These tips and experiences are not only about the technical side of the profession but also about soft skills and management. They are usually very pragmatic in the execution and know where to make tradeoffs if required. They are able to break complex issues into smaller well-defined parts that can be developed.

  They do not always say ‘Let’s refactor or rewrite’ but spend time to understand why a certain block of code is written. If we go along with the analogy of our animal friends, senior software developers should probably be like a wise owl with a perfect vision. They know how the overall system is being used, the next logical improvement area, or a failure point. They are not just writing a code block for a complex system but are providing a solution for a customer’s problem. They provide technical guidance and make architectural decisions by looking at the 10,000 feet picture.

Why Promoting People to Senior Too Soon Is a Mistake

As our businesses grow and evolve, it’s natural to see changes in the roles and compensation of our developers. However, I believe promoting them to senior roles too soon can be a major mistake that may lead to loss of clients, loss of revenue, and damage to the company’s brand. Here are some of the potential issues that could arise as a result of this premature promotion.

Overconfidence: Software developers who are promoted to senior roles too soon may become overconfident in their abilities, which can lead to poor decision-making and a lack of collaboration with their teams. They may be more prone to making mistakes, which can ultimately harm the project and the company. 

Lack of Experience: Senior software developers are expected to have a high level of experience in designing, building, and maintaining complex software systems. If a software developer is promoted to a senior role too soon, they may not have the necessary experience to succeed in this role. They can often miss deadlines, create suboptimal code, and perform poorly.

Career Stagnation: If a software developer is promoted to a senior role before they are ready, they may struggle to advance their career further. Their opportunity to learn is reduced since what is expected out of the senior developers is to teach, rather than to learn. They may become complacent in their role, try to hide out to keep a paycheck, and miss out on opportunities for growth and advancement. This may lead to frustration, confusion, and a lack of direction for the team.

Resentment: Promoting a developer to a senior role too soon may cause resentment among more experienced team members who have worked hard to achieve their senior position. This promotion can be seen as unfair and lead to dissatisfaction and demotivation within the development team. This in turn negatively impacts the team’s dynamics and productivity.

Tarnished Reputation: If you or your organization is promoting software developers to senior roles, well before they are ready to do so, your former employees will be branded as ‘unqualified’ for senior positions and this will damage the reputation of your company, managers, and even the products you build. Your company’s reputation may be affected along with your bottom line.

In the end, being senior should not be for the sake of a pay increase. It is much more than that and should show true mastery in a chosen field. Seniority should be measured not only by the years of experience, but also by technical proficiency, problem-solving skills, contributions to the team, the field and the profession, impact on business value, soft skills, mentorship abilities, and management acumen.

It’s worth noting that these factors are not exhaustive and may vary depending on the company and the specific role in question. Sometimes seniority may be awarded to people who demonstrated exceptional talent, rapid growth, and unique skill set during critical times. I usually look at these exceptions as wartime promotion. In a wartime promotion, there may be a need to promote someone who has exceptional leadership skills or a unique skill set that is critical to the mission’s success. These are often done under fire or very stressful circumstances when time is ticking. Experiences during these times are acquired rapidly and the outcomes materialize so fast.

While there may be exceptions to promoting someone too quickly, such as in a wartime scenario, it’s important to recognize that doing so can have long-term negative consequences for the team, the project, and the company. Seniority should not be given away without any consideration like a candy cane. Careful evaluation of a developer’s skills, experience, and contributions to the team and business is essential when considering a promotion to a senior role.

Promoting someone before they are ready can lead to frustration and dissatisfaction for the developer, as well as decreased productivity and morale for the rest of the team. Therefore, we should strive to develop clear and consistent guidelines for measuring seniority to ensure that promotions are made fairly and based on merit. While management provides adequate support and mentorship along with opportunities for professional development and growth, developers should also focus more on gaining experience, and broadening their skill set rather than being called a ‘Senior’.

Discover Solvoyo Digital Platform