How to write the perfect job spec for junior developer roles
I recently had several conversations with Constructor Labs hiring partners about the best way to hire juniors. Having spent the last few weeks taking the students through the job application process with the help of our in-house talent professional, I thought it would be useful to share my insights on this topic.
Job specs are terrifying
I have been a developer for 15 years and worked on some massively complex projects. Yet, when I look at some of the job ads my graduates look at, my first impression is that I don’t think I am good enough for the job. If that is the effect they can have on a seasoned developer, think about the how someone looking for their first role might perceive them.
Let’s look at a typical spec.
- Some information about how amazing the company is and ridiculously smart people who work there
- Wish list of all possible technologies
- A long list of nice-to-haves
- Something about good interpersonal skills
- An opaque application process, which tells little about the next steps
- No information on salary
What do juniors want?
Before we dive into how the job spec can be improved let’s look at some of the hopes and fears of junior developers. This will help us to structure the job spec in way that will encourage applications and produce the best results.
First let’s acknowledge one important fact. Failure is incredibly painful for some folks. No-one likes rejection and many talented folks will avoid a situation where failure appears to be the most likely outcome. This will stop many applicants from even thinking of applying to you.
Companies typically hire juniors for two reasons. The first, and unfortunately far too common reason, is they view juniors as a source of cheap labour who you can work hard and discard once they have outlived their usefulness. The second is that smarter companies understand juniors will produce their best work at some point in future and strong results will only show after months of great mentorship and support. Constructor Labs train graduates pretty well on how to avoid the former type of company and seek out the latter.
Developers generally find it difficult to gauge their own skills. Those who are most confident in their ability tend to be erroneously so, whereas those who are smarter are much more aware of their limits. The internet is littered with comments about how you are not a “proper” developer until you know technology X and have Y years experience. While such comments are garbage, it can be all too easy for junior developers to let such sentiments creep into their thoughts.
Applicants want to have an idea of what to expect and what a company is really looking for so they can prepare as best as possible. That includes timelines, possible tech tests and interview structure.
While juniors in my experience are quite realistic about salaries, they still want to know how much they can expect to earn and what the career progression could look like. This is particularly crucial for folks who are switching from another industry where progression is based on seniority and only happens every few years. These experiences can create a lasting impression on folks who as a result may not be aware of the opportunity a tech career can provide. Also, we all have bills we need to pay. A clear salary range will let the applicants know they are not going to be left destitute. It may sound ridiculous to those used to tech salaries, but in other industries this is sadly all too common for junior employees.
Your new junior developer job spec
As discussed earlier, a typical job spec will talk about how great the hiring company is followed by a long wish list of skills and desired personal attributes. Junior developers are likely to have a severe case of Imposter Syndrome, especially the smarter ones, and over-selling the company is likely to put them off from applying.
We need to approach the job spec from a completely different perspective. Rather than communicating the strengths of the company, it is much more important to emphasize that junior developer are welcome and how they will be supported.
Good key points to include
- Information about how many juniors you hired hired in past year and why you see value in hiring developers early in their career. This is will send juniors a clear message that they are welcome and not an awkward after-thought.
- Instead of creating a technology wish list, provide information on what the successful candidate can expect to work in the next 3, 6 and 12 months. The idea here is to be forward looking rather than applying pattern matching based on non-existent previous experience.
- Provide information on how you will support the developer’s growth over that period. This can pair programming, a mentorship programme, training scheme etc. A £500 conference budget is however a poor example.
- Include information on review frequency and possible progression path. If you have senior or lead devs who started out as juniors this could provide fantastic evidence of your commitment to successfully supporting staff development.
- Include information on the application process and expected timelines. Respond to applications promptly or let applicants know when they should expect a response. In case of rejection, provide clear feedback on areas you would like to see the candidate improve in.
- Provide a reasonable salary range
If you have a careers section on your website, it could be worthwhile having a few profiles and interviews of junior developers you previously hired. These should be as open and honest as possible. The idea is that these should be relateable and rather than selling the company should provide insights into the journey a junior developer can expect after joining your company.
In all cases try to make the whole application process as friendly as possible. These will create a good impression and may even lead to the unsuccessful candidate recommending your company to others or re-applying later in their career.
One last thought before I leave. Recruitment is a zero sum game. Each developer one company hires means a company elsewhere loses a developer. The only way for tech to grow as an industry is to welcome juniors and support their progress. The smartest companies have already wised up to this and are doing a phenomenal job at nurturing the talent of tomorrow. You should too.