Why You Shouldn't Shy Away From Hiring Junior Tech Talent

Many organizations today fall into the trap of a "senior dev only" approach and avoid hiring junior talent not to compromise on the quality and security of their software solutions. No wonder, as the cost of a mistake is very high in this brave new world; however, while being on a constant watch-out for senior software engineers, many businesses, especially startups, miss out on many opportunities and benefits that rookies can bring to the table. 

As entry-level specialists, junior geeks are expected to require a lot of coaching, supervision, and attention, in general. Many business owners believe that coping with juniors is a waste of time and money and the game isn't worth the candle: you make continuous investments to bring them up to speed and shorten a learning curve, and they leave you for a competitor who offers slightly higher pay and a better office location. 

But it doesn’t necessarily have to be that way. Isaac Lyman, a software developer who runs his personal blog, thinks that "If you don't hire juniors, you don't deserve seniors".

In this article, I'll try to convince you that you're wrong not to hire junior dev talent and will financially justify why it makes sense to bring them on board. But first, let’s define developer seniority levels and what is generally expected of each. 

A software developer is considered to be junior if they have at least 1 to 18 months of experience with real-life technology projects (yes, Bootcamp Graduates, you don't yet qualify as junior unless you get involved in a real-life project).

Albeit being an entry-level position, it does require some coding experience and knowledge of at least one programming language. Juniors are also expected to have a basic understanding of hardware and software technology and be ardent learners and avid go-getters. 

A mid-level developer typically has 2-4 years of experience and is proficient in several areas of software engineering. A mid-level dev is expected to write clean and easily readable and maintainable code, perform code reviews, break tasks down into sub-tasks and be able to mentor and supervise novices. 

Seniors usually have 4-8 years of experience, robust expertise and knowledge of most software development aspects, PM methodologies and tools and, what's even more important, they possess tribal knowledge of this or that particular niche/vertical, have excellent soft skills, and can both work independently as standalone problem solvers and act as team/tech leads. They're capable of self-organization and discipline, can have a copter view of the project, its milestones and technology limitations, can use unconventional ways to overcome challenges, and have a very strong work ethic.

Capable of seeing the project through all of its development phases to launch and completion, a senior software engineer can also mentor less experienced colleagues and turn your junior talent into a well-oiled coding machine.  

While seniors are treated as the software development elite and are in high demand, they are often overconfident and tend to command hefty salaries. They are also picky in terms of the projects they join, and they want to accomplish something meaningful. 

Middle developers also have limitations: they still need mentoring and lack a profound understanding of all development aspects. They also tend to have a fixed mindset and are often incapable of thinking outside the box on their own (without involving a senior colleague). 

The downsides of junior developers, though, are often compensated by tangible advantages. 

So how do you leverage junior software developers as part of your team management strategy? Below are some tips you can act on. 

In a sense, this is a fair trade-off: they need practice and are eager to learn to write better, cleaner code and can help you rid your middle and senior devs of drudgery and refocus them on what’s strategically important. Fixing minor bugs, working on non-significant aspects of backend code, performing concrete, predefined tasks – a hard-working and motivated rookie can handle all of this. 

Warning: if something is critically important and has to be done fast, it's better to assign this task to a mid-level developer, as it usually takes juniors twice as much time to accomplish a particular task as their more experienced peers. 

2) Hire junior developers to save money

While senior-level developers are knowledgeable and competent, their salaries often defy imagination. Given the tech talent shortage, seniors are in high demand across the Globe, which makes them feel like they deserve special treatment. In the United States, an average annual senior developer salary is $102,218, according to Glassdoor. This figure includes base pay only, without taking into account other forms of compensation and will differ depending on the city and state of residence. 

On the other hand, an average junior dev base pay across the US is approximately $62,076 per year (according to Indeed), which makes the difference substantial, if not drastic. These figures surely make you question your priorities when it comes to assigning tasks on your software dev projects. 

Correct assessment of skills often poses a problem. People do tend to associate price with quality, which makes many inexperienced developers position themselves as mid-level. Of course, in some cases, hiring offshore developers would be better justified financially. 

A significant advantage of junior developers is that they're completely white label and all they need to start working on your project is more or less fluent English. If you go to countries like Ukraine or Estonia, you'll be able to find adequate English speaking junior talent that will cost you half of what it'll cost you in North America or within the EU.

