Sean Massa's Labs

How to Run Strength-finding Interviews

2020-03-25 #interviews

I was on DojoLIVE! to discuss Strength-finding Interviews. Check it out!

In an effort to highlight candidates at their best, Trek and I have been running Strength-finding Interviews over the past few years. Over the course of 2 companies, 94 phone screens, 27 interviews, 14 offers, and 9 hires we've refined this approach into something that increases our confidence in no-hires and success in yes-hires. Approximately half of the candidates provided unsolicited positive feedback about the process, even when they were not made an offer.

The key difference between a Strength-finding Interview and traditional interviews is that the interview format is customized per candidate to assess their individual strengths. You can still maintain consistency of assessment by making sure strengths are always tested in the same way and that certain core strengths are always tested.

What follows is a walk-through of the process as a guide for how to do this yourself. You can expect to gain:

In this post, we'll focus on the most unique aspect of the Strength-finding Interview process: Negotiating an Interview Format.

A Job and a Candidate

Let's assume we have an open position for a Web Software Engineer position we'd like to fill.

📋 Job: Web Software Engineer

FlashRecruit is a funded recruitment technology startup with massive traction (SaaS based) looking for a Software Engineer (for full stack development) to join our growing team! We're building chat-based (and other) software to make the job seeking and recruiting experiences better.

Opportunity You are invited to join us on this adventure! There is a unique opportunity here to not only be a part of what we're building, but to influence the direction we take. You will be able to contribute your different skill sets to the various problems we'll solve together.

In this role specifically, you'll be collaborating with the development team to build new features, new products, and iterate on our processes. These efforts will directly lead to happier customers and more sales for the business.

We'd love to tell you more about what to expect, but the team is small and growing. It's hard to predict what the future will hold. Joining now gives you an opportunity to shape that future.

Context We work in the recruiting software landscape, which is complex and crowded. We're doing something unique in the space by offering the ability to chat with a recruiter before applying to a job, which is exciting. We're not stopping there.

We're also a small startup, which means you'll likely wear different hats at different times. We expect you to spend most of your time writing software, but sometimes other related hats will be necessary.

We have an office in Oakbrook, which you are free to use if you like, but the engineering team is fully remote. The company fully embraces remote work. You will be collaborating with others that could be working anywhere in the US (for now). Because of this, communication is key. This includes screen sharing, remote pair programming, writing documentation, virtual meetings, and more.

Expectations of You There aren't many technical requirements. We don't want to exclude you based on something you could learn quickly enough on the job. Instead, we'd like to focus on the skills that we find to be critical to happiness and success in self and team.

Continuous Improvement: For each other item, you don't have to already be great. The core expectation and real requirement is that you improve over time. The processes and expectations in place will facilitate that, but you should be motivated to continuous improvement as well.

Code: Writing software is the core of this role. You should write software that is tested, modifiable, and clear. We have no expectations around computer science concepts, but you should be open to learning about anything relevant to the work.

Worked on Web Software: You should have built web applications or the systems supporting them before. Experience with our entire stack is not necessary. It is helpful to have some experience with at least one of these:

  • Node.js (API)
  • Ember (Web Client)
  • React Native (Mobile Apps)
  • Heroku/S3/RDS (Infrastructure)

Collaborate: You should work well in a collaborative environment. As a team, we'll be building software, reviewing code, deciding on architecture, and iterating on our processes. You don't have to do all of these things, but we'd like you to be involved with the team more than just executing individual task after task.

Write: Because we fully embrace remote work, you will often be writing messages, pull request descriptions, the occasional document, and more. Technical Writing is an important skill in general, but especially in a remote environment.

Give Feedback: You should give feedback on the product, team, and team members. Feedback should be specific, actionable, and timely. For individuals, it should also be directly related to the job they are expected to perform. You should also be mindful or biases when giving feedback.

Receive Feedback: You should respond well to valid feedback. Responding well can mean many things, including disagreement. We want to build a strong, trust-and-respect-based relationship across the team that allows us to give feedback about actions, not judgements about people.


  • Competitive compensation
  • Equity in a funded, early-stage startup poised for exponential growth
  • Full-time W2 employment
  • Health Care Plan that's good for families and individuals
  • Flexible time to allow for a work-life balance that works for you and your family
  • Minimum Required PTO with suggested 4-weeks per year
  • Intentionally Guided Culture based on inclusion and respect
  • Remote work

