Few investments can compete with the ROI of building a truly effective team, but finding the right people can be a challenging process.

There’s a lot of competition for the best developer talent, so we need to work a little harder to find and retain great people. If you’re frustrated with the hunt for great developers, chances are it’s because you haven’t built the right environment to attract and encourage them.

If you copy the pack, you’ll probably fail.

Don’t blindly follow what everybody else is doing. Very few companies are getting this right, which means that if you copy the pack, you’ll probably fail.

Why Does it Matter?

You’re already paying the costs of a high-quality team — you’re just paying the costs in different ways:

Inefficient development process

Expensive, avoidable mistakes made by inexperienced developers

Technical debt

Productivity crashes & burnouts

Employee churn

The problem is, all of those expenses have negative ROI. You can invest the same money in the most positive ROI available, instead: your team.

If you fail to invest in people, you’re making the implicit choice to waste money.

The flawed logic goes something like this:

I can hire a mid-level developer for $120k, or a senior developer for $160k ($40k is the average cost difference between junior and senior level developer skills in the US [Indeed.com]). You think you’re saving that $40k, but…

A preponderance of research suggests that there is an order of magnitude difference in performance between developers. To quote Steve McConnell (author, “Code Complete”):

The general finding that “There are order-of-magnitude differences among programmers” has been confirmed by many other studies of professional programmers (Curtis 1981, Mills 1983, DeMarco and Lister 1985, Curtis et al. 1986, Card 1987, Boehm and Papaccio 1988, Valett and McGarry 1989, Boehm et al 2000).

That doesn’t mean that a top-performing developer will write 10x as much code or crank out 10x as many features. What it means is that they’ll deliver 10x as much organizational value.

Once your product reaches scale, a smart individual developer can make process improvements that save your organization tens or hundreds of thousands per month in development costs, or prevent bugs or UI mistakes that could cost your organization millions of dollars per year.

How much value you can channel through your development team largely depends on your organizational creativity and revenues, but as far as I know, the number is unbounded. When Instagram was acquired for $1B, there were only 13 people on the team — meaning that each team member contributed an average of $77M to the company’s valuation.

Acquisitions like that are rare, but extreme outlier value contributions are commonplace in the tech industry. I have personally seen individual developers move the needle in multi-million dollar ways too many times to list. Unconvinced? See “How One Jira Ticket Made My Employer $1MM/Month: 7 Metrics that Actually Matter”.

Savvy, experienced developers frequently see opportunities that less experienced developers miss.

The good news is, better developers don’t have to cost you more money. Better pay is one of several factors that can attract better developers to your team.

What do developers care about?

According to Stackoverflow’s 2017 survey:

This boils down to:

Survival needs (e.g., health)

Freedom of time

Freedom of location

Growth opportunities

Work impact

Survival comes first. Developers want to be paid fairly, but once we get into typical $90k USD+ software developer salaries, other needs become more important.

Your competitors often fail to differentiate themselves in other ways, meaning you have opportunities to set your company apart.

In addition to basic survival and the equipment necessary to do their job, developers want to work where and when they want, and they want their work to make a difference or have some social impact.

Dare to be Different

Average companies offer fair market salaries, vacation days, health benefits, and equipment. Most software developers take all those things for granted.

What are the best ways to set yourself apart? Here are some things most developers want, but few companies provide. This is how to turn a job into a dream job:

Remote work Flexible hours Professional Development/Learning Opportunities Golden handcuff compensation

Remote Work & Flexible Hours

More than half of developers want both remote work and flexible hours, and rate those benefits near the top of their checklists.

Don’t do remote half-way. Adopt a remote-first culture. If one person attends meetings via computer, everybody should do so on a regular basis.

As much as you can, adopt software to facilitate meetings such as scrum and retrospectives. Those tools don’t just benefit the remote workers — they also help you stay organized, and provide a record of action items that you’ll actually look at in the future, unlike the designated note-takers hastily scribbled notebook.

It will take a little time to transition an office team into high-performance remote operations, but it’s well worth it, because remote work leads to:

Better software design

Highly productive working (offices are interruption factories)

Lower salary costs & commuter benefits (see below)

Golden Handcuffs

You don’t have to offer golden handcuffs to compete, but you should be aware that companies like Facebook, Google and Netflix use that strategy to great advantage to attract specialized, rare talent.

