Put two interviewers on the same candidate and ask them to score 'communication strength.' You'll get different numbers, different justifications, and no reliable way to compare them - because the criterion wasn't defined. That's the problem a competency framework for hiring solves: it gives everyone the same definition of 'good' before the first interview starts, written in terms that can actually be observed and scored.
What follows is a practical competency framework template you can adapt today, along with guidance on writing indicators that actually hold up under calibration.
TL;DR
Keep it to 6–8 competencies per role. More than that and your interview loop can't cover them reliably.
Write behavioral indicators, not qualities. 'Escalates blockers within a day' is scoreable. 'Is proactive' isn't.
Map each competency to evidence - a question, an assessment, a work sample. If there's no evidence, cut the competency.
What Is a Competency Framework for Hiring?
A competency framework for hiring is a list of the specific behaviors and knowledge that separate strong performers from average ones in a role - defined precisely enough that two interviewers evaluating the same candidate land within one scoring level of each other. It's not a job description, which describes what the role does. It's not a skills inventory, which tracks who can do what. It's the thing that tells interviewers what they're actually scoring.
Most guides on this topic or competency framework for talent acquisition describe competency frameworks for performance management or L&D. Those are built differently. A hiring framework has one additional constraint: every competency on it must be assessable within a short interview process. If you can't gather meaningful evidence for it in one or two structured questions, it doesn't belong on the list. For more on how this connects to competency-based interviewing as a broader methodology, that piece covers the research behind it.
The Anatomy of a Role-Specific Competency Framework
Before filling it in: the framework works in three layers. Some competencies apply across all roles - ownership, communication, judgment. Others are functional, shared by a team or discipline. The role-specific layer sits on top of those. Six to eight total per role is the ceiling that works in practice - not because of a rule, but because interview loops don't have time for more and the competencies at the bottom of a long list rarely get real coverage. If two competencies would generate the same question, they're the same competency. Merge them.
The Competency Framework Template
The role-specific competency framework template below has five columns. Here's what each one is doing:
Competency - the capability being assessed for building a competency framework. Named concisely, one thing per row.
Definition - what it means in this role. The same word - 'ownership' - means something different for a junior analyst than a senior manager. Make it role-specific.
Behavioral indicators - what it looks like when the competency is present (strong) and when it's absent or weak. Both matter. Without a weak indicator, interviewers have no anchor for anything below the top of the scale.
Evidence source - which interview question, assessment, or work sample will generate the evidence. If there's no source for a competency, it's not being evaluated - it's being guessed at.
Weight - how much this competency matters relative to others for this role. High / medium / low is sufficient. Not everything needs to be equally weighted.
Competency | Definition | Behavioral indicators | Evidence source | Weight |
|---|---|---|---|---|
Ownership | Sees an outcome through rather than stopping at task completion | Strong: names what they specifically did and the result. Weak: describes 'we' with no named personal contribution | Behavioral question + one follow-up probing their specific role | High |
Stakeholder communication | Gets complex information across to people who don't share the same background | Strong: adjusts the vocabulary and framing for who's in the room, unprompted. Weak: defaults to technical language or assumes the listener is keeping up | Structured question + ask them to explain a past project to a non-technical interviewer | Medium |
[ Add row ] |
Download the template as a Google Sheet / Excel file.
How to Write Behavioral Indicators That Interviewers Can Score
The most common error is writing adjectives instead of actions during assessing behavioral indicators for competencies. 'Proactive,' 'collaborative,' 'detail-oriented' - an interviewer scoring those has to first decide what the word means to them, then assess the candidate against that private definition. Two people doing this in parallel won't land in the same place. What works instead: specific observable actions, anchored in scope or frequency. 'Flagged a risk before the deadline, not after.' 'Asked two clarifying questions before starting the task.' Those can be scored. 'Is proactive' can't.
What makes an indicator work:
Observable actions, not adjectives. 'Escalates blockers within a day' is scoreable. 'Is proactive' requires an interpretation step that will vary.
Scope or frequency anchor. 'Manages stakeholder expectations without being asked' is stronger than 'manages stakeholder expectations.' The 'without being asked' part is what makes it a high indicator.
A weak-signal version, not just a strong one. What does low or absent look like? Without it, anything that isn't clearly excellent gets defaulted to 'average' - which collapses the middle of the scale into meaninglessness.
Calibratable. Two interviewers should score the same response within one level of each other using the indicator. If they're further apart than that, the indicator needs another revision pass.
Before: 'Is a strong communicator.' After: 'Adjusts explanation style when the first version isn't landing, without being prompted to do so.'
Competency Framework Examples by Role
For some competency framework examples by role, two role examples using the same structure. Ownership appears in both - that's the core layer. The role-specific competencies sit beneath it and wouldn't transfer cleanly to the other role.
Competency | Customer Success Manager | Software Engineer |
|---|---|---|
Ownership | Takes personal accountability for account health metrics, not just activity completed | Sees a bug through to resolution rather than handing it off at the edge of their scope |
Role-specific #1 | Discovery - uncovers unstated customer goals before proposing solutions | Systems thinking - explains how a component change affects the broader architecture |
Role-specific #2 | Resilience - keeps the quality of their next customer conversation steady after a difficult one | Technical communication - walks a non-technical stakeholder through a tradeoff so they can actually decide |
Learning agility - how fast someone picks up new approaches when old ones stop working - is worth adding as a third core competency for roles where the job will look different in twelve months than it does today.
Build It in 5 Steps
One process note before the steps: this work happens before the role is posted, not once candidates are already in the funnel. If interviewers haven't seen the framework before the first screen, calibration can't happen in time to matter.
Define success with the hiring manager and two or three people already doing the role well. The question isn't 'what does this job require' - it's 'what do strong performers in this role do that average ones don't?' That gap is where the real competencies are. Writing the framework from a job description alone produces a list of role requirements, not performance predictors.
Choose 6–8 competencies and write indicators for each. Work through the template columns: definition, strong indicator, weak indicator, evidence source, weight. Any competency mapping for recruitment you can't write an evidence source for gets cut - it's a hope, not an assessment criterion.
Map each competency to evidence. One structured question, work sample, role-play, or technical assessment per competency, minimum. This is where verified capability vs. self-reported skills plays out in practice - the evidence source is the mechanism that generates verification, not the resume claim that asserts it.
Calibrate. Before any live interviews, have two interviewers score the same sample answer independently. Compare. If they're more than one level apart on the same indicator, the indicator isn't specific enough. Fix it before the process starts, not after someone is in the funnel.
Review at least annually. Roles change. A competency that mattered when you wrote the framework might be irrelevant twelve months in. Build in a scheduled review - when the role changes significantly, or when quality-of-hire data suggests the framework isn't predicting performance well.
Putting the Framework to Work
Once the framework exists, it drives three things: structured interview scorecards (each interviewer rates the same competencies, not their general impression), interview question design (each competency gets at least one question with follow-up), and assessment selection (a skills test or work sample maps to the competencies it's meant to evaluate).
NaviHyr's Deep Assessment is built to score candidates directly against the competencies in your framework - using adaptive interviews that probe each one until sufficient evidence is gathered, rather than running every candidate through the same fixed question set. If you've done the framework work, the assessment can be calibrated to match it.
Conclusion
Clear competencies, observable indicators, mapped evidence sources. Those three things are what turn an interview from a conversation people compare notes on afterwards into a process that produces comparable, defensible data. A competency framework for talent acquisition isn't overhead - it's the infrastructure that makes structured hiring work.
Download the template to start, or see NaviHyr in action to watch the assessment layer run against a defined competency framework.
Download the competency framework template
See Deep Assessment - NaviHyr's competency-mapped interview engine!