If you aren't sure if you should apply, please apply anyway. Don't self-select yourself out. We'd be happy to discuss any concerns you have with the job post matching your skill set.

FlashRecruit is committed to creating a diverse environment and is proud to be an equal opportunity employer. All applicants will receive consideration for employment without regard to race, color, religion, gender, gender identity or expression, sexual orientation, national origin, genetics, disability, age, or veteran status.

Side Note: I used in the writing of this job post and I'm very happy with the results!

Jessie decides to apply for our job.

👩🏾‍💻 Candidate: Jessie

Education: Self-taught
Experience: 4 years web development

  • Worked on chat software before
  • Designed and implemented APIs in Node.js
  • Implemented web applications in React
  • Wrote API documentation
  • Managed API project by breaking down tasks and communicating across teams

Negotiating an Interview Format

This starts with a request for information from the candidate. The request boils down to "what are your strengths that overlap with our needs?"

We sent Jessie the following email in response to their application.

✉️ Subject: FlashRecruit Interview Process
To: Jessie
From: Sean

Hello Jessie!

Welcome to Phase 2 of our interview process!

  • Phase 1: [Audio Call] Confirm Expectations
  • Phase 2: [Email] Interview Negotiation
  • Phase 3: [Video Call] Strength Finding Interview
  • Phase 4: [Variable] Follow Ups
  • Phase 5: [Video Call] Meet the Founders

The goal here is to really highlight your strengths. Take some time think about what your strengths are, what our problem domain looks like, and how those overlap.

Our stack is:

  • Node.js (API)
  • Ember (Web Client)
  • React (Deprecated Web Client)
  • React Native (Mobile Apps)
  • Heroku/S3/RDS (Infrastructure)

Our problem space is the recruiting software landscape. We're currently focused on improving our job board and streamlining customer on-boarding.

That means:

  • integrating with third party APIs
  • building and running recurring processing tasks
  • consuming XML feeds
  • iterating a relational-database-backed API
  • iterating a web client for a job board
  • iterating a web chat widget
  • rethinking the job board

Please send me your thoughts on what your strengths are and what would best highlight them. This doesn't have to be lengthy. We'll work together to get a set list in place. Then we'll tailor the interview to that list.

Example Strengths:

  • Data Modeling a user and authentication system with a focus on security
  • Finding and fixing poor DB performance
  • Turning a bug report into an actionable bug fix
  • TDDing a feature end to end
  • Refactoring a too-large model
  • Breaking down large tasks into smaller ones
  • Optimizing a UX flow
  • Designing new views
  • Documenting a gnarly part of the system

Then, we'll schedule the actual interview. We like to book 4 hours for that, but if that large of a block of time doesn't work, we can split it up.

If coding in an interview setting won't show you at your best, we can provide a homework problem for you to tackle or you can provide a suitable work sample. In those alternative cases, the scheduled interview would involve talking through homework or work sample.

If you have any questions or concerns about any of this, please let me know.


~Sean Massa

The candidate then responds with their strengths. If they shared some relevant strengths, select a couple to build into the interview. If not, either (1) select less relevant strengths as a way to assess their ability to master something or (2) follow up with them to see if there are other strengths you could focus on.

✉️ Subject: My Strengths
To: Sean
From: Jessie

These are my strengths that seem to overlap with your needs:

  • Technical Writing
  • API Design
  • Outside-in TDD of a Feature
  • System Architecture Design
  • Breaking Large Tasks into Smaller Tasks

I don't typically do well programming in an interview setting. My past work is all private, which means I have no work samples I can provide. Can we do the homework problem you mentioned instead? I'm most comfortable with Node.js for APIs and Jade templates or React for web apps.



Interview Modules

Interview Modules are how you can find balance between consistent and adaptive interview experiences for candidates. The format is flexible around which modules are chosen, but a given module should remain as consistent as possible across candidates.