For instance, boutique custom software development and staff augmentation providers in Eastern Europe charge only $15-20 per hour for junior talent, i.e., $2,400-3,200 per month. And this fee already includes all taxes and social benefits that are typically paid on top of the base pay in countries like the USA. So, at the end of the day, if you count the total cost per hire a junior dev talent, offshore talent proves to provide better cost arbitrage. 

Once upon a time, one of the world’s leading providers of online money transfer services was looking to extend their FinTech team offshore and increase development bandwidth without increasing the investment substantially. They hired a local custom software dev company in Kyiv (Ukraine) for their backend and web development work, while keeping their mobile dev, front-end, UX/UI design and QA in-house. As the vendor also ran one of Ukraine's leading Coding Bootcamps, it could shorten time to hire developers and provide a right mix of junior and senior dev talent to help the client save costs and ramp up the offshore project kickoff quickly. The team was composed of one senior backend developer who also acted as a tech lead, one mid-level backend developer, two junior Java developers, and a Java course graduate who had the highest rating in class. All junior geeks were sourced through Bootcamp.

The monthly cost of this full-fledged 5-person offshore web dev team totaled $21,000. After the web app was released two months later, the client scaled the team down and only retained inexpensive junior staff and a senior developer to support the solution and upgrade/build new features.

Had the company chosen to extend their core team locally, the cost would have been at least twice as much, but the project would have taken much longer to complete as it's nearly impossible to assemble, onboard and bring the team up to speed within a month or so (in the USA, the average time to hire a specialist in software development is 50+ days).

Supervising and mentoring junior devs indeed consumes time and effort. On the other hand, it gives you the chance to infuse them with your company values and grow your own loyal dev staff. But, how do you ensure that they won’t leave you for competitors once they become experienced enough? The key is to give them a clear outline of their career perspectives and show them how they can grow within your company, both personally and financially — schedule regular assessment of their skills and accomplishments which they can treat as a roadmap for professional development. Fostering in-house talent is sure to enrich your company with qualifications and experience in the long run. 

This is by no means age bias, but younger developers tend to be more energetic and driven to grow professionally, while senior-level staff gets idle and complacent. 

Lack of experience often translates into unconventional thinking and helps see new pathways where middle and senior developers can’t come up with anything original. Surely, you can only take advantage of their zeal and energy if you let juniors have their say and listen to their ideas. The long-term benefit of this approach is that once they feel valued and appreciated, they'll move mountains for you and will be your most devoted brand advocates and project evangelists. 

Another way you can benefit is competitor analysis. Junior developers tend to mingle and attend various networking events, so you can use them to find out what your competitors are up to. 

Continuous learning and self-improvement should be a personal philosophy of every developer regardless of their skill level. Yet, older devs have more to unlearn - technologies and approaches become obsolete and are a subject of frequent change in the age we live. Juniors, on the other hand, are likely to be familiar with the more up-to-date technologies, as they don't have any legacy skills that may impede their professional development.

Companies often make a big mistake by neglecting junior talent, and the consequences can often be detrimental – especially for small businesses. No one wants to meddle with juniors who need supervision. However, a “seniors only” approach can be disastrous. If you justify reluctance to hire juniors by saying you can’t afford to make mistakes, you produce a clear message that “no mistakes are allowed here”. People feel intimidated, and, eventually, they lose drive and creative energy. 

If you entrust seniors with tasks juniors can easily handle, they are likely to lose motivation and leave. These guys are knowledgeable and ambitious, and getting stuck in a boring rut is unlikely to guarantee high job satisfaction levels.

Financial consequences can also be daunting: any software project includes some “glue code”, i.e., executable code that serves solely to "adapt" different parts of the system that would otherwise be incompatible. Glue code does not contribute any functionality towards meeting program requirements, nor does it require the senior-level expertise.

Hiring seniors, with this respect, is, basically, a waste of money. Hiring a well-balanced pool of seniors and juniors in 50/50 proportions can get you more work done than hiring only seniors, and can save you up to 75% of costs. 

So, if you are contemplating hiring junior developers, what should be your demands and expectations? Apart from knowledge of at least one programming language and a good understanding of computer technology, the junior staff you hire should be apt learners and have superb work ethics. Some of the world’s best practices of using junior developers involve offering internships to aspiring software developers to foster loyal talent. In Germany, for example, such internships are a regular practice. 

Using juniors is also highly justified when you aren't bound by tight deadlines and have time for meticulous bug fixing and experiment. Or if you’re building an initial MVP product and plan to include seniors at later stages, when the project would need refinement. 

Hiring junior dev talent is a major indication that your organization uses good management practices and has profound growth potential. Everything comes at a price, though.