A few weeks ago, my friend Nico König asked the Twittersphere about best practices when onboarding a new junior developer to your team:
As someone who was recently a junior dev, I have a lot of opinions on this topic. So I decided to summarize them in this post (in no particular order).
💭 Distinguish between opinions and best practices
When you're talking over concepts with your junior, deliberately point out whether the things you're saying are your personal views or proven best practices.
We work in such an opinion-heavy industry. So sometimes it can feel impossible to differentiate feelings from facts - especially if you're new to programming. One tangible way to help with this is to provide resources describing why something is best practice.
🖥 Dedicate time early on for Git commands
On the very first day (or maybe second), walk through the Git commands that you use most frequently on the job with your junior. Nothing is too basic - particularly because many bootcamps or university programs don't teach Git. For example, the bootcamp I went to used Git for version control, but all of our tasks were done solo. So more collaborative Git workflows (like branching or pull requests) were new to me when I started my first developer job.
Ideally, you'd also take the time to explain what each command is actually doing. It took me nine months and one colleague sitting down with a pen and paper for me to finally figure out how a rebase works. Speaking of, teach them how to rebase properly!
📝 Have something for them to work on
Give your junior something to work on that is low pressure, but still impactful. If you're stuck on what kind of work falls into this category, think either nice-to-haves (style improvements, microinteractions, bugs that aren't critical, etc.) or general improvements (refactoring, accessibility, performance, etc).
Be sure to have a dedicated backlog of tasks ready for them to choose from. For most junior developers, this will be their very first software job. So it's unrealistic to expect them to "take initiative" and decide what they should work on without a curated task list.
✅ Give constructive code reviews
Code reviews are a major. At best, code reviews are constructive and serve as continuous learning opportunities. At worst, they can destroy trust and safety within a team.
As the reviewer, you should be pointing out things that are done well and if you have critiques, explaining why something is problematic rather than only saying ‘fix this’ or offering the solution.
👩💻 Practice pair programming
Set regular, dedicated times for pairing (like literally put it in the calendar). I'd recommend at least twice per week. You can have a set of tasks that you work on together or switch between individual tasks.
When pairing, make sure you're alternating between who's driving and who's navigating. Depending on your junior and their learning style, this could also be them observing you. Personally, I learn so much from watching and asking questions.
🧠 Pair on things that aren't code
It feels weird at first, but I promise that it’s helpful. Show them your workflow, how you prioritize tasks or approach learning something new. One of the best non-coding pairing sessions I've had was a colleague walking me through how he conducts a code review.
How you test your own code? Dive into a new project? Manage your time? Plan a company-wide presentation? All of this is valuable.
🙋♂️ Always be available for questions
Make your junior a top priority. When they have questions, stop what you're doing and help them. If you don't know the answer, help them find it - whether that's searching through StackOverflow or introducing them to someone who knows that domain better.
Jess Mitchell also made an especially excellent point about tone:
💞 Get them a buddy or mentor
This should be someone (not their direct manager) that will guide your junior through their onboarding. Your junior should also feel comfortable talking openly with this person and discussing any problems they might be having.
Ideally, your junior and their buddy will meet at least once per week during the first 6 months.
📚 Learn their learning style
Get familiar with your junior’s learning style and try to cater the resources and materials you send them to that style. So if they like books, try to recommend books or written articles instead of videos courses. It's a small gesture, but it'll help them succeed and shows you care.
⏰ Respect their time
Set a good example by not sending emails at wild hours or pressing for tasks. Let them know what's expected from them in terms of working hours. An example of why this is important: In my first tech job, the lunch break didn't count as working time... but no one told me that even if I took a shorter lunch, I still couldn't leave earlier. Later, the fact that I left 30 minutes early every day was brought up as an argument not to keep me 🙄
On a related note, try to encourage wellness by recommending self-care tactics and being open about mental/physical health (if you feel comfortable and safe doing so).
📋 Provide regular feedback
Give regular feedback and updates about how they’re doing. If you're working in a country with a probation time, try to give weekly feedback during that time.
Your junior will likely assume they are doing worse than they really are. But if there is something that needs to be fixed, be sure to tell them enough in advance that there's time to make a change.
🌱 Show humility yourself
Admit when you don’t know things and search for answers together. Offer regular opportunities for them to give you feedback and maybe even in a variety of ways (sometimes face-to-face, sometimes written, etc).
Ultimately, their success is your success, so it's important to know how you're doing throughout this process as well.
Did you find this helpful or useful? If yes, please consider buying me a coffee so I can continue to write posts like this ☕️
Top comments (59)
While this is true of any dev, it's double true of junior devs:
The first weeks, they are going to be anxious to do something - anything - of value. If your code base is particularly complex, this will be difficult. But one thing a team can always use is perspective, and that is easiest to get from a new person.
For years, my go-to task for week one was for the new person to improve the Wiki. Find all of the bugs in our setup docs. Define all of the jargon words we forgot to define. That's all defensibly useful for hiring the next person, which is great, but other than a sense of accomplishment, it doesn't help this person all that much.
In communication or teaching, you want the listener to repeat back what you've just said in order to determine if they actually heard you. Have them work on the high-level overview of the system. Everything they get right, is explained without a bunch of circular reasoning. Everything they get wrong is a teachable moment. And every good teacher knows that they learn as much in the teaching as the student does in the learning. Often this is a good way to find missed features, or solutions to problems you thought unfixable.
I'd always suspected this, but this is the first time I've read it written by someone else.
Developer experience is no different than user experience in this regard. You don't know how many assumptions you assume you're not making, and only outside feedback and the more than occasional ELI5 request (see? I just used an acronym assuming everyone on Dev would know it... That's "Explain Like I'm 5" for those who didn't) can help to undo those assumptions.
Good tips! I wish more companies / teams would give pair programming a serious try. I've had great experiences since I did an internship back in 2006 and the onboarding was basically an introduction to pair programming, a couple of demos showing us how to do TDD, then "okay, partner up with someone and take a task card off the board over there".
Another thing I find helpful is to make sure there are a couple of really well-defined, small-scoped tasks available for them. Or sit down with them and extract several small-scoped tasks from something in the backlog, then pair up. I really don't like welcoming newbies with "here is the link to ALL OF OUR DOCS" or "here is the our Github org -- feel free to browse through all the source code we've ever written". It's much better if they can sit down and discover the relevant parts of our systems (not the dead code from three years ago that's still referenced in our docs), as needed, to do something concrete and easy to measure... so they know what they're doing makes sense.
be aware that folks are different. Not everybody is fan of pair programming. Fore some, following some online courses is a better match. Or even reading a book. Best would be your organisation provides some self-made tutorials, programming guidelines with a lot of examples, template code and snippets to pick from.
My observation: pair programming often leads to silo-thinking and micro-standards but seldom to the quality standards you might need for larger projects. PP heavily depends on the people. Unfortunately the best folks for PP are the most absorbed ones. Knowledge extraction and distribution processes are - at larger organisations and over a longer time period - more important than PP - my very personal observation.
Agreed, but I do think it's a skill that everyone should learn.
I've never worked in a larger org so can't comment on your other points, but I'm tempted to believe that if pair programming leads to "silo-thinking and micro-standards" then you have a much bigger problem that isn't pair programming's fault 🤷♀️
Dear Carolyn,
When you "think" about stuff, that you have never seen, does not make you a professional :-)
It's just wild guessing and is one of the problems that is holding startups back from scaling and growing fast.
All this has nothing to do with IT but with human nature. I am not saying that pair programming is bad. But it is not enough. When you just have pair programming without a programme around it that makes sure, the the right and always different pairs are built, different characters are addressed their way to learn best, trainers are trained and rewarded, folks are fired who never learn, remain dependent on others, never pay back or contribute etc. - you know - all the general HR stuff - you will get efficiency and motivational problems only Microsofts and Googles can afford - but will take lifes when you are an airplane or car manufacturer, responsible for a nuclear power plant etc. ;-)
Seems like you speak from bitter experience, here.
And there's more to the merits of coders learning to pair program than wild guesses. I don't think anybody's saying it's something everyone should do, but it there may be some benefit to learn it in case it's useful in the future, with the right company, colleagues, or program. Tools in the toolbox, and all that.
I have always hated pair programming, as a junior and as a senior dev. It has never not made me feel uncomfortable personally, on either side of it. It's not quite as bad virtually, but still far from great.
I couldn't agree more! I wish I had such kind of onboarding process at the beginning of my programming journey back then. Great post, the topic is worth attention!
Hello Carolyn!
My name is Tatiana, I’m a Brand Manager representing Plarium-South, an international game development company specializing in mobile and browser games (company.plarium.com).
We would like to translate your article and post it in our blog on Habr.com.
We appreciate your consideration of our permission request. Link to the specific original content will surely be provided in the translated version. Looking forward to hearing from you soon!
Regards, Tatiana
Hi Tatiana! I've received your message (and DM, and email). I'm thinking about it and I'll let you know soon.
Thanks! I look forward to
Hi Carolyn! Are you ready to give an answer?
Hi yes sorry for the delay, feel free to translate it 😊
Thank you for offering and thinking of this!
Thanks!
Great post with valuable concepts. Please also consider to make it clear to management, that this process is crucial for mid to long term success. It's an Investment. By the way - I created a pull request and had the junior review it, which made him comfortable with the process and also indirectly pushed him to correct MY mistakes.
💯💯💯
Yeah this is worth tying to risk reduction and revenue.
Great advice!
Many developers often forget how little they knew when they begin. Nothing is too basic for a beginner about Git, that's true, but for many other things as well.
I saw many experienced developers explaining clean code, OOP, and TDD in half an hour. Going little step by little step is, I think, a better idea.
Good tips! I've been implementing almost all of these at MousePaw Media for years, and can vouch for them.
The only one I can't follow is having a "buddy who isn't a direct supervisor". Our particular situation makes that impossible: I have to be both the internship supervisor and primary mentor at this point, since we're so small. But, because of how leadership and decision-making is structured within the development team, that works out pretty well regardless. I also strongly encourage people to work together without me, through pair programming, code review, chat, and other collaborative opportunities, so developers wind up supporting each other anyway!
sometimes it is the same body but different ROLES!
Knowing which ROLE one is playing for a given moment and acting accordingly is something that is even more important the smaller you team!
That's definitely one way to look at it. I will occasionally switch into "Supervisor Mode", but I have to say, it's not often. My management style is already more "guide" than "herd", my philosophy being that it's easier for you to dig yourself out a hole you dug, than to dig yourself out of a hole I dug for you. I'll let individuals decide how they want to approach a particular task they've been assigned, and I'll seldom interject my two-cents until they ask for it (the one exception being if they are about to walk right into a proverbial landmine.)
Anyone choosing to hire junior devs should be prepared to shoulder some of the burden of teaching them. If you can't afford to spend time doing that, you should only hire senior devs (which also has an associated and increased cost). It's unreasonable to hire a junior person and expect them to only have other juniors to mentor them. A junior dev is an investment - they won't pay off right away and require time in place of the higher salary you'd pay someone who could hit the ground running.
Your response sounds like you've had a lot of junior devs foisted on you, which is not the junior's fault. Presumably, a company knows what skill level they are hiring someone at and it doesn't make sense to be angry that they take more time to onboard.
Great article. I wish we had a better word than "junior" for people. I'll never call anyone that.
I like the part about being honest about what we don't know. The illusion or perception that we know everything is harmful. I look for any opportunity to say I don't know something. Even the newest, least experienced developer will know things I don't.
Also distinguishing between opinions and best practices. Even best practices are usually subjective. It's okay for a team to decide to do something and expect new members to go along, but we should be prepared to explain anything and answer questions. The worst thing we can do is portray a practice as something decided by Smart People (You Are Not Included) Who Shall Not Be Questioned.
I especially dislike, "That's not how the team does it," as if the the person we're talking to isn't part of the team. Chances are that's not how we meant it. But we should at least ask ourselves, "How do I mean it?"
Some comments may only be visible to logged-in visitors. Sign in to view all comments.