Latest / DevQuestions with Tim Corey / 322. How to Onboard a New Developer the Right Way

Transcript

322. How to Onboard a New Developer the Right Way · DevQuestions with Tim Corey

• 0:00
  SPEAKER_01: Your team just hires a new developer.
• 0:01
  SPEAKER_01: How do you get them up to speed?
• 0:03
  SPEAKER_01: How do you make sure they become a productive member of a team as quickly as possible?
• 0:08
  SPEAKER_01: And how do you get them comfortable with how you do things as a company?
• 0:12
  SPEAKER_01: Setting up a new developer for success in a new environment can make a big difference when it comes to their long-term success.
• 0:20
  SPEAKER_01: It can also make the team as a whole better as well.
• 0:23
  SPEAKER_01: Let's talk about how in today's episode of DevQuestions.
• 0:35
  SPEAKER_00: Welcome to the Dev Questions Podcast with Tim Corey.
• 0:39
  SPEAKER_01: Software development is more than just writing code.
• 0:42
  SPEAKER_01: So let's talk about the rest of it.
• 0:44
  SPEAKER_01: Specifically, let's talk about how to onboard a new developer the right way.
• 0:49
  SPEAKER_01: Now, if you've ever started a new job at a new company, you probably remember the confusion.
• 0:54
  SPEAKER_01: You're setting up payroll information, getting your healthcare information ironed out, filling out forms, going through the handbook, and more before you even get to the actual job.
• 1:03
  SPEAKER_01: Then you sit down at a brand new computer, figure out your login, and start on the real work.
• 1:09
  SPEAKER_01: You have to figure out where the shared files are, where the documentation is, you have to figure out how to actually start working on code, where the code is, what the process is of getting code into production, where to find out where the tickets are, and so many other things.
• 1:25
  SPEAKER_01: There's a lot that gets thrown at you right away.
• 1:28
  SPEAKER_01: And the worst part is that you get all this fire hose of information and you miss things.
• 1:34
  SPEAKER_01: And then you feel like you feel bad about having to ask again and again for these things because you forgot.
• 1:42
  SPEAKER_01: Now, on the side of the current developers and management, the process is often similar as far as it's a bit of confusion where they we just hired somebody new.
• 1:53
  SPEAKER_01: Now what do we do?
• 1:54
  SPEAKER_01: Oh, we gotta remember to get all the documentation put together.
• 1:57
  SPEAKER_01: And where is a documentation?
• 1:58
  SPEAKER_01: Do we have documentation?
• 2:00
  SPEAKER_01: And oh, we need to get them a computer.
• 2:01
  SPEAKER_01: What should we installed?
• 2:03
  SPEAKER_01: And how do we do that again?
• 2:05
  SPEAKER_01: Because we haven't done it in years, because we've had our computers running forever and so many other things where it's kind of just ad hoc and as you go.
• 2:15
  SPEAKER_01: Unfortunately, most companies waste a whole bunch of time during this process while still not doing a very good job.
• 2:22
  SPEAKER_01: So let's talk about what things you should work on before hiring a new team member so the process goes much smoother and so your team operates better as a whole.
• 2:34
  SPEAKER_01: So, number one, let's establish a standard work environment that can be automatically set up.
• 2:41
  SPEAKER_01: This is if you use Visual Studio, then here's Visual Studio, and here are all the plugins or extensions we use and have a list.
• 2:49
  SPEAKER_01: If you use VS Code, well, you can even have a VS Code setup that just sets everything up with different environments for the way you work on different areas of the code.
• 2:59
  SPEAKER_01: And if you have options, well, that's fine, but document them.
• 3:02
  SPEAKER_01: Have an automated process for installing the tools you need.
• 3:06
  SPEAKER_01: Because it's usually tools that are, you know, maybe you have to install FFmpeg on a machine because you have to make sure you process videos a certain way or whatever the case may be, have a process to automate that as much as possible.
