- Published on
How to Onboard a New Developer Onto Your Team

Today I want to talk about something a lot of new founders, and even mature organizations, get into trouble with. They tend to have more difficulty with it than they'd like to admit: onboarding a new developer onto your team.
We often think onboarding is easy. "Hey, here's the stuff. Here's your documentation. Here's the app." You give them all of it, and if they have questions, maybe they reach out to another developer or the lead, get some more context, and hopefully they figure it out.
What a lot of people don't recognize is that onboarding is probably the most crucial part of whether that person is going to be successful on your team, and whether they bring the best of themselves to the team as quickly as you want them to.
Why do the first few weeks matter so much?
There's a thought out there, and I've heard it several times, that someone who is going to wow you for the life of the company will wow you in the first few weeks. Nobody comes in, does poorly for the first few weeks, and then is amazing a year later. Typically, if they're going to be amazing a year or two from now, it's because they were amazing in their first month.
You're not going to get that, though, if you're not giving them the opportunities to shine.
So the short version of how to onboard a new developer: document how your team works before they arrive, meet with them early and often, and actually hear what they think. Here's what I mean by each of those.
What should you document before a new developer starts?
Documentation should be done before this person onboards. It can take any form; there's no one standard way of doing it. I like wikis. I think wikis are a phenomenal way of saving information. A workbook or some kind of online book is fine too. What matters is that the processes are written down.

