How to Find Great Developers
Now that tech companies are laying off large numbers of engineers, this is the time for growing companies to find new talent. At E-accent, we have always been able to work with great developers. This is how we found them.
The job advertisement
Our job advertisement had the usual sections:
- the business that our company is in,
- what we value,
- the job position and requirements,
- what we were looking for in a candidate.
Being down to earth, we left out the buzzwords, so we did not look for “ninjas” to build the “next generation” of “AI-based” software X, let alone “on the blockchain”.
Instead, we were very concrete and explicit in what we did and what we were looking for.
We would ask candidates to submit a cover letter and a resume.
Where we advertised
We would advertise on job boards, usually:
We did not work with recruiters, but we could have.
What I would do differently
One thing that we did not do was advertise salaries, because we were hiring internationally, and gross wages, take-home pay and benefits vary wildly across countries.
Next time I would do this differently though, with example calculations for different countries, so that people would at least have an idea of what to expect.
Phase 1: Selection of cover letters and resume
During the first selection, we would look for well-written cover letters that showed genuine interest in the position.
This would filter out at least 95% of candidates, as the cover letter would often be missing, or be very generic, so that it was clear that no effort had been made.
We also paid attention to writing skills, as these tend to be a good predictor of programming skills.
In resumes, we particularly looked for relationships between technology and impact.
Other candidates would say something like “Rewrote an internal search engine in C++ to allow a ten-fold performance increase to index a high volume of corporate PDF and Word documents”, which gave us a better idea.
We did not care too much about college education, as this appeared to be a poor predictor of performance. We’ve worked with highly skilled programmers who had a law or English degree.
For the same reason, we also did not care about years of experience (beyond a minimum of three).
Phase 2: Interviews
All candidates who went through the first selection successfully were interviewed.
We would do the interview through audio or video, whatever the candidate was more comfortable with.
Sometimes me and a colleague-engineer would do the interviews together, sometimes we would do them separately.
The goals of the interview were:
- to get to know each other personally,
- and to verify if our values, interests and ways of working were aligned.
During my favourite part of the interview, we would discuss real-world projects in more (technical) detail, sometimes even taking a deep dive into the source code via screenshare.
This was where people’s passions would come to the surface. If the candidate and my colleague would get completely fired up and the interview went way past the scheduled time, it was a good sign.
Phase 3: Technical Assignments
When both sides were happy about the interview, we would give the candidate a small technical assignment based on a real-world case.
We never did whiteboard or live assignments. We wanted people to be in their comfort zones.
The results were invariably quite informative.
Some candidates would come up with a really bare-bones Rails app with two controllers and no tests.
Other candidates would come up with a fully-fledged application with a highly polished user interface and a fully executable specification.
Phase 4: Reference checks
We asked candidates to provide us with two references of former employers or clients.
This reduced our risk of hiring someone who had had to leave a previous job because of misconduct.
Phase 5: Background checks
We ran background checks when we could, but it wasn’t always feasible.
We recruited worldwide and we wouldn’t know if we could trust a background check from some of the countries in which we were hiring.
We always consulted with our clients before adding a candidate to the team that was working on their software.
Many companies that I know don’t run background checks, but you need to make your own risk assessment. If you work with high-value source code or data, or if you want to apply for ISO-27001 certification, you shouldn’t (and probably even can’t) skip these checks.
Phase 6: 2-month trial
At this stage, we would offer the candidate a 2-month contract, so that we could get some experience working together.
During the trial period, candidates would work (and have access to) one project only, with permission from the client.
One of our team would be the candidate’s “sponsor”. This “master-apprentice” model of learning the ropes was extremely effective in getting candidates up to speed.
We’ve been extremely fortunate in finding and working with great developers.
If you’re looking into hiring developers, perhaps some of the methods described above can help you become successful as well.