Most companies are searching for senior developers because of their experience, skills, knowledge, sense of humor (no?) which is why it seems like a logical thing to choose a senior developer, right? Well, not necessary.
First off all, there are all sorts of projects with different positions involved, but in the majority of them, 80% of it is repetitive work, which can be tedious for a senior developer, and only 20% deals with architectural decisions that need to be made.
Yes, you’ve guessed it! These 80% of tasks can be worked on by junior developers, while the other 20% must be handled by a senior developer. With this in mind, you might not really need so many senior developers.
One question arises though – why should you choose a junior instead of a senior developer?
– That’s a great question.
– Thanks!
While I talk to myself, you can go to the next section and learn why junior developers could be better candidates than senior developers in the long run.
Why Choose a Junior Developer Instead of a Senior Developer?
Another important element is motivation. Junior developer has a bigger motivation to work on simpler, more repetitive tasks than a senior developer who finds it boring (I hope you are not bored with this article, I am a junior content writer, after all..)
While working, junior developers are acquiring experience and programming skills and are becoming drastically more productive in shorter periods of time. Senior developers, who already worked on similar projects, have a lower increase in productivity over time.
While junior developers’ costs are rising slowly, their productivity and independence are rising rapidly.
On the other hand, a junior developer is someone we can mold to your needs and become a potentially more loyal team member.
It is very hard to find a senior developer. Also, their price is high from the very beginning. Junior developers are less expensive compared to senior developers. With the mentorship from a senior developer, a junior developer can deliver similar quality. Or can he?
The biggest challenge with junior developers is to deliver the same quality and speed as senior developers. But maybe there is a way?
Things to Watch Out for When Choosing a Junior Developer
Just like your search history, there are things you should be careful about when deciding to give a chance to a junior developer.
To ensure the quality of delivery, there needs to be a constant code review process of junior developer’s work. Experienced developer has to guarantee the quality of work and pace of delivery in any case.
It is of great importance that we don’t rely on junior developers in terms of architectural decisions.
Also, a junior developer shouldn’t be someone totally new to software development. You shouldn’t choose someone who is a total beginner. He/she/they needs to have a total knowledge of the specific software development demands. Experience should be the key difference between junior and senior, not talent or technical competence.
How to Choose a Junior Developer and Keep the Quality and Speed of the Delivery?
First of all, you shouldn’t expect autonomy and full independence from a junior developer. In the start, they are probably going to be a bit confused, scared, surprised (add a feeling of your choice) and God knows what (just kidding, but they might feel insecure and need more guidance.)
This is why you need to provide support in terms of more experienced developers. A senior developer, with experience, knowledge, etc should guide the junior developer during not only the onboarding process but until they have enough experience to own the work.
Even though architectural decisions should be made by senior developers exclusively, they should explain those decisions to junior developers and help them to understand the process. This will help junior developers to grow.
A detailed code review of each PR made by a junior developer, needs to be done. You should expect a lot of review comments in the beginning (did you think that this article was written in one take? Are you serious?).
This will decrease gradually when a junior developer grows its skills and experience. A developer needs to learn to identify and use feedback from previous code reviews. Such as, he or she ought to understand how to organize code, what specific requirements need to be fulfilled, etc.
Make sure that a senior developer is always available for answering questions, helping with code and explaining things that are unclear to the junior developer.
Two Main Things We Should Expect From a Junior Developer
Two things are infinite: the universe and the number of questions a junior developer has during a work day; and I’m not sure about the universe. Joke aside, there are two main things that we should be focused on while developing a junior developer.
1) Junior developers should own the solution of problems. They need to ensure that a problem is solved no matter what. If they don’t know how to solve it, they need to find someone who can.
They should keep track of whether they requested assistance promptly. A senior developer should check on junior and ask if he needs help, until eventually junior starts asking for help as soon as he’s stuck.
2) For each solution, extract patterns and knowledge and be able to solve the same class of problems in the future..
Junior developers should play a win game and look for recurring errors and whether they have previously requested assistance. We can monitor their development and knowledge acquisition in this way.
How Do Our Junior Developers Meet These 2 Expectations?
Solving a problem can be done by finding the problem and telling the potential solution to the junior developer or through pair programming.
We should destroy the myth of making junior developers autonomous by letting them wonder by trying desperately to solve the problem by themselves.
They will become autonomous after they acquire enough experience and guidance from senior developers. Junior developers need to ask for help as soon as they are not able or don’t know how to solve the problem.
All these techniques can be modified depending on the specificities of the project and people involved in the process. Sometimes you need to talk about the tasks before working on them to prevent juniors from wandering into some rookie mistakes. You want to prevent reworking of tasks as much as possible.
A senior’s effort is usually cut in half after a couple of months, when a junior is confident enough and has learned good practices, tips, tricks, etc.
There should be less code review comments, questions, a junior is able to structure its code independently, etc. In the end, there are only architectural decisions as a time consuming process done by senior developers.
There are two approaches to incorporating juniors in project teams:
1) There is an architect working directly on the project and a couple of junior developers that he/she mentors. The architect makes all the architectural decisions, and mentors the whole team, helping them deliver while junior developers are the delivering value.
2) You are adding a junior developer to a project, who is being mentored by a senior not directly involved in the project. That mentor is responsible for the quality and pace of the delivery of the junior.
The experienced developer is not directly involved in the project (maybe he/she is working on different projects simultaneously) but it gives guidance and helps the team when needed.
The suggestions in this article on developing juniors can be applied in both cases.
The Bottom Line
If you’re reading this then you are really desperate to hear more arguments about why a junior could be a better choice than a senior developer.
Unfortunately, I am out of arguments, and memes.. The only thing I can do for you is to tell you to try out the proposed set ups with junior developers and see for yourself. You will not thank me because you don’t know me but let’s end this article on a friendly note. Have a great day.
P.S.
Choose a junior developer!
If you are looking for a junior (or senior) developer for your software development project feel free to contact us.
Let’s talk
