Posted on Jul 03, 2020 by @afterxleep

Mentoring Junior Engineers (and new hires)

In a previous post, we discussed strategies to hire, motivate and mentor Engineering Interns and is time to move up the ladder and talk about the recently hired, more Junior members of your team. Let’s get down to it.

Seniority is not only about knowledge

When it comes to software engineering, most people think that Senior Developers are better, faster, and more efficient than Junior engineers. In many cases, they are, but that’s not always true.

I had the opportunity to work with Junior Engineers that, when writing code, outperformed everyone in the team. They were more curious, eager to learn, focused, committed to their work, and wrote beautiful code. Still, when it came to asking questions, helping someone else, communicating ideas, estimating, or dealing with a problematic customer, their world fell apart.

Junior Engineers should be proficient in at least one programming language, and capable of implementing solutions based on simple technical requirements. The main difference between them and experienced developers is that they will need support and permanent supervision from you to stay on track and deliver results.

It is your job as a manager to set up a support framework, keep them engaged, productive, and provide plenty of opportunities for professional growth.

Seniority is less about how much you know, but more about how much support you need.

Hiring

Hiring Junior Engineers is a fantastic recruitment strategy. Its easier to find talent, they are eager to learn, most will go the extra mile, and if treated right, they will become your most loyal and trustworthy employees over time.

As you would do when hiring interns, with juniors, look for fast-learners, problem solvers, and especially good at following directions (yes, that’s a learned skill), but don’t ignore technical abilities.

It is a good idea to use technical exercises during the interview process to validate skills. I prefer short take-home exercises Vs. whiteboard coding, but especially when hiring Juniors, it’s good to share study materials in advance and allow them to prepare. That will level the playing field, allowing you to better evaluate for potential.

Lastly, make sure you offer a clear career progression path, discuss it openly, and answer questions during interviews. The best Junior devs will be more interested in a place where they can learn and build a career and less on benefits like gym passes and catered lunches.

Pair Programming goes a long way

Writing code alongside a more experienced developer has many advantages for junior members in your team. Even if they are just a spectator at the beginning, it’s a fantastic way to get insights about the code, the product, team’s best practices, and technologies used.

During the first few days (a week or so) of your new hires, have them sit down together with senior developers for a couple of hours at a time, and ask your team members to be open for questions and “program out loud. “ That is, merely saying out loud what they are doing on the screen.

Soon enough, your new team members will be able to move freely throughout the codebase, understand the general architecture and coding practices, start proposing changes and ideas, and eventually taking on small stuff on their own.

Pair programming is also a great way to help your experienced team members be more focused and confident. Just don’t force it on them. It might not be a good idea to have your team members pair-train someone else a day before the next release or when everything is on fire.

Frustration-free (paired) Code Reviews

The main goal of code reviews is ensuring code health improves continuously, anticipate issues, and share good programming practices across the team. They also have an essential function for teaching developers something new about programming languages, frameworks, or design principles.

It’s always ok to give feedback (as long as you are doing it from an educational point of view) and leave explicit comments to Pull/Merge requests. With Junior developers and new hires, it’s also a good idea to personally give this feedback.

Giving feedback and requesting changes via your favorite version control system is easy, but it does not leave space for questions and in-depth knowledge sharing. For the first couple of months, ask your team members to take some time to explain their comments in person, and be ready to answer questions.

Doing paired code reviews will promote a culture of transparency and openness, fostering a trustworthy environment, where direct feedback and questions are well received.

Remind them about the big picture

I’ve seen too many places where new joiners are sent out to write unit tests or fix silly bugs for months before allowing them to do anything relevant in the code. This practice is usually the result of lazy tech leads and managers expecting their team members to learn things by doing the work they don’t want to do.

If you want new joiners to become productive fast, don’t be a bully. Give them relevant work from the start. It might sound a little bit scary, but if you take the right approach, there’s nothing to worry about.

Learning something new boils down to focusing on the problem at hand. We put all our efforts into understanding what we see, but don’t necessarily pay too much attention to the big picture. This is especially true for younger developers.

Don’t expect your Junior team members to consider the impact and implications of their work on a broader scale. It is your job to help them understand and look at things from that perspective.

The trick is to give them work that has meaning and matches their skillset. Make sure to explain why they are doing the job, how important it is to the product, company, or service, and its impact in the long run. Soon enough, they will learn to think about those things before pushing code.

Motivate through learning

The more time you allow your team to be curious and learn from others, the more motivated they will be, especially when it comes to Junior profiles.

Your new hires will be very engaged for the first couple of months, but as soon as they can move around freely throughout the code and gain confidence, their learning pace will slow down.

It is your responsibility to keep the team motivated and engaged. A good start is to facilitate time to explore new technologies, products, or technical topics. Hackathons and coding labs, for example, are great for learning for large teams, and technical talks or small workshops are well suited for smaller groups.

Foster a teaching/learning culture by scheduling some time during work hours every week and having one or two members of the team present or talk about a specific technology or idea. Order some pizza or snacks and create a safe space for sharing and asking questions.

Assign a mentor, have plenty of one on ones

Having someone answering your questions goes a long way. Everyone in your team should have a mentor available to answer questions, help with technical problems, and provide career support.

Ask a senior member of your team to become a mentor for your new hire. Agree on a training path in advance, and provide some tools to follow up. Something as simple as a Trello board with pre-defined tasks does is great to track progress.

The mentors should also be responsible for the wellness and professional growth of their mentees, help both on hard (technical) and soft skills development and have frequent one-on-one meetings

Setting up weekly one-on-one meetings with your direct reports is crucial, and especially with Junior team members and new hires. Ask them to come up prepared with questions and arrange a safe space to share them with you.


I hope you have enjoyed this article. Feel free to follow me and reach out on Twitter if you have any questions or feedback.

Check out other posts in the series:


Photo by Alex Kotliarskyi on Unsplash