• 3:20
  SPEAKER_01: Because here's the thing.
• 3:22
  SPEAKER_01: First of all, it's gonna help a new hire because they're gonna have the same setup as everybody else.
• 3:26
  SPEAKER_01: Now, yes, we all customize things and you know change our themes or whatever.
• 3:31
  SPEAKER_01: But for the most part, you should have a standard base you work off of.
• 3:35
  SPEAKER_01: And that'll help them get up to speed.
• 3:38
  SPEAKER_01: And when you show them, oh, you're gonna do this and go here and go there, they're using the same tools so it looks the same.
• 3:45
  SPEAKER_01: And it's much easier for them to understand and follow along with you.
• 3:49
  SPEAKER_01: There's less translation about, oh, well, you're using Visual Studio and that's how you do it, where I use VS Code or we use JetBrains or whatever the case may be.
• 3:58
  SPEAKER_01: But also, if your computer crashes, which does happen, I have lost a few machines in my day where the machine fries, the hard drive fries, something goes wrong, and you need a new machine.
• 4:11
  SPEAKER_01: Well, you don't want to spend the whole day setting everything back up, installing everything.
• 4:16
  SPEAKER_01: Again, this is where Docker really helps too, because if you're using like SQL and MongoDB and RavenDB and all these other database environments, that can be very quick to set back up.
• 4:26
  SPEAKER_01: But if you have a standard work environment with configuration for how to install it automatically, well, you can do that too.
• 4:34
  SPEAKER_01: So you can get back up to speed very quickly when your computer dies.
• 4:39
  SPEAKER_01: That's number one.
• 4:40
  SPEAKER_01: Number two, keep documentation of your systems and processes and keep them up to date.
• 4:47
  SPEAKER_01: This is where the central storage is, where the ticketing system is, and how to get to it, and what the logins are and who to ask for logins, who's in charge of these different systems.
• 4:59
  SPEAKER_01: So if there's a problem, you know who to go to.
• 5:02
  SPEAKER_01: And all these various things, keep them and keep them up to date.
• 5:06
  SPEAKER_01: Document your process.
• 5:08
  SPEAKER_01: This is where maybe AI can help a bit.
• 5:11
  SPEAKER_01: I'd be very careful though, because yes, people will just say, well, AI can do the grunt work of just documenting.
• 5:18
  SPEAKER_01: Yes, but what happens instead is it creates some verbosity there that makes it really difficult to understand where things are because of so much content.
• 5:26
  SPEAKER_01: And what you really want to have is as small as possible documentation.
• 5:32
  SPEAKER_01: You want that to be, you know, a little bit of information, not paragraphs and pages of information.
• 5:38
  SPEAKER_01: So, and the other thing is you don't want to give AI any kind of login information or or any kind of keys or anything else.
• 5:48
  SPEAKER_01: So be careful there.
• 5:49
  SPEAKER_01: But this is where you document your system and your processes.
• 5:54
  SPEAKER_01: So, number three, and this kind of goes along with this, but document every step to fix a bug and deploy it.
• 6:04
  SPEAKER_01: Every step.
• 6:06
  SPEAKER_01: So this comes from where do you get the ticket for that?
• 6:09
  SPEAKER_01: How do you know it's assigned to you?
• 6:10
  SPEAKER_01: How do you filter just the ones that are assigned to you?
• 6:13
  SPEAKER_01: How do you prioritize all these things until you get to the point of, okay, we have a bug now.
• 6:18
  SPEAKER_01: Let's walk through the process step by step with pictures on how to fix that bug.
• 6:25
  SPEAKER_01: The reason you do this is because this is probably one of the most common processes you do.
• 6:30
  SPEAKER_01: Now, if you have a different common process, document that.
• 6:33
  SPEAKER_01: But this is a very common process and a very common thing you'll give a new hire a do as the first task.
• 6:41
  SPEAKER_01: You say, okay, here's a bug, go fix it.
