We’ve all been “the new person” at the office. Lost, confused, excited for the work ahead, but still not quite sure how to log into the computer.
Onboarding is the process of moving brand new developers from confused and lost to productive and high functioning. There’s a ton of information that new technical employees need to learn before they can start doing their job. How you train new team members makes a big difference to their success long term.
Tech companies have the highest employee turnover of any industry. 23% of new hires won’t make it to their one year anniversary, and poor onboarding processes are a big driver of this turnover. In this post, we break down why you should take the time to set up a formal onboarding process, as well as some best practices for welcoming your new developers.
Why you need a formal onboarding system
If you’re only hiring a handful of new developers each year, it can be tempting to “wing it” and let developers figure it out as they go. There’s a commonly used expression in software companies of “drinking from the firehose”, implying that hitting new hires with as much information as possible in their first week is a good thing. Sink or swim. Dive into the deep end. Why are we so insistent on drowning our new employees?
Developing a repeatable onboarding process will set employees off on the right path from the beginning. Companies with a specific budget for onboarding are more likely to retain employees, their new hires become fully productive faster, and new hires are more likely to develop into corporate leaders.
Instead of letting developers find their own way to productivity, we need to be prescriptive about how they learn. Your new developers don’t know what they need to know — only you can tell them that! By breaking down your environment, workflow and code base into digestible training plans, you can make sure your new developers cover every aspect.
Setting clear expectations also make your new employees happier! It’s terrifying to be in a new job with a new code base, hoping against hope that your boss doesn’t realize they’ve hired the wrong person. This feeling is called impostor syndrome. There’s often a little doubt when you start at a new job, wondering if you’re up to the challenge. You’re worried about being on probation and losing your exciting new job. This can lead to holding back on questions to appear “smarter” or constantly wondering how you compare to their expectations. By setting milestones and learning outcomes early, new employees will feel more confident. They’ll know there is no such thing as a stupid question.
A thorough onboarding plan sets a baseline for future success. There are generally at least two ways to solve every problem, but if your team is doing everything one way and a new hire is working a different way, you’ll run into problems further down the line. Remove bad habits from the start by laying down best practices early
The length of your onboarding process depends on the size of your company and the complexity of your codebase and infrastructure. Atlassian devotes a week to new developer bootcamp, and Facebook’s bootcamp is 6 weeks long.
Policies that make for easy onboarding
There are a few ways you can build your team to make it easier to onboard new developers into it. Generally, consistency and convention are easy to pick up. Customization and chaos are not.
- Formalize your team’s code style. Linting tools are available for almost all modern languages — it’s disheartening to spend time crafting a pull request you’re proud of and then receive negative comments about naming conventions. It’s an easy setback to avoid.
- Use conventional workflows wherever possible. For example, follow a formalized git workflow. Atlassian provides a great overview of common git workflows. Stick to one of these, and there’s a good chance a new hire already knows and understands the process. If they don’t, the web is full of tutorials and specs to help clarify things. Best of all, you don’t have to keep the documentation up to date yourself.
- Automate your development environment and deployment. Use tools like Vagrant or Docker to quickly get code running on a stable environment against the same dependencies with everything preconfigured. No one wants to be editing a php.ini file, debugging dependency conflicts and tracking down package manager versions on their first day. (In fairness no one ever wants to be doing this, but it’s much worse on your first day!). As a bonus, your team gets a repeatable environment which will reduce friction during code reviews, testing and pair programming.
If you think about how many new developers you’ll need to onboard over the life of your product, it’s easy to see how easy-to-navigate workspaces pay off. Developers will be up and running much faster.
Begin onboarding before they arrive
A big chunk of onboarding needs to be done before the new hire shows up the office. Some of these tasks can be done by HR, and others will need to be handled by a technical manager:
1. Set up what you can before they arrive. It sounds obvious, but turning up to a new job and finding out they haven’t even found a desk for you doesn’t make you feel like the company is excited to have you on the team. Make sure they have a computer ready to go, and any other tools they’ll need to get started.
2. Remove as many chores as you can. If setting up a development environment takes a long time, then consider doing this ahead of time. Waiting two hours for a database migration to run isn’t as much fun as coding!
3. Create any logins they need to team tools. You can send all the setup emails to their new inbox to be waiting for them.
4. Paperwork is no fun. Send it to them ahead of time to make sure they get paid quickly, and they aren’t wasting valuable (and fun) coding time shuffling papers.
5. Setting up a Trello board with all of the tasks needed for onboarding can help keep track of all the moving parts. Assign HR tasks (like setting up a new desk or payment paperwork) to your HR contact. Assign reading and research tasks to the new hire. By checking off items, you can make sure the hire is on the right path to success.
The great and critical first two weeks
The first two weeks are vital for setting the right tone for the rest of their tenure:
Assign a mentor or buddy to your new hire. A dedicated mentor can be a great resource for newbies. If there are confusing parts to the process or code, it’s more productive to ask someone for help than to keep crawling through an unfamiliar codebase until you’ve worked it out. New hires shouldn’t have to worry about who to ask or whether their problem is worth taking up this person’s time. Buddies can also help with the simple logistics of working in a new office. Where’s the best lunch spot? Where do we keep pens? I’ve brought my own stationery from home because I didn’t feel comfortable asking anyone where I could grab new pens from!
Ship ship ship! Even if it’s something small, get your new team member to ship something early. Adding a visible improvement to the code base (and ideally deploying in production) is a great way to make a new employee feel valued and part of a team. They’ll also gain valuable insight into the deployment processes and architecture.
Introduce the rest of the company. Odds are your developer will have to interact with other departments throughout their job. Show them around the office and introduce them to other teams they might work with. Support, marketing and product management are all important teams to know!
Code reviews. It’s obvious a new start needs to take a look at your new hire’s code, but also get them to review other team members code early. It gives visibility into the most up-to-date parts of codebase, and encourages interaction between more members of the team.
Measure, track, improve!
After a hire has completed the onboarding process, book some time with them to get feedback. Find out what was helpful and what could be improved or dropped completely.
New employees come at problems with fresh eyes, so they’ll likely spot missing documentation or broken processes along the way. Processes change and occasionally, onboarding documents might miss the update. If things are broken, now is a great time to fix them.
Track the productivity of new hires over time. You need to be hiring regularly for this data to be useful, but if new employees are taking more and more time to become productive, you should revisit your onboard process and see how you can get them up and running faster.
Recruiting new development talent is an expensive process. Depending on the time spent looking for that perfect fit, you could be spending between $20–30k on your next hire before they even walk in the door. Doesn’t it make sense to give them the very best chance to be successful and keep them around?
Spend time and energy on building out a thorough onboarding process. Your new developers and productivity will thank you!
Never miss another post. Sign up for the weekly 100TB newsletter and follow us on Facebook and Twitter.
Originally published at blog.100tb.com.
