The Case for Junior Engineers

I've had the privilege of working with some of the most talented minds in the industry across multiple start-ups, a hedge fund, multiple sales companies, a healthcare company, and a brief stint in consulting as both a junior and senior engineer. I've also experienced firsthand the joy and expedience that result from teaching and being taught, especially about the programming languages that I adore. I've always valued being in leadership positions when I've been confident in my abilities, whether that's for a hackathon, a kickball team, or a software product. And there's nothing I love more than to learn.

However, alongside these professional highs, I've grown increasingly frustrated with the reluctance of the tech industry to hire and train junior developers. Leadership should take notice. We need to invest in young software professionals.

"We Only Hire Senior Engineers."

One disheartening recent trend is the reluctance to hire junior developers at all. "We only hire Senior Engineers." It's a strange motto. When I see companies only offering senior engineering roles, I become suspicious. Will I end up doing tasks that juniors could handle to start my tenure in this role? Will I eventually get to tackle complex tasks? Will I be doing everything solo? Will I answer to other Seniors, instead of a VP, or a Product Manager?

Unfortunately, the answers to these questions is often 'yes'.

Companies' focus seems to be on securing experienced engineers who can immediately contribute at a high level. But what is a high level? Is it being able to solve complex tasks? Or is it just the ability to solve all tasks that arise? I believe it's the latter. And that's a cut corner — instead of a solution. We want monkey wrenches, instead of allowing a workforce to become more efficient - to specialize. We don't want a fork or a spoon, we want a spork. Even if we're eating steak.

The fact is that companies indeed have complex tasks that require solving. And they require specialists to do that. However, that doesn't eliminate the mundane fundamental tasks that are not complicated but still demand the same amount of developer time. Just like the spork analogy, engineers have different specialties, different strengths. So how do we approach this?

Artificial Intelligence?

Sorry, OpenAI, but that's not my answer.

Reading up on LinkedIn articles lately, I can say for certain that this is an unpopular answer. Artificial Intelligence pops up all over the place. And don't get me wrong — I love it. If you're an engineer and you're not using AI, you're falling behind. But that's only true if you know how to use it. Which requires training. Expertise. People who can use AI are specialized, they're inherently Seniors that can understand what's provided by the AI. Despite that, it seems like more and more are forced to use artificial intelligence to try and solve problems that could be solved without its help. So no, sorry. It's not my answer. While AI is a powerful tool, it can't solve this. The main reason? AI doesn't reduce complexity.

The code provided by many AI solutions I've utilized requires a higher level of scrutiny which doesn't allow me to understand in a quick manner. It requires time — the most precious resource in all of project management. You see, AI is trained on all code. This includes vastly technical solutions a senior could write as well as the fundamental problems a junior could solve. This means that sometimes, even the AI can over-engineer the solution — exacerbating the engineering bottleneck when the senior has to undo the extra work. There have been times where I've asked AI for a solution and what's been provided takes longer to read and understand than if I had referred to official documentation (like my forebears often demanded) and written it myself.

So again, the burden falls upon the Senior. The bottleneck remains. It almost gets worse.

We can't rely purely on staffing Senior Engineers. It doesn't scale. And using AI to try and fill that productivity gap only makes us rely on Seniors in a roundabout way. So what's the solution? Drumroll, please. I think you know what's coming.

Junior Developers are the Missing Piece

These short-sighted approaches overlook the immense potential of junior talent. Fresh College grads bring fresh perspectives, enthusiasm, a willingness to learn, and much-needed chaos to a workplace. They adapt to coding styles quickly, challenge dated practices, and — unlike AI — they won't be reaching into understanding beyond the scope of current seniors to create something too complex to unwind. As an added bonus, when juniors ramp up, they can often surprise with their productivity. I sometimes think that coding as a junior was some of the most productive engineering of my life. However, I didn't have to do the rewrite. So jury's still out.

Unfortunately, these qualities are often undervalued in favor of immediate proficiency. But even when we examine a new-hire Senior Engineer's immediate proficiency, we can discover that the impact isn't immediate or proficient. Senior engineers require ramping up, too, especially if you're relying on them for complicated technical requirements. They require loads of access requests. You still have to solve "works on my machine" on their new laptop with a new M4 chip. And, if you're only staffing Senior Engineers, you're using one to train one on subject matter. A double bottleneck. Both Senior Engineers are focused on the same task: help me out, man!

To put it succinctly; only hiring seniors wastes talent and time and money.

The Training Gap

The lack of investment in training programs is equally concerning. Companies often expect new hires to be fully-formed experts, ignoring the necessity of continuous learning in our fast-evolving field. Good training programs can bridge the gap between junior and senior levels, making tiers. This fosters a culture of progress. Of hierarchy. There's a reason that we love tracking milestones, that we are continuously attracted to clear hierarchies; the sense of progress and organization is fulfilling. Without such programs, we risk stagnation and a workforce that isn't evolving to meet new challenges. And we fail to reward those that work hard to learn things that are difficult and increasingly important. The program itself creates massive incentives to juniors and seniors and everyone else.