• 6:43
  SPEAKER_01: It's a simple bug, but that'll get you through the process of understanding how we submit code for review, understanding how you push the code into production, understanding how we deal our ticketing system, and so many other things.
• 6:55
  SPEAKER_01: So document that entire process.
• 6:58
  SPEAKER_01: That means that your team members aren't being asked over and over by a new hire, hey, how do I do this now?
• 7:04
  SPEAKER_01: How do I find my tickets?
• 7:06
  SPEAKER_01: How do I mark the ticket as done?
• 7:08
  SPEAKER_01: When do I mark it as done?
• 7:09
  SPEAKER_01: Who reviews this?
• 7:11
  SPEAKER_01: All this stuff can be in documentation.
• 7:14
  SPEAKER_01: That this is not that you don't want people to talk to the new hire, the new hire to talk to people, but you want to give them as much autonomy as quickly as possible so they can feel like they're making a contribution and they can get up to speed very, very quickly.
• 7:30
  SPEAKER_01: With this, number four, document every step to add a feature and deploy.
• 7:37
  SPEAKER_01: Because this may be a bit different.
• 7:39
  SPEAKER_01: So features are different bugs because of the fact that you're adding something new.
• 7:43
  SPEAKER_01: And how do you add something new?
• 7:45
  SPEAKER_01: How do you figure out what to add and where the libraries are for the different things we have already done?
• 7:52
  SPEAKER_01: And how do you make sure that we're not, you know, repeating ourselves in a way we shouldn't, and so many other things.
• 7:58
  SPEAKER_01: Document that step by step with pictures.
• 8:02
  SPEAKER_01: Again, this is the next big step for a new employee where they're gonna add something new.
• 8:09
  SPEAKER_01: And so you want to be able to walk them through and give them as much confidence as possible in the process so they can just focus on the code.
• 8:19
  SPEAKER_01: All right, that's number four.
• 8:20
  SPEAKER_01: Number five, give them time to absorb everything.
• 8:24
  SPEAKER_01: You do not want to just have a fire hose.
• 8:27
  SPEAKER_01: Give them time to absorb things, give them space to kind of understand what's going on.
• 8:33
  SPEAKER_01: And this is where that documentation helps too, because you can say, hey, you know what?
• 8:37
  SPEAKER_01: Once your computer is installed and set up and all the rest, and once you kind of poked around a little bit, here's a bug.
• 8:44
  SPEAKER_01: Here's the documentation for how to fix that bug.
• 8:47
  SPEAKER_01: Take your time, get to it, and walk through the process and then come back to us when you're done.
• 8:53
  SPEAKER_01: Not a rush.
• 8:54
  SPEAKER_01: That gives them the opportunity to kind of calm down, let things filter into their brain, let them come up with questions they might have, make sure to give them time to absorb everything.
• 9:05
  SPEAKER_01: You don't want to just overwhelm a person.
• 9:09
  SPEAKER_01: You want to allow them to absorb what they've they've been presented with so they actually learn things.
• 9:16
  SPEAKER_01: Because if it's important enough for you to tell them, it should be important enough for you to give them time to actually remember it.
• 9:24
  SPEAKER_01: Number six, pair them with an experienced developer for their first task.
• 9:29
  SPEAKER_01: Now, this may be after the bug, this may be after that first bug fix or two, since they had that paperwork, that documentation.
• 9:37
  SPEAKER_01: But at some point in the near future, pair them with an experienced developer for their first task and let them drive and say, okay, let's walk through this thing that we're gonna do.
• 9:48
  SPEAKER_01: And just watch them do it, talk them with them on the process, and make sure they are confident and comfortable doing the process.
• 9:58
  SPEAKER_01: And this is not, make sure it's not a a person just telling them what to do step by step.
• 10:04
  SPEAKER_01: Make sure that you let them drive so that they can understand what they're doing and and kind of make false starts and make, you know, and then walk them through it, go, oh, nope.
• 10:16
  SPEAKER_01: Here's where you find that information.
