Photo by Valeriy Khan on Unsplash

Junior developers entering the job market in 2019 are running headlong into the harsh reality that it can be very difficult to get hired in this field if you lack practical experience. Any junior developer who has spent time on the job hunt fresh out of a boot-camp or university program has experienced the paradoxical mindset of companies hiring developers. Some will hire juniors, but only if they have 2+ years experience (how do they get it?). Others only have openings for mid to senior level developers, and don’t hire juniors at all on principle. Still others require 4+ years experience with Gatsby.js, along with 2+ years experience with Angular 8 (these companies are frustrating for all of us).

What’s causing companies to shy away from hiring new developers? There are several reasons I see for this trend, and I will spend some time unpacking them in this post. I’ll also give my thoughts on how juniors can improve their prospects during the job hunt.

Supply of junior developers is surging

According to the US Bureau of Labor Statistics, software developer jobs have more than doubled, from 507 thousand available jobs in 2006 to 1.2 million jobs in 2016, and this number is only supposed to go up. In response to this demand, universities, MOOCs, and coding bootcamps have ramped up their offerings for prospective software engineers. Universities in the US graduate nearly 50 thousand students per year, while estimates for bootcamps are between 15 and 30 thousand graduates per year. While it’s hard to doubt that the demand for software developers in general is rising steadily, the ratio of juniors to non-junior developers entering the marketplace is definitely skewed towards those with less experience.

What this usually means for juniors today is that they are competing in a very saturated market, with the few junior jobs available having dozens if not hundreds of competitive applicants. I say “few junior jobs”, but why is that? Shouldn’t there be a relatively even spread between junior and senior openings? Not quite, and here’s why.

Developers are hard to interview

Software developers in general are notoriously hard to interview and vet properly. Even experienced developers with many years of complex projects and value added have a difficult time conveying their merits to potential employers. Many companies have resorted to catch-all ‘code-quiz’ style interview processes, with arbitrary puzzle-solving acting as a gateway to further interview stages. While this at least creates a concrete goal juniors looking for their first job can aim toward (studying these types of problems), it also means that companies are able to be brutally selective, filtering out all but the strongest puzzle-solvers. The irony here is that of course the code-challenge interview style is a poor indicator of how a candidate will perform day-to-day development activities, but that’s a topic for another article.

In addition to the problems with code-challenges, most companies are aware of the pitfalls faced when trying to hire software developers, and so they opt to not even bother interviewing juniors. Instead, they focus their efforts on more experienced candidates, with the hope of securing a more productive employee from the start. However, this just further limits the avenues for juniors to gain experience and become more competent, exacerbating the problem.

Juniors are risky

Finally, juniors are a huge risk to the company that hires them. They must first dedicate resources from more experienced developers in order to properly train the new hires. For an average developer it takes 3–6 months before they’re fully productive, and for juniors this time is extended to 6–12 months. Junior developers are also more likely to introduce bugs to the codebase and to deviate from clean software construction patterns and principles. With the proper testing infrastructure and mentoring opportunities in place, these downsides can be mitigated, but many times companies will have neither, and so low-quality code can make it into a production environment, creating even more work down the road and accumulating technical debt. These things are to be expected with a junior hire, but, much like with the interview process, many companies will just choose to not hire juniors to begin with in order to avoid these issues.

Further complicating matters is the fact that many developers, juniors included, will not stay at one company for an extended period of time. There are several factors that drive this, but many boil down to the fact that developers can often raise their pay by 50% or more, just from joining a new company. If a developer is not extremely happy with their current work situation, that kind of pay increase makes it a no-brainer when deciding to jump ship. Since junior developers have a longer ramp-up cycle for becoming productive and contributing value, companies will again try to partially mitigate this risk by only hiring experienced developers from the start.

What can you do?

As a junior developer, there are several things you can do to give yourself the best possible chance to get hired in the current competitive landscape.

One way is to hone your self-learning techniques to make sure you can stay on top of the changing industry, and stay as attractive as possible to potential employers. This will better enable you to maintain a high-quality portfolio of work and side-projects to give companies a better idea of what your strengths are as a developer. Continuing to work on your skills is extremely important: don’t fall for the trap that after receiving your degree or certificate that you are ‘done’ with learning. In software development, and especially with web technologies, your skills will stagnate without regular training and practice.

You should also focus on the fundamentals to ensure that your skill set stays flexible and marketable for the long-term, and is not greatly affected by the short-term trends in technology. Having a good understanding of the fundamentals will also allow you to pick up new, trendy technology relatively quickly, because you will have an understanding of what the problem being solved is, and an appreciation for tools that solve it well.

Finally, don’t be a junior. The best way to increase your chances of getting a job is to have enough experience and projects under your belt that employers will recognize you as skilled and valuable. This can be tough, especially if you need to be hired soon after finishing your education. One way to accumulate practical experience, even as a junior, is to offer freelance services. Doing this will widen your understanding of the technologies used in the real world, as well as grow your people and communication skills.

Wrapping it up

Junior developers are entering a tougher marketplace than ever before. Skill requirements are increasing, the number of juniors in the marketplace is skyrocketing, and companies are wary of adding a newbie to their ranks. Even so, as a junior there are concrete steps you can take to improve your prospects and gain valuable skills that will serve you for years to come. To all the juniors out there, don’t give up, and good luck!

If you enjoyed this article please consider clapping or sharing it with others. Thanks for reading.