Selection: Some modules will still apply to most candidates. In our interviews, we typically do the same 2 modules for everyone, then leave room for 2 other modules to be flexible towards the candidate's strengths. Modules should also span technical implementation skills as well as collaboration/communication skills.

Format: Collaboration is very important. If the candidate is comfortable with it, try to make at least 1 large module involve collaboration with a team member. That doesn't have to be live coding in a high-pressure situation. Collaboration could be talking through an architectural design, planning a project, triaging (not necessarily fixing) a bug, or the like.

Construction: As you use this process more, you'll build more and more modules. This will require some work, but it's also worth the effort. When building modules, try to make them as realistic as possible. The domain should be the same or analogous to your domain by default, although you can shift this per candidate too. The tasks should be representative of the work required to do the job. Try to be flexible on technology choices, as well. Candidates will do a better job if they can pick tools they know to solve a problem.

For our job, we could really use someone with strong API Design and high-quality execution. We also want to assess how well they will work in a remote environment.

Let's set up an interview that highlights the candidate's "API Design" and "Testing". We already asked for a technical writing sample and the homework problem includes a writing section as well. We can dig further into how well the candidate works in a remote environment during the Q&A.

✉️ Subject: Interview Agenda
To: Jessie
From: Sean

We're excited for your interview!

Proposed Interview Format

Here's a breakdown of the interview format we'd like to use. Let me know if you have any comments, questions, or concerns.

  • Intro and Overview (15m)
  • Homework Discussion: Chat App (1hr)
  • Break (10m)
  • Collaborate: API Design (1hr)
  • Collaborate: Refactoring and Testing (45m)
  • Break (5m)
  • Two-directional Q&A (45m)

Intro and Overview

We'll walk through the general landscape of FlashRecruit's industry and architecture. This will help us get things flowing before digging into the other modules.

Homework Discussion: Chat App

Strength: Technical Implementation

We'll discuss the decisions you made and the product you produced for the homework assignment. This will include what you would plan to do if you had more time.

API Design

Strength: "Designed and implemented APIs in Node.js"

We'll take a page from our system and talk through how we'd go about architecting the API of it from scratch. We'll dig into general strategy, URL schemes, wire formats, resource relationships, data backing, performance monitoring and optimization, and wherever else you have related skill.

Collaborate: Refactoring and Testing

Strengths: Refactoring and Testing

We'll discuss refactoring and testing strategies in general and with a specific example from our system.

Two-directional Q&A

We'll take this time to ask more specific questions about each other.


Please do the following:

  • provide a technical writing sample
  • confirm the interview format
  • provide availability for a 4-hour block in the next week or so

The candidate agrees to the format and sends the requested information. Now we build the assessment scorecard for this candidate.

Each module can assess multiple skills, some deeply and others less so. There can also be a lot of overlap. A scorecard format helps us gather notes from multiple sources about a specific skill.

Below are the modules we're going to run along with the skills we can capture signals for in those modules.

📝 Assessment Plan: Jessie
  • Homework Discussion: Chat App
    • UI Component Architecture
    • UI Component Development
    • Testing
    • CSS Implementation
    • Technical Writing
    • Breaking Down Tasks
    • Maintainable Code
  • Collaborate: API Design
    • API Design
    • Testing
    • Technical Writing
    • Collaboration
  • Collaborate: Refactoring and Testing
    • Refactoring
    • Testing
    • Working with Existing Code
    • Culture: Empathy and Understanding for Past Decisions
    • Collaboration
    • Maintainable Code
  • Two-directional Q&A
    • Giving Feedback
    • Receiving Feedback
    • Remote Work
    • Collaboration
    • Continuous Learning

That's It, for Now!

You may be able to imagine how we take that scorecard through to the execution of the interview, but either way, there will be future posts in this series that cover the rest of the process.

I hope you found Strength-finding Interviews useful. This is the result of research, experimentation, and iteration across years of work, quite often in collaboration with Trek. You can read Trek's earlier take on this format, as well.

I consider this to be an evolving process. If you have questions or feedback, please let me know! Please send it to,, or comment below!

Related Resources

How to Run Strength-finding Interviews | Sean Massa's Labs