Tips for mentoring junior developers and bringing them up to speed

As impossible as it may sound, the most skilled senior developer on your team was once a junior. That’s right; they used to write buggy code, just like your newly-arrived junior dev currently does. And look at them now!

Junior developers can go a long way, especially with some help from their team. Mentoring junior developers spares them from making every error in the book as part of the learning process.

Mentoring takes time and effort, but it doesn’t have to be a chore.

With these six tips, you’ll make mentoring a more enjoyable experience for everyone involved and help junior developers unlock their senior potential.

Determine the baseline for each new member

Assuming how much your developers know without testing them can hinder their potential, regardless of whether you underestimate or overestimate their current skills.

To get the most out of your team, you should determine each new member’s skill levels individually before you start mentoring them.

Let’s say you’ve hired three junior developers specializing in JavaScript. One has a CS degree, one went through a coding bootcamp, and one was self-taught.

It wouldn’t make much sense to mentor all of them in the same way, right?

Instead, it would help if you first assessed where each developer stands before continuing with the training.

As a starting point, you could refer to the pre-interview sample coding tests they’ve done during the recruiting process and your notes on their code.

Another option would be to give juniors practice assignments during the initial stage of the onboarding, before allowing them to work on actual projects.

Creating clear criteria for these assignments can help you evaluate the skills of your new employees more accurately.

While it’s not easy to measure a mental skill such as programming, there are effective ways to do it. For instance, Binary Studio assigns simple and specific applications to test developers.

Here’s how they measure the results of JS developers.

As you can see, they’ve managed to develop a points system for criteria such as architecture, infrastructure, responsiveness, and more.

If you take a similar approach, you will be able to analyze each area individually and adjust the training program so it addresses any weak points in the new hire’s knowledge.

You could even speed it up if you see the junior developer has already mastered a technical skill.

Once you determine the baseline for each junior developer, you’ll be able to tailor the mentoring approach accordingly. An early assessment will also help you create realistic predictions for their progress and contributions to the company.

Document critical information and workflows

When you hire a junior developer, they’ll hopefully ask question after question. To save the assigned mentor some time, you could build a base of documentation critical for understanding the company and its coding practices.

Joining a new company, regardless of seniority, means a developer will have some uncertainties about the project.

This is even more evident with junior developers, who will likely also have questions about programming.

Asking questions is far from concerning. On the contrary, it shows the dev wants to understand and learn rather than guess. Quora user Jay Nabonne, a senior software architect and developer, finds this a desirable trait.

“I have had junior developers ask between zero and 4-5 questions per day depending on the project. The ones that asked fewer questions made me the most nervous and I frequently had to fix their work because they would be way off track in their solutions.”

However, to save the mentor from repeatedly answering project-specific questions that can’t be Googled, you could refer the junior developer to your company’s knowledge base. Here’s an example of what that can look like.

Knowledge bases, or internal wikis, allow you to gather all information, documents, and workflow details in one place that is easily accessible to the entire team.

Here is what Slite, a popular knowledge sharing tool, suggests you cover in your knowledge base:

• Company policies
• HR process
• Product roadmaps and projects
• Onboarding material
• Process documents
• Company and team structure

Software development companies can also benefit from adding documents about

• Coding standards and style
• Workflow procedures
• Programming tutorials

With all that info, your junior devs will be able to answer a good number of questions on their own.

They’ll also feel more confident and encouraged to continue with self-service learning. Still, no amount of independence can replace organized, supervised training, which is why you should make training the top priority.

Make training a priority

An advantage of hiring junior developers is that you get to mentor and train them in a direction compatible with your company.

Still, you should strive to create a training experience that will not only provide devs with information but also teach them autonomy.

When a junior dev joins a company, they’re the least experienced person there and are often unsure even of the skills they already possess.

Makers, a programming academy, has identified imposter syndrome as one of the factors holding junior developers back from progressing.

“They will likely have the least amount of technical training of everyone on their teams, and may find themselves working with people biased against junior developers. This kind of attitude can often dent the confidence of new developers, leaving them feeling isolated and fearful.”

Luckily, training can get them on the same page as the rest of the team.

By creating a training plan, you ensure that each new junior developer works with the same essential knowledge.

However, don’t forget to supplement the training with individualized add-ons addressing a developer’s specific needs or interests.

A vital part of training is also teaching developers to become self-reliant. There isn’t always going to be a provider of information to assist them, so they have to become experts in researching and finding relevant answers.

After all, an average dev spends a significant portion of the workday looking up code.

Another tip for efficient training is to apply a hands-on approach.

Rather than assigning juniors to watch coding tutorials, you’ll achieve better results with active training.

