Hiring is Broken: A Guide for Early Stage Startups

Here’s a secret. We all know the interview process is broken. The current method of interviewing, especially for Senior Developers, is exhaustive– it stretches resources thin without significantly improving the quality of hires.

Over the years of working at start-ups I’ve built a process tailored for teams of three to fifteen software developers that prioritizes meaningful engagement and organizational alignment. This methodology has proven effective in my experience.

The Foundation: It Starts with You

The energy you bring to an interview sets the tone for the entire process. A rushed or tired demeanor won’t inspire confidence or encourage the best from your candidates. The solution? Interview fewer candidates but do it more thoughtfully. Begin with a resume screen that focuses on those that truly resonate with you, looking for projects or accomplishments that spark your interest and align with your organizational needs.

Understanding Your Needs

Before diving into interviews, clarify to yourself what you’re seeking in a new hire. Is it mentorship ability, process improvement skills, sound architectural decision-making, or the capacity to lead the development of a new feature?

The Interview Process: A Structured Conversation

Allocate an hour and a half for an interview that explores the candidate’s past projects, technical challenges, and achievements. Start by walking the candidate through the process. The interview starts with project deep dives. Then switches to general software knowledge, and ends with a practical coding exercise.

Project Deep Dive: Ask them to describe a software system they built and are proud of. You’re looking to understand their role and why it was significant to them. Explore the technological challenges they faced and what they’d do differently in hindsight.

Consistent Delivery and Impactful Contribution: The ability to consistently deliver projects to completion is especially critical in smaller organizations, where each team member’s impact is magnified. Senior developers should have a history of successfully seeing projects through.

Quantifiable details: In addition to evaluating their delivery record also delve into the quantifiable details of their projects. Inquire about specifics such as the number of requests served, page load times, or the size of the largest database table. With this technique you gather evidence of their active involvement and understand the scale of their work.

Technology Alignment: Inquire about their favorite technology and how it aligns with your stack. This can reveal if they’re a good fit for the role you’re envisioning. For senior positions, especially, alignment with the existing tech stack is non-negotiable.

General Software Knowledge: Dive into their technical understanding with questions that cover fundamental and practical knowledge. Encourage guesses and ask them to reason about the question.

In the context of HTTP, what is the difference between PUT and PATCH?
What is the difference between Docker and Kubernetes?`
What is the difference between Javascript and Node.js?
What is the purpose of a database index?
Which datatypes are suitable to store money values such as the invoice total?

Practical Coding Exercise: Evaluate coding proficiency through straightforward tasks focusing on the basics of the langauge. Here’s a Python challenge I use:

Create a Person class.
Add functionality to the class to allow it to “speak it’s own name.”
Create a collection of Persons.
Filter out all persons named “X” from the collection you created.

Acknowledging the Two-Way Street

Remember, interviews are as much for the candidate as they are for you. Be prepared to answer questions about the role, on-call load, the technology and your team.

Hiring as a Skill

Not everyone is naturally adept at interviewing. It requires a breadth of experience and a nuanced understanding of both technical requirements and human engagement.