The Powerhouse of Junior Devs
Why you should grab a junior developer (preferably on talent.io ;) )
Nearly 19% of developers on the job market in the UK, France, and Germany have between 0–1 years’ work experience — yet the difficulties of being hired as a junior developer are no secret.
The problem is widely felt as more people than ever are entering the industry (StackOverflow’s March survey of 100,000 devs shows the majority have under 5 years’ professional experience). At the same time resistance to entry-level applicants exists alongside massive demand for developers in general.
Here’s what to expect from your junior developers and why, far from being a drawback, hiring junior is a solid strategy and ultimately beneficial.
Back up a second… what is a junior developer? 🤔
To define parameters, I give you (disclaimer) a highly generalised Junior Dev ‘Top Trump’:
As the ball game changes after first employment, this article focuses on entry level devs.
Salaries are not only contingent on seniority but also location and tech stack. Detailed salary reports are widely available so the above is just an overview for context. Junior developers are on average quicker to hire from first contact with a company than their senior counterparts.
Where do they all come from?
There’s no single road to development. People start from many directions and stages in life, and their route impacts opportunity. The term ‘junior developer’ covers a vast range of experience and capabilities.
The Graduate 🎓
University is the go-to point of entry. Work experience backgrounds of graduates naturally vary but the progression is well-established. Graduates in their twenties fit the stereotype demographic of industry juniors, particularly where dominated by a young startup scene.
From the Camp ⛺
Learning Solo 🏃
A high proportion of professional developers are self-taught (with or without the aid of online courses) — the tech sphere has grown in parallel with many of today’s working-age population, who began as amateurs in a fledgling industry. The rate of technological change and development of languages keep all developers on a constant learning streak. The prevalence of self-driven learning means lack of open stigma against self-taught professionals, but getting a first foothold without formal qualification is nonetheless challenging and, at times, a matter of luck.
Developer Arsenal: What’s *really* essential?
“From the candidate side it’s intimidating, lengthy job descriptions that seem impossible to match, code assignments and interviews.” — Jessica
Jessica, a recently trained Junior Developer, talked about seeking an entry level position in the absence of a degree:
“The industry is growing aware that traditional education does not equate to the best candidate... however job ads are slow to reflect this. Many still ask for a CS degree and that can be very off putting. I encourage you still to apply.
Outside the traditional education route you have to be more creative presenting your knowledge. Detailing your own projects and tech stack, with a link to GitHub, is a great way to convey the knowledge you have.”
The value of non-traditional qualifications and soft skills is reiterated by Zenguard CTO Jörn Stampehl (coincidentally ZenMate Tech Blog is written by a junior dev), who focuses on the ability to handle a working environment over pure technical experience:
“If you never worked in a ‘real’ company you don’t know about time pressure, working in bigger and remote teams, shifting requirements, incidents on live systems, etc.
Projects at university are most likely somewhat artificial, with well defined requirements and probably not reaching any real user. Self-taught or freelancing developers tend to miss the experience of team work, team planning and dealing with merge conflicts.
All this is why a developer who hasn’t experienced a working environment for longer than 6 months full-time has a steeper learning curve.”
All juniors are equal, but some are more equal than others…
Old and Wise (yet somehow at a cost?)
Many people enter development following a career in some other field. Yet despite career change being an ever-growing norm, there are obstacles specific to seeking entry positions at a later age.
Prejudice against older entrants in tech is often based on certain assumptions:
- people with a prior career aren’t prepared to return to a starting salary (or work for free — which no-one should be doing)
- they are less adaptive and mentally agile (so less desirable for a tech role)
- sadly, an age bias common in the startup sector dominated by individuals in their twenties and thirties
I was recently directed to Tim Leunig’s TED talk on the source a longer base of experience provides for creativity. Rather than expecting older developers to be stuck in immutable habits, we should realise how much creativity derives from past experience — not to mention the understanding non-development positions in various industries and fresh perspectives retraining developers offer.
Additionally, many young people emerge from University with degrees in part because it’s a societal norm to do so (and there’s nothing wrong with that). When someone actively choses to re-train and re-enter working life later on from scratch, this surely says something about their drive as a professional.
Selling yourself short
There’s no hard-and-fast rule on the point at which someone becomes (or stops being) a junior developer (this article eschews use of the term altogether, even where the application can seem clear). The absence of a solid universal baseline places certain demographic groups and individuals with a tendency to comparatively underrate themselves at a disadvantage. People with the same skill sets can be faster or slower to start calling themselves professional.
Many companies look for mid level developers over juniors. The rationale is not purely in terms of quality or technical level: essential tasks exist at all levels of technical complexity, as does good or poor quality programming. Especially amid small startups with high pressure and low manpower, the concern of many companies lies in the time and personnel investment needed to support and integrate juniors. Occupying more senior team members with mentorship of juniors unable to drive bigger project tasks is perceived as a major drawback.
Why they make no sense
It’s generally true that more resources are needed to bring a junior member up to speed — but the ability to problem solve autonomously isn’t purely based on technical seniority. One anecdotal counter is the case of technically advanced programmers who require significant supervision to keep on track within a project (people can code very well, but if they’re coding the wrong thing that still isn’t useful).
The benefits of integrating junior developers (not only ‘hiring’ them) more than compensate the costs:
1) Here to stay — Retention
Anecdotes aside, the time commitment for junior developers has a high probability to be well-placed. Entry level developers often have greater loyalty and better retention at a company where they have been given their first professional development and well-treated. Pawel Gdula, Chief Architect at OUTFITTERY:
“I have seen junior growing to mid and senior level in the same companies simply because opportunity was created for them. They were staying way beyond average 2 years.”
Retention more than compensates for any resource drain, which would otherwise be spent in more frequent hiring processes to find mid level devs.
2) 💪 Strengthen the team
Alongside retention and encouraging internal progression, symbiotic junior-senior relationships surface repeatedly as a major team benefit to taking onboard and growing junior devs. Dr Nakeema Stefflbauer of FrauenLoop emphasised this in a forum held by talent.io on diversity and inclusion in the tech sphere and it was well-put by Pawel:
“Having juniors in the team can be really good experience for senior devs to enter in the role of teachers. I have seen people enjoying this and great chemistry created in the team.”
A team bound by personal relationships with tutor-student dimensions creates a better work environment and will in probability have all-around higher retention. It’s a question of balance.
The perfect team is always a mix of senior and junior developers. Juniors can come up with crazy ideas and chase them — seniors can moderate these ideas, guide processes and so on. With only seniors your environment can cease to be evolving — only juniors and it can get chaotic.” — Jörn
3) Raise juniors in your image
Junior developers can be grown in a way to suit company processes.
“The investment pays off. Juniors might start off not knowing the processes but after a couple of months, they know. And they will also know the frameworks the company is using and the tools.” — Jörn
The need of companies to bring in tech talent is leading to initiatives for training developers even from the ground up, moulding trainees to fit their specific working methods. SoundCloud’s DeveloperBridge Program and BT in partnership with Code First: Girls provide recent examples.
4) Fresh perspectives
“The disadvantage of juniors lacking experience is also their advantage. Juniors are more open to new things because they still want to learn. They try things that might be tried before but with a new approach. They question things that were done because no one ever asked if this was right.” — Jörn
The most experienced developers learn and work with new and evolving technologies. Seniors have more experience and autonomy adapting, but learning on the job is the default in development and shouldn’t deter hiring companies.
The gist is that investing in your juniors pays off.
Happy to say that talent.io practices what we preach. Via the platform we have access to thousands of developers of all seniorities which we’ve used to select a fantastic dev team, many of whom have started as juniors.
Émilie Phommaphavanh joined talent.io as her first place of work two and a half years ago. Integrating has various aspects but the common theme is investing the time from the start to educate new members to become both autonomous and fully functioning members of the team. Her onboarding demonstrates some possible processes for providing support:
“We complete a series of trainings before taking on tasks from the backlog, ranging from basic Ruby/Rails exercises and documentation (since we also hire developers who are not familiar with the technologies) to presentations of our app’s main components (by the other devs). New members are assigned a ‘mentor’ until they complete the training. We’re also highly encouraged to pair program.”
There’s widespread complaint about the difficulty of finding good tech talent, but at the same time companies overlook developers with solid skills and an even greater potential to learn quickly on the basis of junior experience.
It’s a short term view which — unless hugely pessimistic about your future as a company — doesn’t make so much sense.
To exit on a pleasant word from Pawel:
“Just to add something on top from my own experience. I really like working with junior devs. They bring fresh energy to the teams, they work hard, they have fun learning and they really appreciate that you help and work with them on the problems.”