Why Hiring Juniors and Training them is not enough for fast-growth companies
"Education is the solution to inequality. It's so obvious." I heard that proposed solution many times since a very young age. It's a commonplace piece of knowledge. Yet, 20+ years later, inequality is still not solved and doesn't show any signs that it will be any time soon. I wonder if all the people working on governments and education are so much dumber than the average person who knows that "Education is the solution to inequality." If you dig a little deeper into the problem, you will see that it is way more complex. But we don't want to dig deeper into the problem. That would require effort and creating solutions that require more robust diagnosis and elaborate implementation. That's way too much work, and it's too uncomfortable. It's easier to think that people on the other side are dumb, we're smart, and to rely on the commonplace.
One other piece of conventional knowledge that falls into that category is the now-famous "To solve the Hiring gap, just hire Juniors and train them. It's so obvious! Are companies dumb or sumthing?" Granted, inequality is an infinitely more complex problem to solve than "The Hiring Gap" I'm not saying otherwise. But look into the problem just a little further, and that solution in a vacuum doesn't hold up. Gergely has broken this problem down very well, so we won't focus on that here. Instead, we will focus on how healthy teams scale and how people build software in those teams to show you why hiring juniors alone won't solve your problem. But first, let's see why people recommend this so much.
Why Hiring Juniors Seem so Obvious
It pays to work backward on why this appears so often as a recommendation. From the outside, people don't know how companies are structured. They don't know how many people on each level there are. So the few that do research go by open positions, or worse, by their own experiences.
Companies open several junior positions when they're planning to expand. One anecdotal example of this is that I'm growing my org, and the number of junior positions is over 3x the number of senior ones. This distribution is the norm, not an exception. However, these positions fill out way more quickly than any other ones. The supply is just too big and gets bigger every day. More people are realizing that tech offers a satisfying and high-paying career. Bootcamps are becoming better and faster, giving people the base they need to join as a junior. So if we do open up several positions, they won't stay open for long.
People are frustrated by this, and rightly so. They're promised a fast-growth, high-paying career by courses and friends who are usually well-intentioned and speak from experience, but they can't find those positions. They can't get selected because a massive number of people are also applying for the same positions.
Another factor contributing to why people believe that companies need more juniors is that the ladder becomes increasingly challenging for each level. So, in general, it takes considerably longer for a Software Engineer to become a Senior Software Engineer than a Junior to become a Software Engineer. This impacts the company's structure and makes it so that even if you did hire more Juniors, they would soon become Software Engineers, but it will still take time before they're at a Senior level -> You end up needing to hire Seniors if you want to grow.
It is undeniable that to grow sustainably, companies need to promote and develop people from within their current teams. But even if you're great at doing this, people need time to grow, and they need good references to do so.
Well-Rounded Teams and Why they Matter
Good managers understand that team structure has a high impact on how fast people grow and how effective the team can be. Having a well-rounded team is critical for good results and retention, so we need to constantly gauge the level of the people working on our teams and match that with opportunities that enable them to have a more significant impact, learn, and grow. This is true due to how team members can share responsibilities and tasks. Tasks that need to be done but don't develop a senior can be carried out by people to whom those tasks are a challenge. Having Seniors in the team that can guide them on achieving better results on those tasks enables the non-senior engineers to have a safer and faster learning experience and the seniors to focus on work that is a challenge for them. So everyone wins when we can build a well-rounded team. To summarize some of the benefits:
- Seniors <-> Junior mentorship: Seniors get to use their experience and knowledge to ramp other people up and generate more value for the company. Juniors get to grow faster due to the guidance of the Seniors.
- Seniors get to focus on Complex Issues: The career progression for a Senior engineer is increasing the scope of their contributions beyond the team's boundaries and becoming more strategic. They won't have time to identify those opportunities and carry them out if they have to dedicate too much of their time to delivering tasks that aren't professional challenges on their level. Having Juniors and non-seniors in the team ensures they have that time and that those tasks are being accomplished by people they are a challenge to.
- Juniors have a safe environment to learn: By having guidance and other more experienced people in their teams, Juniors get a healthier flow of responsibilities and take on more ambitious projects knowing that they will have others they can rely on for direction and support. We can't provide that direction and support if, for each Senior person, we have ten other Juniors. The Senior won't have time to do a good job.
- Non-Seniors can learn to coach having a reference in the team: This is severely underrated, but having a senior person in the team helps the software engineers to learn how to mentor while also having a technical reference.
A well-rounded team has at least 1 Senior. Ideally, that person shouldn't be mentoring more than five other engineers, including those who aren't Junior anymore. The distribution of those five engineers can vary depending on the team's challenges and how experienced the Senior and the team's manager coach other engineers.
If we hire too many or too few Juniors, we fail to build this kind of team. We create organizational problems and end up increasing turnover.
A Well-Rounded team
So why is it hard to scale well-rounded teams without hiring Seniors?
Ideally, we would be able to perfectly match the creation of new teams with the career development moment of the people we have inside the company. But a lot needs to happen simultaneously for us to open only junior positions to scale that team.
Let's look at an example to picture this better: Imagine we already have a well-rounded team composed of 3 Junior Software Engineers (SWEs), 2 SWEs, 1 Senior SWE, and 1 Engineering Manager in our org and we want to create a new team, with a different focus that will eventually have the same structure. If we tried to minimize the number of senior positions we would need to open for this, we would need to:
- Move the Senior to either the new Senior SWE position or the new Engineering Manager (EM) position, depending on which career track they want to grow on.
- Promote one of the SWEs to a Senior SWE
- Promote one of the Juniors into SWE role and open up their position
Creating new teams is not easy. Doing it so without hiring needs many factors to align. Open in new tab to see text better
So even if we have people ready for these promotions, this would still leave us with 4 Junior positions open, 2 SWEs, and 1 EM or 1 Senior SWE. We could wait longer until another one of the SWEs is ready to grow into a senior position. But what if we need the team now? The solution people usually provide to this is to build the new team within an existing one and later split it into two. This is great when we can find a team with a similar focus. But what if we can't? Even when we can, a huge squad becomes less effective in discussions, and silos tend to form. Within those silos, we would still need technical references if we want people to grow as fast as possible in their roles. Depending on how we grow that team, we can also make it untenable for the seniors to do anything other than onboard and ramp people up.
So, as expected, scaling an engineering org is not as simple as "Just hiring more Juniors." It would be great if that were such a silver bullet. But, when we're concerned with providing the best experience to those inside the company and creating an environment where they can deliver the most value, we can't rely on that tactic alone. We will need technical references, and these positions will scale with the number of teams we have. We will need autonomous Software Engineers, and while most will come from internal promotions, we will still need to hire some.
Companies should hire juniors and non-senior engineers. They need to have them on way more volume than Senior Software Engineers, for sure. Also, they need to have a large portion of their new Senior positions as internal promotions rather than outside hires. They can't have that if they don't frequently invest in the development and hiring of juniors and non-seniors. These are all true statements. But hiring Juniors is still not enough. Nor is it something that companies don't do.
If companies want to grow fast and healthily, they will need to hire, develop and retain Senior+ engineers in a high volume. Senior positions scale with the number of teams if you want to build software that solves your customers' problems and allows you to maintain your speed of innovation. But, more importantly, Juniors and Non-senior Engineers need technical references to be able to grow faster. You will not retain them in the long run otherwise, and so all the Junior people you trained will end up leaving your company.
So hiring 40 people fresh out of a Bootcamp when you have less than 5 senior engineers is a formula for failure and increasing your company's turnover. They won't grow as fast you expect because they will lack the guidance to do so and the Seniors will suffer trying to parallelize their technical work and mentoring all these people. Instead, think about how to scale your company in a healthy way. For example, stop clustering all your senior engineers in the same team and start spreading them out to act as solid references inside a team. Build well-rounded teams and make managers accountable for coaching people and leveling them up faster.