Give the dev tasks, ask the mentor to supervise them, but don’t forget about the primary purpose of training: empowering the developer to become a valuable contributor to the team.

In other words, training gives you an opportunity to shape junior developers into autonomous coders who know how to use available resources to reach the project goals later on.

Do code reviews

If you want junior developers to write better code, you have to tell them exactly what to improve.

Code reviews help you gain insight into their coding practices and give you the foundation to provide constructive feedback.

In case your junior devs feel uneasy about having their code reviewed, you could let them know it is a common practice and something they’ll encounter throughout their careers, and not just at the beginning.

Even senior developers at Google and other tech giants get their code reviewed regularly. The number of comments they receive over time decreases, but it’s worth noting that it never reaches zero.

So, once you make your developers realize the practice is a normal part of life at a tech company, it’s time to dole out the feedback.

When giving feedback, remember to critique the code, not the person who wrote it. It’s also vital to always find good things about the code, especially with junior developers; even Google’s code reviewing practices suggest doing so.

“It’s sometimes even more valuable, in terms of mentoring, to tell a developer what they did right than to tell them what they did wrong.”

Still, the purpose of code reviews is for developers to upgrade their coding skills, so don’t hesitate to point out what could have been done better.

To help you systematize the process, we’ve compiled a checklist of the features of the code to comment on during a review, based on Google’s suggestions.

As you can see, there’s no room for personal taste in reviewing code. Even the style of code should be assessed according to the company’s internal guidelines.

If you still find a part of the code that could be better but the change isn’t strictly necessary, you can preface the comment with the word Nit (derived from “nitpick”) to let the dev know it’s a point to polish if they want to go the extra mile.

Leverage pair programming

Pair programming, the programming technique where two developers work on the same code, can help your junior developer advance their coding skills in tandem with the mentor or even a peer.

The technique is usually done through the roles of driver and navigator, where the driver carries out the navigator’s instructions, asks questions, and makes suggestions.

The two regularly switch roles, so the junior dev gets to both write code and shadow the senior when they’re driving.

As opposed to the tips for mentoring junior developers we’ve outlined so far, pair programming requires the mentor’s active, real-time participation.

Still, there’s no need to worry that a senior developer might find mentoring and pair programming a burden without getting much out of it. Such an investment of time yields great results in the long run—and science confirms this.

A study on pair programming between novices and experts has found that when two programmers work on the same code side by side, they spend 15% more time coding. Therefore, doing so boosts the productivity of both parties.

However, the return on investment is even more significant.

The study has revealed that pair programming teaches juniors to write better-structured code with fewer bugs.

Some companies also practice pair programming between junior peers, where both of them get to see how the code looks from an onlooker’s perspective.

You can leverage pair programming even if your company is fully remote.

Atlassian, a company producing development and collaboration software, has had great success with the method.

Their Jira team implemented remote pair programming and found it beneficial for the quality of code, as well as for strengthening the bonds between the teammates.

So, if you’re looking for an interactive way your junior developers can upgrade their coding practices, consider pairing them with a senior for a coding session or two.

Start small

Assigning junior developers tasks on actual projects is a valid mentoring method—as long as you supervise them and choose tasks in line with their current capabilities.

Five years ago, a distraught junior software developer took to Reddit to start what would become a famous thread in the community focused on career advice in the computer science industry.

The developer arrived for the first day on their first real developer job and was assigned with running a script to create their personal database instance. During the first 30 minutes on the job, they managed to delete the production database.

The CTO told them to leave and never come back.

Commenters were largely supportive of the developer, claiming that the company was to blame for the fragility of data.

This story warns us to plan the tasks assigned to junior developers carefully. Rather than giving them access to critical data immediately, it’s better to prepare smaller tasks they can get started with in a controlled environment.

Starting small doesn’t mean you underestimate the new dev; it only indicates you’ve taken time to compose a realistic plan for their development.

After all, even the best programmer in the world was once a junior. The way to writing brilliant code often starts with squashing simple bugs or doing other trivial tasks.

As senior coder and programming book author Reginald Braithwaite puts it, all senior developers were once in their careers junior programmers.

All in all, you should focus your mentoring efforts on starting with what junior developers already know and building from there. Together, you’ll be able to broaden their programming horizons and turn them into a knowledgeable individual precious to the team.

Conclusion

There may be thousands of junior devs on the job market, but the opportunity to select a few and guide them to coding greatness is still invaluable.

If you get the chance to mentor a junior developer, try to be mindful of the fact that they’re just getting started. Try to ease them into the process with structured training created in accordance with their current skills, without overburdening the dev trying their best.

We know that mentoring juniors can sound demanding. Still, all mentoring efforts will be worth it because you’ll get a skilled engineer for your company, and the developer will remember you for life as a person who helped shape their future career.