Hiring a Javascript Dev? Use These Interview Techniques
You decided to hire a JavaScript developer. You want them to be perfect all around — to navigate JS’s crazy ecosystem, to have deep expertise in your technology of choice, and to be fluent in core computer science principles. Yes, another flavor of the Iron Triangle, and we can’t have it all. But can’t we try?
In this article, I wanted to share our experience interviewing developers and the methods we use to determine where a candidate falls within the said triangle. However, it’s important to establish some foundational understanding first.
What Do We Look for?
Some skills are not negotiable. Many thanks to Chirag Jain, who distilled them into an evident and handy list:
- Problem-solving,
- Critical thinking,
- Continuous learning,
- Team spirit,
- Self-management.
So, these are the must-haves for an engineer in any niche.
What Do You Look for?
It depends on your specific case. What a revelation, I know. Still, you look for someone to solve a problem, so profiling the problem outlines the required skill set. Keeping it short and sweet, I prefer UNPHAT (another batch of gratitude here goes to Oz Nova, whose article on technology choice inspired me). It stands for Understand, eNumerate, Paper, Historical context, Advantages, and Think!
Let’s Recontextualize It a Little for Our Needs:
- Understand the problem: What specific challenges is your project facing? Are you building a high-performance web application, maintaining a legacy codebase, or creating a new framework?
- Enumerate multiple solutions and consider different approaches to solving your problem. Could it be addressed by a specialist in a particular framework or someone with broad ecosystem knowledge?
- Research papers (or documentation) of the technologies and methodologies relevant to your problem. This could involve reading documentation for specific frameworks or studying best practices for your application type.
- Consider the historical context of your project. What experience would perfectly match your project’s current state and future direction? For instance, a developer with experience in jQuery and modern frameworks like React or Vue might be ideal if you’re modernizing a large jQuery codebase. If you’re building an application with the latest technologies, someone with a history of early adoption and quick learning might be more suitable.
- Weigh the pros and cons of different developer profiles. A React expert might be perfect for your project, but consider what you might be sacrificing regarding broader JavaScript knowledge or core CS skills.
- Soberly evaluate how different developer profiles would fit your needs. What facts would need to change for you to prioritize one area of expertise over another?
What Exactly Do You Look for?
It’s time to combine those (and here’s where we hit the Iron Trilemma). Ideally, you’d want a developer who excels in all three areas, but such candidates are rare and often come at a premium. More realistically, you’ll need to prioritize based on your project needs (as identified through your UNPHAT analysis) while ensuring the candidate possesses the non-negotiable skills we discussed earlier.
Let’s explore how this might play out in different scenarios:
Scenario 1: Startup Building a New Product
- UNPHAT Outcome: Need for rapid development and flexibility
- Prioritized Area: General JS knowledge
- Why: Prioritize a developer who can quickly adapt to changing requirements and isn’t locked into a single technology. Their broad knowledge allows them to make informed decisions about which tools to use as the product evolves.
Scenario 2: Enterprise Modernizing Legacy System
- UNPHAT Outcome: Need for specific expertise to handle complex migration
- Prioritized Area: Specific expertise
- Why: If you’re migrating from an old jQuery codebase to React, you might prioritize someone with deep React expertise, including experience with large-scale migrations.
Scenario 3: Tech Company Building Developer Tools
- UNPHAT Outcome: Need for optimized, efficient solutions
- Prioritized Area: Strong computer science fundamentals
- Why: A strong foundation in CS principles is crucial when building tools other developers will use. This ensures your products are well-architected, efficient, and can handle complex use cases.
In each scenario, the non-negotiable skills (problem-solving, critical thinking, etc.) remain constant, but the technical focus shifts based on the specific needs identified through UNPHAT.
Balancing the Trilemma
While you may prioritize one area, it doesn’t mean you completely ignore the others. Here’s how you might balance them:
- Use your UNPHAT analysis to prioritize based on immediate needs and determine which area is most critical for your current project.
- A candidate who is strong in your priority area and shows aptitude in the others might be ideal. Their ability to learn and adapt (one of our non-negotiable skills) is key here. Look for growth potential and a problem-solving approach.
- Consider team composition. If you already have deep, specific expertise on your team, you might prioritize broader knowledge or CS fundamentals to round out the team’s skill set.
Constructing an Interview
Now to the meat and potatoes. How exactly do you identify your Mx. Big Hire? Here’s a toolkit of assessment methods. Choose and combine the ones that best align with your needs.
Rapid Fire Questions (Under 15 Minutes)
What’s happening: A quick series of technical questions covering various aspects of JavaScript and its ecosystem.
Example:
- What’s new in ES2024?
- When would you choose Vue over React, or vice versa?
- Explain the concept of tree-shaking.
What you can learn: This assessment quickly gauges the candidate’s broad knowledge of JavaScript, recent developments, and ability to articulate technical concepts concisely. It’s beneficial for assessing the general JS knowledge and communication style.
System Design Discussion (10-20 Minutes)
What’s happening: Present a high-level problem related to your business and ask the candidate to design a scalable solution.
Example: Design a real-time collaborative text editor or a high-performance data processing pipeline.
What you can learn: This discussion showcases the candidate’s ability to think at a systems level, understand scalability and performance considerations, and know relevant technologies. It’s beneficial for senior roles and assessing core computer science knowledge.
GitHub Profile Review (20-30 Minutes)
What’s happening: Examination of the candidate’s public code repositories and contributions.
Example: Look for contributions to open-source projects, personal projects, code quality, documentation practices, and activity in the JavaScript community.
What you can learn: This review provides insights into the candidate’s coding style, proactiveness in the developer community, and passion for programming. It can indicate their expertise in specific technologies and commitment to continuous learning.
Code Review Exercise (30 Minutes)
What’s happening: Provide a code snippet with intentional inefficiencies and ask the candidate to review and optimize it.
What you can learn: This exercise assesses the candidate’s ability to identify performance issues, knowledge of best practices, and skill in optimizing code. It’s particularly useful for evaluating their depth of knowledge of specific frameworks or libraries.
Pair Programming Session (1 Hour)
What’s happening: Work with the candidate on a small, complete task in real time.
Example: Implement a feature together, such as adding sorting functionality to a table component or creating a custom hook in React.
What you can learn: This session reveals the candidate’s problem-solving approach, coding style, collaboration ability, and communication skills. It’s an excellent way to assess how they might work within your team.
Trial Day (8 Hours)
What’s happening: Invite the candidate for a paid workday with your team. Have them work on small, completable tasks in your actual codebase and interact with team members in a natural setting.
What you can learn: This immersive experience provides insights into how candidates perform in your work environment, their ability to navigate your codebase, and how well they mesh with your team culture.
Take-Home Project (4-8 Hours)
What’s happening: Assign a real-world task that mirrors your project’s requirements and must be completed within a set timeframe.
Example:
- For a real-time application: Implement a simple pub-sub system in JavaScript.
- For data-intensive applications: Build a basic ETL workflow orchestrator.
- For front-end focus: Create a small React or Vue application with specific features.
What you can learn: This assessment reveals the candidate’s problem-solving approach, code quality, architecture decisions, and ability to work independently. It’s excellent for evaluating their expertise in specific technologies and their application of CS principles in real-world scenarios.
TL;DR
- We defined the bare minimum for a hire.
- We identified how to form requirements for the hire.
- We reviewed several options for assessing candidates.
Thank you for bearing with me. This article is just one perspective in a sea of hiring strategies and experiences, and I’ll be glad if it serves its purpose. I would love to hear your insights, challenges, and success stories. What strategies have worked for you? What unique challenges have you faced when hiring for JavaScript roles?