How much more? Companies using the golden handcuffs strategy often pay 150%–300% market range — or even lottery-ticket money for select talent with proven skills in hot research areas like machine learning, AR, VR, blockchain or drones. I don’t know the upper limit. Some acquihired developers earn millions per year in stock & salary.

How to Save Money on Salary

The idea is to maximize the value of your investment, not to invest as little as possible.

Lucky for you, as long as you compensate fairly, developers will usually trade quite a bit of cash for a bit more freedom. But don’t take that as an excuse to cheap out. The idea is to maximize the value of your investment, not to invest as little as possible.

To get the most for your money, you need to pay above market, and I don’t mean 110% of market average. Your competition is already doing that. 120%+ will help you attract top-tier senior talent.

The way to save money on salary is to hire in pairs; one senior developer paired with one junior developer. Put them on the same project and practice code review and ad-hoc pair programming.

Salaries vary a lot over time, but as of July, 2017, expect to pay:

Senior: $140k — $230k

$140k — $230k Junior — Mid: $100k — $140k

These numbers probably sound high, but that’s because we’re intentionally beating the market a little bit to attract the better developers who can easily land competing offers.

You may be tempted to adjust those rates down for cost-of-living in your area, but it’s a better idea to stay inside that range and instead save money on office space by hiring remote engineers.

If you hire remote, you’ll save on office space, commuter benefits, food, office supplies, building insurance, and a thousand other little expenses that add up to a lot of money. You’ll also be able to get away with paying towards the bottom-end of those ranges if you hire remote, because employees are willing to trade a bit of cash for a bit of freedom, and they’ll be able to take advantage of cost-of-living arbitrage to have a higher standard of living in a lower cost location.

Save money on office space by hiring remote engineers.

If you’re in San Francisco, New York City, or Los Angeles hiring employees that need to commute to your office, expect to pay closer to the top of those ranges for the best talent, e.g., $180k+ for a top-tier senior developer. $120k+ for a top-tier junior developer.

Imagine you’re hiring a team of 6. We’ll assume that you’ve chosen to build a remote team so you can get away with paying near the low-end of these ranges. Imagine you hire an all-senior team:

6 Senior Developers @ $150k

@ $150k Total: $900k ($75k/mo)

Now let’s split hiring between junior and senior:

3 Senior Developers @ $150k

@ $150k 3 Junior Developers @ $110k

@ $110k Total: $780k ($65k/mo)

By pairing juniors and seniors, you’ll save enough money to hire another employee or two — and if you’re hiring well trained, top-tier junior developers, they’ll enter the team with mid-level skills and within a few months, begin contributing at or near the level of your best senior developers.

WARNING: Do not attempt to save money by hiring all junior developers.

You can honestly pay a junior developer quite a bit less than a senior developer, because you must pair them with a senior developer to ensure that they’re effective. Do not attempt to save money by hiring all junior developers. It will cost you a lot more than hiring the same number of seniors in disasters, refactors, and other hidden expenses.

Interviewing

Most companies get interviewing wrong. I would never hire a developer without watching them code live with my own eyes. Generally, that means that interviewers should pair with them on challenges. Pre-select a few challenges that are representative of the type of work you really do on your application on a regular basis and let your interviewers choose from them.

Do this on real computers, not whiteboards. Preferably, remotely, before spending any money or investing serious time with the candidate.

Never ask a candidate to code on a whiteboard. Candidates will think you don’t know how to interview developers, and your company is stuck in the dark ages.

Never ask a candidate random CS algorithm questions. Candidates will think you just graduated from a CS program and have no idea what challenges await in the real world.

Knowing the gist of common data structures and algorithms has tremendous value. Memorizing them all well enough to crank them out on a whiteboard doesn’t. That’s what Google is for. Most of the candidates I’ve seen do well in CS interviews have been fresh college grads with no real world experience.

Max Howell wrote Homebrew, which is used by a whole lot of Google employees (and just about every other developer with a Mac), but Google turned him away because he couldn’t invert a binary tree on a whiteboard.

Oops.

What to look for in a senior developer

Generally, you want senior developers with a broad range of experience, paired with a deep understanding of application architecture and technology stacks similar to yours.

Proven problem solving skills with multiple real-world production apps at scale

Deep specialization in the problem domain or technology stack (ideally both)

Excellent mentorship/teaching skills (remember: you’re going to pair them with junior developers for the purpose of training the juniors)