• 10:17
  SPEAKER_01: Here's how it, you know, and that will reveal some things they may have missed.
• 10:21
  SPEAKER_01: You can help fill in those gaps with them.
• 10:24
  SPEAKER_01: And this kind of feels comes to next number seven, which is encourage them to say, I don't know.
• 10:34
  SPEAKER_01: That phrase is so important for people to be able to say.
• 10:39
  SPEAKER_01: So tell them you need to be able to say, I don't know.
• 10:43
  SPEAKER_01: And say, you know what, you're not gonna know most of the stuff, and that's okay.
• 10:48
  SPEAKER_01: But we want to know what you don't know because we can't fill in those gaps if we don't know you don't know.
• 10:54
  SPEAKER_01: So, and this also can be something where you lead by example, where they ask you a question and you say, I don't know.
• 11:01
  SPEAKER_01: Let's go find that.
• 11:03
  SPEAKER_01: And so make sure they know it's a okay phrase phrase to say, and in fact, it's an encouraged phrase to say.
• 11:11
  SPEAKER_01: And then make sure they know who to ask for help.
• 11:15
  SPEAKER_01: This is where knowing who's in charge of different things and that documentation earlier, where you say, you know, Bob's in charge of the SQL Server, and you know, Mary's in charge of the ticketing system, and and so they know who to go to when they have a problem with one of those things.
• 11:31
  SPEAKER_01: So encourage them to say, I don't know.
• 11:34
  SPEAKER_01: And then let them know who to go to for help.
• 11:37
  SPEAKER_01: Number eight, have written expectations of how they'll be evaluated.
• 11:43
  SPEAKER_01: This comes on a management shoulders, uh, especially, not just the team, but let them know what you're looking for.
• 11:50
  SPEAKER_01: Some organizations say, you know what, we're gonna evaluate you based upon how many tickets you complete.
• 11:55
  SPEAKER_01: Okay, they should know that up front.
• 11:57
  SPEAKER_01: It should not be a guessing game.
• 12:00
  SPEAKER_01: If you say, we're gonna do lines of code, these are horrible ways of evaluating developers.
• 12:06
  SPEAKER_01: But let them know what your way is of evaluating them because they shouldn't have to guess, am I doing okay?
• 12:14
  SPEAKER_01: They should be able to be the first line of evaluation on themselves on how to be evaluated.
• 12:20
  SPEAKER_01: But they can only do that if they're evaluating the same way their boss will be.
• 12:25
  SPEAKER_01: So have it written down.
• 12:27
  SPEAKER_01: Here's how we evaluate you.
• 12:29
  SPEAKER_01: This also encourages management to actually know because some places just don't know.
• 12:35
  SPEAKER_01: They're just kind of guessing at how they're evaluating.
• 12:39
  SPEAKER_01: So I feel like you're doing a good job.
• 12:41
  SPEAKER_01: That's not a great evaluation, right?
• 12:43
  SPEAKER_01: So you need to have a way to say, this is what we're expecting from you.
• 12:48
  SPEAKER_01: And then this is how you can evaluate yourself to know if you're meeting our expectations before we do.
• 12:55
  SPEAKER_01: Number nine, ask them to document anywhere they had issues in the onboarding process, and then fix those issues.
• 13:05
  SPEAKER_01: So this helps you make the onboarding process better.
• 13:08
  SPEAKER_01: And it also reveals to you any things where you kind of skip over things, where you, you know, just kind of hand wave past certain areas because you've done it for so long and you miss.
• 13:20
  SPEAKER_01: Oh, yeah, we do it that way.
• 13:22
  SPEAKER_01: And when you figure out those gaps, you might also figure out, hey, we shouldn't be doing it that way.
• 13:30
  SPEAKER_01: Right?
• 13:30
  SPEAKER_01: And so you figure out, hey, you know what?
• 13:33
  SPEAKER_01: We should probably think about what we're doing.
