Templates

Interview process template: designing the stages for a role

On this page
  1. Design in five steps
  2. Stage types and what they are good for
  3. The coverage matrix
  4. The interview process template
  5. Example 1: account manager (mid-level)
  6. Example 2: backend software engineer (senior)
  7. Checks before the process goes live
  8. Running the process consistently
  9. Common design mistakes
  10. Questions people ask

An interview process template sets out the stages a candidate goes through for one role: what each stage assesses, its format and length, who runs it, what a candidate must show to move on, and how long the whole process asks of the candidate. Designing it before the first screen is what keeps five interviewers from asking the same questions while nobody checks the skill that matters most.

This page is about the design of the whole process. The questions for each stage go in an interview guide, the scoring in an interview scorecard, and the logistics of a multi-interviewer day in a panel interview plan.

Design in five steps

  1. List the competencies. From the intake meeting, write the four to six things a person must bring to succeed in the first year. Split them into must-haves and nice-to-haves.
  2. Pick the best method for each. Some competencies show up best in conversation about past work, some only in a work sample, some in references.
  3. Assign each competency to one stage. Each must-have gets a primary stage where it is assessed in depth, and at most one other stage that checks it.
  4. Order the stages. Cheap and quick stages first, to narrow the pool; expensive stages later, when fewer candidates remain.
  5. Set pass rules and time limits. What a candidate must show at each stage, how quickly feedback is due, and the total hours asked of the candidate.

Stage types and what they are good for

Stage typeGood forWeak forTypical length
Recruiter screenMust-have experience, logistics, pay fit, motivationDepth of skill20–30 min
Structured behavioral interviewHow the candidate handled real situations: ownership, conflict, judgmentHands-on skill45–60 min
Technical or skills interviewKnowledge and reasoning in the domainWorking style over time45–60 min
Work sample (live)Doing a representative task with the team watchingPerformance under less pressure60–90 min
Take-home assignmentQuality of independent workCandidates with little free time; hard to verify authorship2–4 hours of candidate time
Case or presentationStructuring a problem and communicating a recommendationExecution detail45–60 min
Panel or final roundSeveral competencies in one visit; cross-functional viewsAnything already assessed well2–4 hours
ReferencesPatterns over time, confirmed by people who saw the workAnything the candidate chose the referees to praise2 × 20 min

For take-home work, the scoring and time limits in how to evaluate a take-home assignment keep it fair.

The coverage matrix

The core of the template is a grid with competencies down the side and stages across the top. Mark P where a competency is primarily assessed and C where it is checked. Every must-have needs exactly one P; a row with no P is a gap, and a column with no P is a stage you can cut.

COVERAGE MATRIX — [role]
                        Screen   HM interview   Work sample   Panel   References
Competency 1 (must)     C        P              .             .       .
Competency 2 (must)     .        .              P             C       .
Competency 3 (must)     .        C              .             P       .
Competency 4 (must)     .        .              .             P       C
Competency 5 (nice)     .        P              .             .       .
Logistics / pay fit     P        .              .             .       .

The interview process template

INTERVIEW PROCESS — [role, level]
Hiring manager: [ ]   Recruiter: [ ]   Last reviewed: [date]

COMPETENCIES (from intake)
Must-have: 1. [ ] 2. [ ] 3. [ ] 4. [ ]
Nice-to-have: 5. [ ]
Deal-breakers: [ ]

STAGES
#  Stage            Format        Length  Interviewer(s) + backup   Assesses (P/C)   Pass rule
1  [Screen]         [phone/video] [30m]   [ ]                       [ ]              [ ]
2  [ ]              [ ]           [ ]     [ ]                       [ ]              [ ]
3  [ ]              [ ]           [ ]     [ ]                       [ ]              [ ]
4  [ ]              [ ]           [ ]     [ ]                       [ ]              [ ]
5  References       [call]        [2x20m] [ ]                       [ ]              [ ]

RULES
Feedback due: [within 24 hours of each stage], written before discussing
Scoring: [1–5 scale with anchors, per competency]
Debrief: [within 2 business days of final stage]; decision by [role]
Candidate time, total: [hours]   Calendar time, screen to offer: [weeks]

CANDIDATE-FACING SUMMARY (sent after the screen)
[Stage names, length, format, who they will meet, when they will hear back]

ACCOMMODATIONS
[How candidates request adjustments, and who handles them]

