Struggling to Find Great Senior JavaScript Developers? Mentorship is the Answer
By: Eric Elliott
Tags: Coaching, Technology, Management, Mentorship, JavaScript

Dry Wraps — Vern (CC-BY-NC-2.0)

The more I study the impact of mentorship on the teams we work with, the more I’m blown away by the magnitude of change it produces. The cost of mentorship increases on a linear scale with time, but the impact of mentorship increases on an exponential scale, with compounding productivity returns orders-of-magnitude greater than the time and money invested.

Because of the radically different scales (linear vs exponential), it’s difficult to wrap our brains around how much we’ll be rewarded by investing more in mentorship. Our brains seem hard-wired to think in linear terms, and it’s frustratingly hard to get them to think in terms of exponential scales and compounding rewards.

The linear thinking problem can lead us to make huge mistakes, such as the entire software industry radically under-investing in training. The result is not good.

Often, managers fall into the mistaken belief that if employees aren’t busy writing code, they’re not being effectively utilized. It turns out, that belief simply isn’t supported by the facts.

According to the 2016 Stack Overflow survey of over 56,000 coders, mentorship programs correlate with higher pay than a college degree — reflective of the fact that mentorship is an extremely effective way to learn skills.

According to the 2017 Stack Overflow survey, company-sponsored learning opportunities consistently rank among the top benefits employees look for in job opportunities.

88% of employees feel they could benefit from more training.

Mentorship benefits for mentees

Accelerates learning & growth

Increases confidence

Better access to positive examples (how to do things the way experts do them)

Decreases fear of contribution/collaboration/idea sharing

Increases communication skills

Mentees feel more invested-in and valued

Improves upward mobility — a Sun Microsystems study found that mentees are 5 times more likely to be promoted

Mentees become mentors and pass all these benefits on

Mentorship benefits for employers

Great perk for recruiting

Increases developer productivity & retention¹ ²

Reduces knowledge silos

Improves the bus factor — reduces succession risks

Creates a more positive, helpful, collaborative team culture

Increases loyalty

Increases employee engagement and motivation, dramatically improving financial outcomes³

Improves leader identification and promotion pipeline — mentors are 6 times more likely to be promoted (Sun Microsystems)

The industry recognizes that there is a growing skills gap, and has tried to plug it by offering free subscriptions to online learning, free books, etc…, but those resources go under-utilized by employees because:

Employees usually don’t know what to focus on or how to learn it, and sorting through free learning subscriptions feels like a colossal waste of time when it’s hard to find materials directly relevant to their job

Employees fear that their career development is not important enough to the company to disrupt their daily workflow

A mentor engages 1 on 1 with employees. A good mentor should be able to quickly and easily identify weak spots and help fill in knowledge gaps without wasting any time searching through random learning resources.

By incorporating mentorship into regular employee duties, you can remove the perceived daily workflow “interruptions”, and officially allocate time for employees to learn and engage with each other.

Lifting Teams to 10x Productivity

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. (See also “Getting to 10x”).

Conversely, many developers are able to produce software that delivers organizational value, but do so while incurring a tremendous amount of tech debt: Writing code that is difficult or impossible to maintain, or littered with bugs. Usually both.

Such developers may produce value in the short term, but contribute net negative value to the organization over time.

The trouble is, it’s hard to hire senior developers:

The average difference between junior and senior developer salaries in the united states is $40k per year (source: Indeed.com), leading some companies to try to save money by hiring more junior developers and fewer senior developers.

This strategy backfires because without the proper guidance, junior developers usually cost much more than the salary difference in degraded product quality and productivity.

If you want to save money, don’t hire cheaper developers. Train better developers.

Senior developers are hard to find and recruit. Because tech job growth has consistently outpaced the influx of new developers in the market for years, competition to hire senior developers is fierce, and salaries can easily exceed the budgets of all but the most well-funded companies. As of this writing, top companies routinely spend $140k — $250k+ (up to $400k at companies employing the golden hand-cuff retention strategy) for top-tier senior developers.

What is a senior developer, anyway? Perhaps you’ve heard of the 10,000 hour rule. It takes about 10,000 hours of deliberate practice to master a craft. That’s about 6–10 years. But developers with 1–5 years of experience are frequently being hired to fill “senior developer” positions. Clearly, the 10k hour level of mastery is not the one being used to define “senior developer” in the industry today — for good reason.

I’ve seen developers with 20 years’ experience I wouldn’t trust to build a todo app, and others with less than 1 year I’d trust with the architecture of a mission critical product. While there’s no substitute for experience, after the first year, experience matters a whole lot less than a passion for the craft and a drive to excel at it.

After 1–3 years, you start to really see the difference between developers committed to excellence and deliberate practice, and those who are just in it for the J-O-B. A “senior” developer doesn’t have to be a master of the craft right now, but they should at least be on the path.

That said, there really is no substitute for real experience. You can really benefit from somebody who’s been where you’re headed before, and has had enough deliberate practice time to develop a deep mastery of the required skills. No matter how good your training is, it’s great to have at least one expert mentor available to help your team.

Ideal Expert Mentor Attributes (should have most of these)

Empathy

Patience

Excellent communicator & technical writer

6+ years’ experience building apps full-time (Yep, experience matters in this case — we’re looking for mastery. See the 10k hour rule.)

