featured_image

Adebayo Akinlaja

Junior… We’ve all been there. At one time or another in our careers, most of us have started at the bottom, and over time, evolved our skills in order to be known as “senior.” We’ve had lots of challenges — while there may be some we’ve overcome alone, most of us have had support along the way.

Almost all of the write-ups, articles and tweets you read about hiring junior developers describes its negative impact on speed and quality of delivery. I couldn’t disagree more.

I personally have had numerous sessions with junior engineers (many of whom I mentored) to learn how the experiences in the early stages of their career have shaped their growth and confidence in software development. It all comes down to mentorship.

“It’s malleable when it’s still heated and soft, it brittle when it’s cold and dry”

For starters, let’s talk through the benefits of having junior developers join your team. As the potter says, “It’s malleable when it’s still heated and soft; it’s brittle when it’s cold and dry.” The same is true of the contrast between junior and senior developers. If you catch them in the former stage, you can help shape them into the type of developer that you want to work with. Here’s why:

  • The chances of hiring a good junior developer are higher than that of a great senior developer. The latter are in high demand, and they’re expensive. 
  • The growth rate of a junior developer is faster and more consistent than that of a senior developer. When I say growth rate, I don’t mean simply development speed and quality. I’m also thinking about how quickly developers can grow through collaboration and curiosity when there is not an ego at play.
  • Junior developers bring passion, curiosity and enthusiasm onto your tech team.
  • Junior developers with the right soft skills will learn from the senior team members, and with time, become the seniors you wished you were able to find. (You might probably be thinking about retention — I’ll definitely touch that in future articles.)

“I only recruit senior devs. The trick is, I recruit some of them earlier in their career.” – Reginald Braithwaite

In my engineering team, we’ve been continuously refining our on-boarding process to reduce the “time-to-useful” of an engineering hire, which is about 2 months. Building mentorship into the growth track of a junior developer is a critical component.

In software development, knowing what needs to be done isn’t the most important part — thinking about how to get the job done is. Here are the basics of a great mentorship program:

  • It consists mostly of guidance — style, best practices and scenarios.
  • It focuses on coaching junior developers how to learn: Even something as simple as support in navigating the typically awful reference materials for a given language can be helpful.
  • It helps junior developers gain institutional and legacy knowledge about the codebase and its eccentricity.
  • It benefits your senior developers as much as your junior developers: Being a good mentor is a people skill (soft skill) that is helpful for senior developers to develop. 
  • It defines the difference between a productive junior developer and an unproductive one.

Both the mentor and mentee benefit from a strong mentorship program. Next I’ll dive into what they each have to gain from the process, the things they both need to consider before applying for or providing mentorship, and mentorship plans and schedules.

Benefits

Mentor

  • Glaze and polish your people management skills
  • Improve public speaking and building interesting conversations
  • Master working efficiently with junior developers
  • Learn to explain technical concepts (design approach, implementation details, architecture etc) without omitting details that may seem obvious
  • Improve and boost confidence on the mentorship subject — code refactoring, database and query optimization, clean code and using development approaches effectively

Mentee

  • Increase speed to ramp up on programming language and codebase
  • Learn development life-cycle best practices (not only coding)
  • Improve professional growth
  • Improve development / growth rate with a close feedback loop
  • Boost confidence in knowledge of a subject

“With more questions comes great insight even to things considered crystal clear”

Considerations

A good mentor must:

  • Show respect for both the mentee and the company’s goal
  • Create a sound and objectively sane relationship / bond with mentee
  • Be tolerant. Critiques should be focused on code, subject area and not people or personality
  • Allow mentees take complete ownership of tasks assigned to them
  • Allow room for initiatives and step aside sometimes to give mentee room to lead conversations and sessions
  • Give prompt feedback, bearing in mind that they have to be Actionable, Specific and Kind. (It should be more of candor and not cream-rubbing) 
  • List and follow through on specific goals and objectives — not pool of goals without clear expectations

A good mentee must:

  • Show respect for both the mentor and the company’s goal
  • Maintain a sound and objectively sane relationship / bond with mentor
  • Receive feedback with grace and dignity
  • Have limited list of goals before requesting for mentorship
  • Proactively seek for feedback and follow through on goals — crossing and ticking

What to do

Company

  • Create an enabling environment where mentorship is a default
  • Give room for early morning mentorship sessions — incorporate into company culture
  • Promote logging on mentorship hours
  • Have pair programming tools and softwares in place

Mentor

  • Have a kickoff session where expectations and follow-up schedules are discussed (Visual cue is very important, always turn on your cameras during video calls/online meetings)
  • On your own, draft out your personal goals from the mentorship, milestones and mentee growth signs. Keep a list and tick as you cross / achieve them
  • When discussing expectations, if you are targeting specific programming topics, have timely outputs on each topics to cover (strive for concise bullet points)
  • Mentorship sessions are great during the early hours of the day; block out few morning hours
  • For consistent and short feedback loop, create a channel for feedback and document all feedback (Slack and google docs)
  • Shadowing is a good way for mentees to learn; Invite mentee to meetings, calls and pair programming sessions (google calendar)
  • Technical mentorship can be a lot straight forward, don’t overlook soft skills
  • Be available, open minded and share adequate resources
  • Follow through on the expectations and goals
  • End of day check-ins is a “great-to-have”!
  • After the mentorship program, take out time to reflect on all that was done and achieved (retrospective)

Mentee

  • Have your expectations and goals drafted out — what would you stand to gain from the mentorship program
  • Document feedback and work on them (continuous improvement / continuous delivery)
  • Take general notes on almost everything
  • Be available and accessible
  • Take on more and go on chasing bugs
  • Accept criticism / feedback
  • After the mentorship program, take some time to reflect on all that was done and achieved

Naturally, a mentee who has grown and gained from mentorship should pay it forward and take on a mentee of their own to continue the cycle. The importance of mentorship can’t be overstated. I hope these lessons will help you prepare for a great mentorship program.

featured_image
About the Author

Adebayo Akinlaja

Thanks for subscribing!

 

Partners

Tap into a global talent pool and hire the “right” developers in days, not months.

Developers

Accelerate your career by working with high-performing engineering teams around the world.

BECOME A DEVELOPER

Hire Developers

We take great pride in matching our developers with the best partners. Tell us about your team below!

preloader_image

Thank you for your interest

A member of our team will reach out to you soon.