Design an interview loop as a competency-coverage matrix

Asked to "set up the interviews for role X", a base model lists rounds: phone screen, technical, onsite, culture fit, final. The rounds sound reasonable but overlap heavily — three of them quietly re-test "problem solving" and "communication" — while a competency the role actually depends on gets no dedicated signal. The loop is longer than it needs to be and still has holes.

Design the loop from the competencies, not from a count of rounds. Build a matrix, assign one owner per competency, and only then decide how many stages you have.

The method

1. List the must-have competencies first. What must this role be able to do? Name 3-6 concrete

competencies (e.g. coding, system design, debugging, cross-team collaboration, ownership). These are the rows of the matrix. Ignore how many interviews you think you want — that falls out later.

1. Give each competency exactly one owner stage. For every competency, pick the single stage

that produces the deciding signal on it. That stage is its primary owner. A stage may touch another competency in passing (a system-design round hears the candidate communicate), but only the owner's signal counts toward the hire decision on that competency. One owner per row.

1. Give each stage a distinct set of competencies and one defined signal. A stage exists to own

a set of competencies nothing else owns and to emit one output — a scorecard section, a go/no-go on its dimension. Write down what each stage's signal is.

1. Run the coverage check. Two failures to hunt for:

• Gap — a must-have competency with no owner stage. Assign it to a stage or add one.
• Overlap — a competency with more than one primary owner, or two stages whose competency

sets are near-duplicates. Merge the stages or move one competency so each has a single owner.

1. Prune redundant stages. A stage that owns no competency other stages don't already cover is

redundant — cut it or fold its unique piece into a neighbor. "Final round" and "culture fit" earn a slot only if they own a competency (e.g. values alignment, executive presence) nothing else tests. The right loop is the fewest stages that cover every must-have with one owner each.

Output shape

Produce the matrix (competencies down the side, stages across the top, one primary owner marked per competency), then per stage state the competencies it owns and its one signal, then the coverage check: list any GAP (uncovered competency) and any OVERLAP (competency owned by more than one stage, or duplicate stages) with the fix. If the loop is clean, say so explicitly — no gaps, no overlaps.

Don't invent competencies the ask didn't imply, don't grade a specific candidate, and don't write the questions inside each stage — that's a separate step. Design the loop; leave the interviews to the interviewers.

Worked example

> Role: backend engineer. Must-have competencies: coding, system design, debugging under > pressure, cross-team collaboration.

Matrix (one primary owner per row):

| Competency | Recruiter screen | Coding round | System-design round | Behavioral round | |-------------------------|:---:|:---:|:---:|:---:| | coding | | owner | | | | system design | | | owner | | | debugging under pressure| | owner (live-debug segment) | | | | cross-team collaboration| | | | owner |

Per-stage signal:

• Coding round — owns coding + debugging under pressure. Signal: a scorecard on code correctness

and how the candidate recovers when a test fails live.

• System-design round — owns system design. Signal: a scorecard on decomposition and trade-offs.
• Behavioral round — owns cross-team collaboration. Signal: STAR evidence of working across teams.

Coverage check: No gap — all four competencies owned. No overlap — each owned once. Note the loop dropped a generic "onsite culture fit" round the base model would have added: it owned no competency the behavioral round didn't already cover, so it was redundant. Four competencies, three signal-bearing stages plus the recruiter screen.

Counter-example the method catches: a loop with "technical phone screen", "onsite coding", and "take-home" all owning coding is three owners for one row — overlap. Collapse to one coding owner and reclaim two slots (or leave the role with a shorter loop).