I've seen this kind of program work. In multiple places, in fact.

For instance, at Softmart: I was immediately met with an orientation and an internal education program to help me understand that I was working at an IT resale firm. Those words in that order did not make sense to me — straight out of college — until I took that course. I would never have understood job needs without it.

Conversely, when I moved to a position at a hedge fund: it was interpersonal conversations with quants and analysts and colleagues that taught me what we were doing. Tons and tons of maths, equities positions, futures contracts — Arbitrage! — words I had to look up after each discussion. Unlike the training program, however, I was directly confronted the work that had to be done for me to be productive — on my own. This price was paid for by my coworkers. They were forced to train, even if we didn't have a program.

Either way, the cost of training and education is there. No matter what.

Senior Engineers are the Bottleneck

Current hiring practices overburden senior developers with a wide range of responsibilities from fundamental tasks suitable for juniors to complex architectural decisions that will impact the whole company. This imbalance leads to burnout and hinders strategic thinking in the moments that actually require it.

Over my career as a senior, I've been tasked with everything from a Hello World in a new language to developing automated orchestration of hundreds of containers for a data pipeline. This variety not only led to mental burnout but also meant that senior engineers spent less time on the innovation that could drive the company forward. And, sometimes, they apply strategic thinking where it's unnecessary. That Hello World I mentioned? It was brilliant. But it was over-engineered. Time was wasted because I held the work to a higher standard that wasn't required.

On top of the dynamics of work complexity, there's also a matter of crunch time. When senior developers are overstretched, the quality of work suffers in every possible dimension. Essential yet less glamorous tasks are often overlooked, leading to technical debt that hinders progress and innovation.

On more than one occasion I've thought, I don't want to do that, when I know it's a mundane refactor after closing my hundredth mundane refactor of the month. I know I'm a particularly picky engineer; I like to be stimulated in my work environment and engaged on the project. But when I'm handed a thousand rudimentary problems for an entire week, work is so much harder. However, that wasn't the case when I didn't already have that experience. I didn't get burned out by something that I haven't done. Fundamental work was stimulating and empowering as a junior engineer.

It's important that we cater to all ability levels when solving software. And by utilizing different levels of expertise, we're able to create stimulating, productive work environments.

One of which is:

Hackathons: Scaling Problem-Solving with Juniors

My favorite. One of the best things about working at BetterCloud was my interactions with Hackathons. It was fun as a junior dev to lead a team for projects with teammates across the organization with varying expertise to get a prototype together.

Organizing hackathons engages junior developers in problem-solving and can be an excellent way to innovate and motivate — without disrupting business operations. By assigning tasks to juniors and framing the process as a competitive yet collaborative hackathon, companies create a dynamic environment where fresh ideas and enthusiasm thrive. This method allows juniors to tackle non-critical work effectively, offering cost-efficient solutions and fostering a culture of growth and learning. Juniors bring high energy and a willingness to learn, which can lead to unexpected and effective solutions that might not emerge from traditional approaches.

In contrast, relying on senior engineers for every problem can bring your entire business to a standstill. Senior engineers are best reserved for complex decisions and high-impact projects, ensuring their expertise is utilized optimally. When you block all of them, you can't prioritize property.

By leveraging the potential of junior developers through hackathons, companies can solve routine issues efficiently while allowing seniors to focus on critical initiatives, freeing them up so that everything isn't a blocker. This balanced approach not only maintains business continuity but also builds a stronger, more versatile team for the future.

The Path Forward

The tech industry needs to shift its hiring and training paradigms. Here are a few steps to make a significant difference:

• Hire Junior Developers: Trust in the newest generation of workers to contribute enthusiastically as junior developers.
• Invest in Training Programs: Develop comprehensive initiatives that support juniors' growth, leading to a more skilled and versatile workforce.
• Balance Team Composition: Form teams with a mix of junior and senior developers. This allows for better task delegation and mentorship.
• Foster a Culture of Growth: Encourage continuous learning and clear career progression. Recognize and reward junior developers' growth to motivate and retain them. Turn your Juniors into Seniors.

By addressing these issues, we can create a dynamic, efficient, and satisfying work environment. Junior developers have vast potential, and with the right support, they can become the senior engineers leading our industry into the future. It's time to invest in that potential.

With the advanced technical literacy of many younger generations now entering the workforce, they may not even need computer science or technical degrees.

If you believe in the value of training and nurturing junior developers to become the backbone of your engineering team, I'd love to connect. I'm a seasoned polyglot engineer with extensive experience across the technical stack, from front-end to back-end, on-premises, and cloud. I'd love to hear about your experiences as a senior engineer and as a junior. And if you're looking for someone to guide your team there, I'm your man.

Thank you for reading.