A deep understanding of software development principles in multiple paradigms (OOP, FP, etc…)

Experience with multiple programming languages, preferably from different language families (C family, Lisp family, ML family, etc…)

Experience scaling an app with more than 20 developers and more than 10 million users

1–2 years’ experience with your particular tech stack

The big problem is, employees who match that description are extremely hard to find, and hard for small companies to afford. (Please reach out if I’ve just described you).

Most job listings currently titled “Senior JavaScript Developer” don’t require this level of expertise. 1–3 years’ experience, with 1 year in the required tech stack and high-quality JavaScript training would be more than adequate. Pair them with a good expert mentor, and they’ll contribute at (or very near) the level of the best senior developers on the team. A few will stand out and exceed your best expectations.

How do we hire 10x developers?

The more I work with tech leaders trying to build great teams, the more I think about what qualities make some developers 10x better than others, and the qualities that make some teams 10x better than others.

Universally, 10x teams employ 10x developers. I have never seen an exception to that rule. But not every team with a 10x developer on it becomes a 10x team.

What’s the difference?

Mentorship Culture

The first step is to foster a culture of mentorship on your teams. One of the best ways to do that is to protect your code repo branches so that you can’t merge into the main trunk without a code review.

Most people think this is about preventing bugs, but it works best when developers view it as a mechanism for learning and knowledge sharing. When you see code that could be simplified, point it out. When you see anti-patterns, point out the alternatives. You should always have at least one other team member reviewing every line of code before it gets merged.

It’s just a nice side effect that doing this leads to fewer bugs. Every hour spent in code review saves 33 hours of maintenance. (See also: “The Outrageous Cost of Skipping TDD & Code Review”)

But that’s just step one. Most working developers (even senior developers) are lacking basic foundations in the essence of software development: composition. All software development is the act of decomposing problems into smaller pieces and composing the solutions together to form an application. You can do it intentionally, with purpose, or you can do it accidentally, with duct tape and crazy glue.

For best results, you need somebody on your team with a solid foundation in how to compose functions and data structures well, understand what goes where, and how to fit all the pieces together.

I’ve got some bad news to break to you:

There’s close to 100% chance that nobody on your team is qualified.

How do I know? Because I have been interviewing candidates for JavaScript jobs on a regular basis since 2010, and I’ve encountered close to zero candidates who qualify at interview time without some supplemental training.

What do I mean by that specifically? The candidate should be able to answer the following questions correctly, and demonstrate the principles in code:

“What is function composition?”

“What is object composition?”

Together, those form the cornerstones of functional programming and flexible object reuse.

In JavaScript, they’re supported by 2 very important features that I call “the two pillars of JavaScript”:

Prototypal Inheritance

Functional Programming (specifically in JavaScript, first class functions with closures enable this)

When I mentor new recruits, the first order of business is to help them understand the basics of functional programming and flexible OOP.

“Favor object composition over class inheritance.” ~ Gang of Four, “Design Patterns: Elements of Reusable Object-Oriented Software”

Those simple pillars provide a solid foundation to build apps on top of, with all of these features:

Less code

Fewer bugs

Improved code clarity

Reduced maintenance costs

Mentorship culture also allows the easier spread of useful ideas throughout your organization. Ideas with huge potential to impact critical business performance metrics, such as:

TDD, and improved testing processes, which saves significant time and money

Continuous delivery (automated with CI/CD tools and workflows), which reduces the risk of vaporware and budget-blowing estimation hazards

Better code organization, which reduces software maintenance costs

How Much Should You Invest in Mentorship?

The benefits are so clear and so impactful, the question about implementing mentorship in your developer organization should not be if you’ll do it, but how much you should invest.

My general rule of thumb is that every developer should be paired with a more experienced mentor — somebody who has been where you want that developer to go.

That rule is not simply for junior staff or new hires, but your most senior staff, as well.

You should count on spending about 30% more on top of a developer’s annual salary to provide adequate mentorship for that developer. That cost is primarily the cost of pairing a developer with a more experienced mentor (paid in salary to the mentor). For the low cost of 30%, you can yield as much as a 1000% productivity boost. You’d have to be crazy or uninformed to pass on that deal.

Mentorship should consist of a mix between training specific skills and pairing on problems in your real projects.

Pairing, you’ll have two people working together, collaborating to solve a problem with the junior in the pair doing most of the driving — the mentor should take a hands-off approach, serving as a navigator. You don’t need to pair developers full-time to provide the mentorship benefit, but you should set aside at least an hour per week for the mentor and mentee to work together one-on-one. Junior developers will need a lot more pairing time.

This sounds pretty good until you ask the question, “who will mentor the mentors?”

“Who will mentor the mentors?”

In my experience on teams with mentorship cultures, even the most junior developers on the team quickly reach the skill level of the most skilled people on the team, but when they reach it, improvement hits a brick wall, and additional progress is very slow going.

In order to remove that artificial ceiling, you need to have access to higher-level mentors — people who are not necessarily part of the team.

I went out searching for a mentorship platform to find qualified mentors to do exactly that, and I couldn’t find one, so I cofounded DevAnywhere.io. We developed an advanced JavaScript curriculum, started mentoring developers one-on-one, and the program has produced some spectacular results.

If you need mentors for your team leads & new recruits, we can help you out.

Level Up Your Skills with Live 1:1 Mentorship

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