Don’t Hire Rockstar Developers. Create Them.

“I have over 200 tech openings.”

I recently heard that statement from a close friend who owns a large tech recruiting company. It wasn’t surprising to hear — finding good tech people isn’t easy, and skilled labor isn’t cheap. 

According to the Bureau of Labor Statistics, the job market for software developers is growing at an incredible rate. Employment opportunities are projected to grow 22 percent from 2019 to 2029. The average growth rate for all other occupations is around 5 percent. In other words, great developers are in high demand — and that’s unlikely to change in the near future.

BlueStingray.com is known for its strong team of developers. We’ve built that team gradually, often hiring applicants who had little background in software development. In many cases, we’ve invested heavily to develop our employees’ skills, and we made those investments because we were confident in the individuals we’d hired. 

Here’s the secret:

We don’t hire rockstars. We hire based on personal characteristics that make for great employees — then provide the resources our team needs to grow their skills. By keeping the process structured, we avoid bad hires, and we rarely pay six-figure salaries at the outset of employment. 

Why Rockstar Developers Make Bad Employees

Like many CEOs, I’ve heard the term “rockstar” thrown around for the last decade or so — and like most people in tech, I’m not a huge fan of the term. A rockstar is someone who’s exceptionally good at their job, aware of their talents, and ready to move on to the next big opportunity. In other words, they’re bad long-term employees. 

When we’re hiring, our goal isn’t to find the rockstars. It’s to create them. The formula we’ve used to build our team is simple, as it only contains two key variables (and yes, as a tech CEO, I’m using an actual formula). $var1 =  the person that fortune 100s don’t hire who will be amazing devs based on raw brain power/

$var2 = A training program that allows new developers to excel to the point that they become loyal developers.

By taking advantage of these variables, an employer can build an incredible staff of loyal workers. That requires a thoughtful hiring process — and acknowledging that the employer’s responsibilities don’t end after onboarding.

LaunchCode

To find people who meet our criteria — and don’t expect six-figure salaries right out of the gate — we often use three resources: LaunchCode, online ads, and referrals from current employees. Of these options, I’d recommend LaunchCode as a primary resource. Started by Jim McKelvey, LaunchCode, offers a free tech education with job placement opportunities. The goal:  Bring people from all backgrounds into the tech field, reshaping the way that employers think about hiring. We’re fans of their outlook on the industry, and their resources have allowed us to build a diverse and talented team.

But finding applicants is only the first step of the process. To hire intelligently, businesses need to look for the right qualities, and a substantial resume — while helpful — isn’t the most important factor.

Interviewing Developers: A Two-Step Process

We have tried many approaches over the years, and through our experience, we’ve streamlined our hiring. All capable applicants receive two interviews, and I’m looking for different characteristics in each interview.

The first interview is with the CEO, never with a group of individuals. A group environment isn’t appropriate for engineering interviews — the group setting might work for a sales position or a job that requires speaking or presenting to groups of individuals, but we’re looking for people who can communicate effectively to other engineers (occasionally clients).

The first interview is to see if the person will be a good cultural fit. Will they be able to work with other engineers as a team to complete large complicated tasks? Are they passionate about programming? Do they program outside of school or work? 

We’ll typically avoid recent college graduates, non-practicing programmers, and rockstars who intend to use the position as a stepping stone to bigger, not-so-much-better things. We want people who appreciate what we offer: a cubicle-free, culturally diverse work environment with plenty of room for advancement. We’re hiring for the long term, and we want people who will grow with us.

Interview One: Attributes To Consider

1. Basic communication skills
2. Personality (Is the candidate pleasant to work with?)
3. Passion (Does the candidate show enthusiasm for tech?)
4. A basic understanding of programming
5. Ability to learn quickly
6. Cooperativeness (Is the candidate a team player?)

As for the applicant’s technical background, we’re not concerned with the languages they know or use (at this point). We’re simply looking for people who understand the concepts of software engineering. Experience is important, but long-term employees need the capacity to learn new skills.

The second interview is performed by a CTO or senior engineer. The goal is to determine at what technical level the candidate is based on previous work. As stated above, we prioritize capability over experience; I’d rather hire a motivated programmer than an experienced programmer who’s simply looking for a paycheck. If we believe that the candidate can contribute to the team in less than 90 days, the cost of training a new employee will quickly be regained once the employee can work on billable projects. 

Interview Two: Goals

1. Determine the technical level of the candidate
2. Evaluate the training needed to get the candidate up to speed
3. Determine true level of interest in technology specifically programming
4. See how comfortable the candidate is with discussing code, technology and their reason for engineering their app the way that they did.

We ask the candidate to walk us through some of their current code or apps that they have built. As we have them discuss their app, we discuss their development process. Questions can include: Did you do a discovery? What tools and systems did you utilize?

As they walk through the app, we also sprinkle in dozens of questions so that we can determine the extent of their technical knowledge. 

Also Read: 6 Things You Want to Check Before Hiring Remote Developers

• Training Developers and Engineers

This is where the fun begins — and this is where Blue Stingray stands out.
Great training is just as important as great hiring, and 95 percent of our new hires do well under our training process. A few need extra help or can’t keep up, but if they’re capable and motivated, we’ll provide the resources they need to join our team.
Again, we try to move new hires onto a billable project within 90 days. In other words, training needs to be extraordinarily effective, and a structured process makes that goal much more manageable.

We break down our training process into three stages:

1. Following training documents and working with a team lead and a mentor. 
2. Working on small tasks along with a senior developer and a mentor.
3. Ongoing training and support as they slowly move into billable client work. 

After configuring a laptop with everything the new hire needs, we start the training. The exact process varies depending on what skills they’re developing, but I’ve learned that an established framework is absolutely crucial. If employees don’t receive structured training, you’re preventing them from meeting their potential. More pertinently, you’re wasting time — and so is the employee.

Our documentation is a combination of proprietary Blue Stingray guides and training tools that we’ve found online. Unlike other companies, we don’t shy away from free online resources. Most modern programmers rely heavily on free tools, so it makes sense to utilize these. We provide support from a lead developer and mentor; the trainee handles tasks at an increasing level of difficulty until we feel they’re ready to work on a billable project.

We want trainees to be comfortable while learning, and we recognize that different people acquire skills at different rates. All programmers feel a sense of pressure when working on their projects, but we take steps to prevent this pressure from getting in the way of good work. We’re able to do this by maintaining a structured approach to training with plenty of guidance. 

For Small Companies, Developing Developers Makes Sense

Blue Stingray is a small team, and we began training our own programmers and engineers through necessity. As we’ve grown, we’ve maintained the same approach — by “developing developers that can develop,” we save money, build loyalty, and avoid candidates who would contribute to a toxic work environment.

Occasionally, we’ll encounter a project that calls for an established “rockstar” candidate. These are more expensive hires, but sometimes they work out well. Still, we prefer developing our own core. That process results in loyal employees, and as long as we treat them fairly and compensate them appropriately, they’ll stick with us over time.

Successful sports teams can’t stay successful for long without a great minor league farm system. Granted, the tech world is a bit different, as every programmer needs to join the major leagues quickly, but on-the-job training is the most effective way to build and maintain a successful company.