Example 1: account manager (mid-level)

Must-haves: 1. Growing existing accounts. 2. Running a clear customer conversation. 3. Handling an unhappy customer. 4. Organized follow-through across many accounts.

StageLengthAssessesPass rule
Recruiter screen25 minLogistics, pay fit; checks 1Has managed a book of accounts; range fits
Hiring manager interview45 minP: 1 (past expansions, with numbers); C: 4At least 3 of 5 on competency 1 with a specific example
Role-play: renewal call with a pricing objection45 minP: 2 and 3At least 3 on both, scored by two observers
Peer interview30 minP: 4 (how they track work); C: 3Describes a real system, not intentions
References2 × 20 minC: 4No pattern of dropped follow-ups

Candidate time: about 2.5 hours. Calendar target: 3 weeks from screen to offer.

Example 2: backend software engineer (senior)

Must-haves: 1. Designing services that hold up at scale. 2. Writing maintainable code. 3. Debugging production problems. 4. Leading technical decisions with other engineers.

StageLengthAssessesPass rule
Recruiter screen30 minLogistics, pay fit, scope of recent workHas owned a production service
Engineering manager interview45 minP: 4 (past technical decisions and disagreements)At least 3 with a concrete example
Paired coding on a realistic task75 minP: 2; C: 3At least 3 on code quality from both engineers
System design60 minP: 1At least 3 on trade-off reasoning
Incident walk-through: a real past outage, anonymized45 minP: 3At least 3 on method, not just the answer
References2 × 20 minC: 4Confirms leadership examples

Candidate time: about 4.5 hours, delivered as a screen, one manager call, and a half-day final with three sessions. No take-home, because the paired session covers code quality.

Checks before the process goes live

  • Every must-have has exactly one primary stage.
  • No stage exists only because "we always do one".
  • Each stage has a named interviewer and a backup, and the interviewers are trained on the scorecard; a short calibration session before the first candidate helps.
  • The pass rule for each stage is written before the first candidate.
  • Total candidate time is stated and proportionate to the role.
  • Feedback deadlines and the debrief date are set.
  • The candidate-facing summary matches what will actually happen.
  • There is a clear route for accommodation requests.

Running the process consistently

The design only helps if each stage asks its assigned questions and records evidence for its competencies. Give interviewers the coverage matrix along with their guide, so they know what not to ask as well as what to ask. Where interviewers take notes with a tool, Interview Signal shows the stage's question guide during the call and ticks off questions as they are covered, which helps each stage stay on its own competencies. Without a tool, a printed guide with checkboxes does the same job; see structured interviews without an ATS.

Collect written feedback before the debrief, not during it, so the first opinion spoken does not shape the rest. The interview debrief template runs the discussion one competency at a time.

Common design mistakes

MistakeWhat it causesFix
Stages copied from another roleCompetencies that matter here go untestedStart from this role's competencies
Every interviewer asks "tell me about yourself" and a favorite questionOverlap, and gaps nobody noticesA coverage matrix with one primary stage per competency
The most expensive stage firstHours of team time on candidates who fail basic must-havesCheap stages first
No written pass ruleDecisions based on overall impressionA minimum score per competency at each stage
Adding a stage when the team is unsureLonger process, same uncertaintyImprove the stage that should have produced the evidence
Process never reviewedStages that predict nothing stay foreverReview after each hire: which stage's scores matched the hire's performance

Questions people ask

How many stages should an interview process have?

As few as it takes to assess each must-have competency once, with evidence. For many roles that is a screen, one or two interviews and a work sample or final round. Add a stage only when it assesses something no other stage does; a stage that repeats earlier questions adds candidate time without adding information.

What is the difference between an interview process and an interview guide?

The process is the design: which stages exist, in what order, who runs them and what each one decides. The interview guide is the content of one stage: the questions, follow-ups and what good answers look like. Design the process first, then write a guide for each stage.

Should every candidate go through the same interview process?

Yes, for the same role. Consistent stages, questions and scoring make candidates comparable and make the process fairer and easier to defend. Accommodations for disability and scheduling flexibility are adjustments to how a stage is delivered, not a different process.

Where should a take-home assignment go in the process?

After at least one conversation, so only candidates with a real chance spend hours on it, and before the final round, so the final can discuss the work. Keep it short, tell candidates how long it should take, and score it against a rubric written before the first submission arrives.