You need to document not only how the app works, how individual features, screens, or pages work, but also the life cycle of a ticket. Do you work on it and then somebody else does something with it? Do you work on it, create a PR, and send it to QA? Does somebody create a PR and the developers themselves do some QA and double-check it first, and then it gets merged and sent to an actual QA team? Whatever that process is, it needs to be documented.
You should also link every tool the team uses that's going to help the new hire. If you're using something like Jira or Azure Boards, they have a link and they're connected. If there's specific software like BrowserStack that gets used for app testing, they're given access to it. I've talked before about the hardware a mobile team actually needs: if the developer needs a physical device, do they have it so they can start testing and playing around with the app? And have you documented your patterns and practices?
Recently I spoke with somebody who completely believed they could use AI to guide a new hire through onboarding, and it was a complete failure. The person being onboarded had no understanding of what was going to happen. They had no idea whether they were getting the right answers, and even when they thought they were, sometimes they were actually getting the wrong ones. There's something to be said for documenting all of this yourself, in a way that proactively helps the person coming onto your team.
If you've documented your stuff and set yourself up for success there, you're probably going to be fine. If not, that's the first thing you should be doing. I wrote more about what it costs a team to skip this in what happens when your dev team has no process or docs.
Why should you meet with a new developer if the team already knows the work?
As soon as they're onboarded, you want to start meeting with them. Make sure you and your team are meeting with them at some point throughout the first few weeks.
Somebody told me a while ago that this doesn't really matter, because the team is who they'll be working with, the team knows how the work gets done, and so maybe they don't need to meet with that person regularly. I say that's completely false. You need to meet with that person anyway, because the interview was only one part of your understanding of them.
You need to understand how they work. Do they like working more independently or more on a team? Do they like using AI consistently, or would they rather ask somebody when they have questions? Are they relatively new to this tech stack, or to programming in general? Because if they are, there's going to be quite a bit of hand-holding. You need to be okay with that and prepare them for it, and prepare yourself too, or whoever the lead or mentor buddy is for that person.
The more people who meet with your new hire early on, the better your chance of knowing that person is being taken care of, and that they won't just perform adequately. They'll probably outperform.
By then, hopefully they've had enough time with people to get a tour of the app, and a tour of the internal tools needed to make the app work. If they're new to the technology, they've had time to adapt. And if they had questions along the way, they've had the chance to document the answers, maybe not for themselves but for the next new hire.
It's also a really good opportunity for them to check your onboarding documentation. Maybe you do a really good job keeping it updated, and maybe there were a few things missing that this new hire was able to find. Now you can make it a little better for the next person who comes around.
The more you get to know a person, the easier it is to connect with them, and the better you can play to their strengths. I've met developers who are phenomenal at picking up when a test case is broken, and I've met developers who aren't as strong overall but are very good at designing reusable components. You won't get to that understanding unless you really hone in on what their skills are and how you can use them.
One thing I'd like to remind people of: you've already hired them. You trusted them. If you didn't trust them, you wouldn't have hired them to begin with. So if you trust them and you want them to succeed, give them every opportunity to prove that to you at the very beginning. The more you do, the better your outcomes are going to be, and you'll get your dividends. Maybe not immediately, but at some point, for your team, maybe your product, and definitely your company.
Should a new developer share opinions right away?
The only other thing I think is necessary when onboarding a new person is to actually take the time to hear what they think.
There's a practice I've heard attributed to Amazon, where someone newly hired or promoted into a leadership role doesn't speak in meetings for their first week or two. The idea, as I understood it, wasn't that nobody wanted their opinion. It was that the company already trusted the leaders in the room, and the new person needed time to see how things worked before bringing their fresh ideas in. I went looking for that one and couldn't confirm it's an actual Amazon rule, so take it as an idea rather than a fact. What is well documented is that Jeff Bezos ran meetings that started with everyone silently reading a memo, and then the employees gave their thoughts before he did.
For better or worse, I think holding a new person back like that is a good idea in some cases and a bad one in others. On a very young team, one with limited resources or one that's still figuring certain things out, having those opinions early and giving feedback on them is very beneficial. It helps everyone understand where you might be going right or wrong.
I've said this before about junior developers: new developers are great because they come in with fresh ideas, things that worked really well at other organizations or on other apps. We should all be striving to better ourselves, and there's no benefit to letting that live in the dark. I understand there will be times when it's not in anyone's best interest to take more feedback, because things are working the way they are. But if you hear them out, maybe it's not today's idea. Maybe it's tomorrow's, or the next day's, and you can use it then.
When you have someone who's willing to give feedback, good or bad, that's actually very beneficial to your team. It means you've created a healthy enough culture that they trust you with their thoughts, and even when they're wrong, they'll come back later with more that might benefit the team in the long run.
I often see that the teams that do really good work aren't just the ones with the technical capability. They're the ones with a high level of trust in each other. The worst teams are the ones with very little trust and very little conversation happening between them. That doesn't mean you need a dedicated hour or two a week where everybody says whatever they want. It means that if you foster an environment where people are willing to bring up their thoughts, right or wrong, they'll keep bringing them up. And as they get more confident with the tech stack, the product, or the business, they'll come to you and say "this is why I believe this," and you'll know it's right because they've done their research and their due diligence.
What does a new developer need from you long term?
As teams mature, these are things you really want to be doing, especially at the very beginning. Longer term, when you're figuring out how to promote someone, or how you know they're ready for more leadership or more opportunity, it comes down to what exactly you're hoping they'll gain.
You've got to remember there are two parts to a person growing. There's growth that benefits your needs, and there's growth that benefits their needs. If you can find a way to make it work for both sides, you'll have a strong developer who's really going to push themselves. If you only let them focus on one or the other, those people will burn out, or they'll be the first to leave, or the first to get a pink slip because they weren't focusing on what benefited everyone.
As a leader, whether you're the scrum master, the CEO, the CTO, whoever you are, your goal should be to uplift your employees, and a new hire is no exception. If anything, your goal is to uplift them even more at the beginning, so they understand how they can best be used within your company and your culture. It's a big part of how I think about leading a product team for a client. Long term, as you understand where they are and how they benefit you, you should be looking at how they can grow, so that even if they did have to leave your organization, they're prepared for it.
The goal is to keep them forever, and hopefully they're willing to stay. But reality hits, and it's okay that people need to grow and move forward. We have no reason to ever say we shouldn't be willing to uplift somebody. If you keep that in mind and you're willing to help people out, you'll be rewarded, if not by that individual then maybe by somebody else on the team, because people notice. Keep people happy, onboard them well, and I think you'll see better dividends down the road.
Need help with your project?
Chris Martinez
Founder of CAM Software · Mobile engineer
Chris founded CAM Software in 2022. He leads embedded product engineering engagements for established companies with mobile-led products, inherited applications, and delivery challenges. His work spans product alignment, React Native and native mobile engineering, supporting web and backend systems, release reliability, and responsible AI delivery. He also operates software products owned and operated by CAM Software from Northwest Arkansas and works with teams nationwide.