7 Key Reasons Junior Developers Fail to Become Senior

Photo by Clark Van Der Beken on Unsplash

The speed of promotion in software engineering roles is astounding. Sometimes junior software developers start work on a project and by the time the project is finished they have become senior.

“I think there is an issue with those who are quick at completing simple tasks rather than following coding standards. Those who produce solutions that are not maintainable. Put another way, some developers are junior and stay junior.

Here are some key reasons that your junior friend stays that way.”

Look for yourself at the tell-tale signs of a junior:

Arrogance

“I’d say your arrogance clouds the judgment of the perennial junior developer. 

Junior developers tend to speak more than they listen. They tend to think of their own solutions and stick to them — even when the evidence points to them being incorrect.

Now it is fairly normal for software engineers to be rather judgmental. I’ve been dinged in the past and told I’m not a ‘real’ developer for not using vim for example (seriously). However, this is about developers who take their own opinions more seriously than that and stick to them for longer when they shouldn’t.

Thinking you are always right is a classic junior trait.”

Superficial Code Reviews

“Code reviews are essential for a good software development process. 

Junior behaviors here include (but are not limited to) trivial comments. You know. Those spaces the linter does not have a rule for. A line break here or there. Complaining about the spelling of something which is correctly spelt (seriously).

I know we should get a linter and move on from this type of thing. However, the permanent junior usually finds a way to keep on finding issues.

Trivial code review comments are a classic junior trait.”

Depth of Knowledge

“Not all senior developers have a first degree. A second degree is incredibly rare. The good news is that you don’t need any formal qualifications to become a great senior developer. 

However senior developers need a breadth of knowledge. That doesn’t mean copy-pasting solutions from previous employers (which happens from my ‘senior’ colleagues) or other ways of faking knowledge. 

A senior developer thinks about their solution in terms of the entire context of the project, their collegues and the customer. They often say ‘it depends’ because of this but you’re not a senior just because you parrot that phrase.

Lacking depth of knowledge is a classic junior trait.”

Emotional Decisions

“At the best of times, we can’t make all our decisions based on data. 
However, when making changes to our codebase I think there is no choice. How do you know that your solution is better if you don’t make checks on your presumptions?

It’s not just that junior developers often ignore the data. It’s that they take incomplete data sets as data or misinterpret results to fit with their worldview.

Making emotional decisions is a classic junior trait.”

Overly Complex Solutions

“Competent developers are always looking for ways to simplify. That should be the name of the game.

I’ve noticed that junior developers often hack around until they come up with a solution that works. Any solution at all? This can lead to a convoluted and difficult-to-understand solution that is barely maintainable. 

What marks out the higher quality code of a senior is that last step of development (after testing, which isn’t even included in this list BTW), making the code easy to read and maintainable.

Anyone can write code that a machine can understand, the skill is in writing code that humans can understand (paraphrasing Fowler).

Creating over complex solutions is a classic junior trait.”

Chasing The New Hotness

“When a new technology reaches the market, it’s great to find out about it. Creating toy solutions at home to become familiar with that technology is indeed great.

Bringing a half-baked solution to work? Makes the code difficult to maintain and understand. It might be a great solution to a problem. But is it the solution that works for the whole team? Does it require documentation that inevitably is not read by half the team? So many questions, but you’ve already implemented and pushed your code now. Frustrated that your colleagues aren’t bright enough to understand your solution? The problem is you, unfortunately. If you encounter this situation you are doomed to stay a junior.

Chasing new technology for its own sake while forgetting your colleagues is a classic junior trait.”

Bad Assumptions

“When developing we all make assumptions. The quality of our code is influenced by the quality of those assumptions. 

How many code reviews make the fundamental attribution error and fail to consider the situation when judging the quality of the code? That’s when we assume the developer is at fault and not the situation in which they find themselves.

Jumping to solutions without planning your code can have serious consequences which can leave a codebase riddled with bugs.

 Making poor assumptions is a classic junior trait.”

Conclusion

“I remember one senior software dev. Very junior but when taken on insisted on having a six-month review with a view to being promoted to senior. Although they didn’t know much about coding they made sure to give an “opinion” at every opportunity. 

They got their promotion but I think you shouldn’t follow this path. You should adopt senior practices and behaviors to become senior. That can’t be that hard to understand can it?”