• 13:35
  SPEAKER_01: Sometimes you get so in the groove of doing something that you don't think about it consciously.
• 13:42
  SPEAKER_01: But when a new hire comes in, they kind of reveal these things.
• 13:45
  SPEAKER_01: And if you have them documenting any place where they had an issue or they're they're missing documentation or whether where they're confused on something, when they document those things, then you figure out, oh, we're we're missing this.
• 13:59
  SPEAKER_01: We have this gap that we didn't see.
• 14:02
  SPEAKER_01: It's a great opportunity for the organization.
• 14:05
  SPEAKER_01: Number 10, and I think this is really important, not just for the new hire, but for the team in general.
• 14:12
  SPEAKER_01: Number 10 is schedule a celebration for two to three weeks after the new hire starts.
• 14:21
  SPEAKER_01: Not right away, not the same day in a celebration.
• 14:24
  SPEAKER_01: It could be a lunch.
• 14:26
  SPEAKER_01: It I personally I like to have a let's take the team out for lunch and kind of celebrate.
• 14:31
  SPEAKER_01: But if your company's not big on that or they they're not gonna give it time to do that, well, bring in donuts or you know, have some kind of celebration at work with you know muffins or whatever.
• 14:44
  SPEAKER_01: But take the time to celebrate when that new person has gotten past the, oh, I'm still dealing with HR.
• 14:52
  SPEAKER_01: Like, because you want to get to the point where they are in the job, they have done a few things so that when you hang out and you're talking to them and you're saying, hey, how's your onboarding going?
• 15:06
  SPEAKER_01: It's not just, oh, I've got my insurance set up now, great.
• 15:09
  SPEAKER_01: Like, that's that's not what you want to have the conversations about.
• 15:12
  SPEAKER_01: You want to have the conversations about, hey, I got my first ticket out.
• 15:15
  SPEAKER_01: Hey, I'm I made my first mistake, right?
• 15:18
  SPEAKER_01: Like, have those conversations because it's more realistic of what a developer goes through and it's a better bonding experience.
• 15:28
  SPEAKER_01: Because this is important, that new hire, you need to work on bonding them with the rest of the team.
• 15:36
  SPEAKER_01: Because if they don't bond well, you're gonna have a hard time as a team.
• 15:42
  SPEAKER_01: Whereas if you can get them to see each other and you know, have a casual environment where they can talk and they can talk about, hey, what's your you know, your your hobbies or whatever, or talk about the you know, the first things that you that you learn on the job, and then you can talk about how, yeah, my first week, I deleted the SQL database.
• 16:02
  SPEAKER_01: And have those funny conversations that starts to build camaraderie and it starts to build a bit of trust between team members.
• 16:10
  SPEAKER_01: And you be careful because you don't want to put the person on a spot.
• 16:14
  SPEAKER_01: Don't put them in the front of the room and make them give a prepared speech that's gonna terrify some people.
• 16:19
  SPEAKER_01: That's not it.
• 16:21
  SPEAKER_01: But you know, a celebration where you're having muffins or going out to lunch and you know, eating pizza, those things can really change the team dynamic.
• 16:30
  SPEAKER_01: So preparing to onboard a new developer, it's a great opportunity for your team to formalize your process and to get your entire team on the same page.
• 16:42
  SPEAKER_01: And then when the developer does join, it's a great opportunity to identify the gaps in your process and fix them.
• 16:48
  SPEAKER_01: It's also a great opportunity to further build team cohesiveness and morale.
• 16:54
  SPEAKER_01: Don't let the opportunity pass you by.
• 16:56
  SPEAKER_01: All right, thanks for watching.
• 16:58
  SPEAKER_01: And as always, I am Tim Corey.
• 17:01
  SPEAKER_00: Thank you for joining us for this episode of Dev Questions.
• 17:04
  SPEAKER_00: When you're ready to learn to think and code like a professional developer, head over to IamtimCorey.com and enroll in a course.