Excellent learning skills (ability to research & learn about new technologies & solutions to problems)

Passion for software building & excitement to tackle the specific problems they’ll encounter on your team

Bonus: A public record of mentorship, writing, public speaking, or OSS contribution

Experience:

3+ years, minimum.

6+ years, ideal.

What to look for in a junior developer

Hiring junior developers is all about understanding their learning trajectory. You’re going to stump them with some technical and software architecture questions. Look for somebody who’s not afraid to say, “I don’t know, but I’d love to learn it!”

Here’s what to look for:

How much do they know about your tech stack?

Do they know the right things, or just the stuff that’s obviously available to google in API docs?

Most importantly: How long have they been seriously learning? Is their learning velocity impressive? Is their passion for it obvious?

Great junior developers will want to learn about the team, and they’ll be on the lookout for opportunities to pair up with a great mentor. This is a great time to mention to them that they’ll be paired with a senior developer who’ll give them constant support and feedback.

Junior developers are looking for a fast-track to learning and career development. Give it to them, and they’ll jump at it.

Professional Development & Learning

In the United States, we tend to neglect all forms of mentorship, training, and apprenticeship in the workplace. In other countries, apprenticeships are time-honored traditions with a proven track record dating back centuries, and people apply it to most skilled trades, including software development.

The US needs to take a lesson from the rest of the world, because when it’s implemented well, mentorship correlates better with higher pay than advanced university degrees, intensive bootcamps, certifications, or online courses.

What is Mentorship?

Mentorship usually takes the form of one-on-one, long-term guidance from a senior level expert. Mentorship relationships ideally span months or years, and may even outlast the employment relationship. Mentorship is not just for junior developers. Senior developers need it, too.

Mark Zuckerberg (Facebook) was mentored by Steve Jobs (Apple). Sergey Brin and Larry Page (founders of Google) were mentored by David Chariton. David Packard and Bill Hewlett (founders of Hewlett-Packard) were mentored by Frederick Emmons Terman.

Ideally, all of your employees (regardless of skill or experience) should have mentors. Pair senior developers in mentorship relationships with mid-level and junior developers. Depending on career goals, senior developers may also wish to enter into a mentee relationship with engineering managers, CTOs, other senior developers, or specialists in a field of interest such as machine learning, AR/VR, etc…

If your team does not have a qualified mentor for your senior developers, actively look for opportunities to solicit mentorships from people outside the company. Some experts in the field will be willing to enter into mentorship relationships. If you can’t find somebody to do it at no cost, try offering money (paid by the employer). Increasingly, mentorship is becoming a viable career opportunity for highly accomplished talent.

There are platforms to pair mentors with mentees, but when I looked into them, I was severely disappointed. Instead of offering true long-term mentorship, they were mostly pay-per-minute developer help services. The quality of both the mentors and the mentees was abysmal.

So I cofounded a new platform: DevAnywhere.io

It’s a great way to kick start mentorship culture on your development teams, and provide a mentor for the most senior developers on your team — the ones you don’t have any role models senior enough to pair them with.

Paid Training

The best companies offer training budgets to employees. To really stand out, offer a generous budget for training resources such as books, online content, and conferences. For $1k — $5k per year, you can provide a very powerful benefit that top-tier talent loves.

You should also count on investing 30% — 50% of a developer’s salary into mentorship. That may sound like a lot, but it has an extremely high ROI. The amount invested runs on a linear scale, while the ROI of the investment runs on an exponential scale. (See also: “Struggling to Find Great Senior JavaScript Developers? Mentorship is the Answer”)

If you have developers on the team who would serve as a good role-model/mentor for more junior members, the cost will go to the mentor’s salary. You’ll need to take them off of individual-contributor duty for at least a day or two per week and put them on multiplier duty.

For your most senior developers, you’ll need to look outside the organization and find a mentor. Since most qualified mentors will be unable or unwilling to donate their time to your cause — you’ll need to pay them.

Need help finding qualified mentors? Try DevAnywhere.io.

TL;DR

If you want to turn your boring job listing into a developer’s dream to attract better talent, here’s the recipe:

Generous vacation time

Remote work

Great health benefits

Flexible hours

Great equipment

Mentorship

Training budget

Skip the whiteboard/CS quiz (watch them code on a real computer, instead)

Level Up Your Skills with Live 1:1 Mentorship

DevAnywhere is the fastest way to level up to advanced JavaScript skills: