9- How to Score Candidate–Role Matches Without Bias

For: placement coordinators and workforce teams matching trained, credentialed candidates to open requisitions.

Why: matching by hand is the application-review bias problem all over again — every coordinator weighs requirements differently, the reasoning never gets written down, and re-scoring a hundred pairs after a rubric change is work nobody does.

Outcome: every candidate–requisition pair scored against the requirements checklist on arrival — banded strong / partial / not-qualified, coachable gaps separated from hard fails, every call pinned to evidence — and the whole pool re-scored the moment you tune a weight.

This is Chapter 9 of the Case Intelligence series, the second demand-side chapter. In Chapter 8 you turned every job description into a structured requirements checklist, each item flagged HARD (disqualifying) or COACHABLE (trainable before the start date). This chapter is where that checklist earns its keep: it meets the candidate pool, and every pairing gets scored against it by one rubric.

The running example stays the same: RiseWorks Foundation / Pathways 2027 (Train → Match → Place → Earn). Its 58 credentialed candidates, lined up against the open requisitions in the Job Requisitions store, produced 108 candidate–requisition pairs. Scored on one rubric, the pairs banded 20 strong / 51 partial / 37 not-qualified, and the funnel narrowed to 29 placed. Those bands — and the supply/demand gap hiding behind them — are what this chapter builds.

As in every chapter, each step is tagged [DIY] or [SENSE], because this article is honest about what you can do yourself with any AI and what needs Sopact Sense. Designing the match rubric and scoring one pair by hand work in any chat window, today. Scoring all 108 pairs on arrival, and re-scoring all of them when a weight changes, is what the product does over the stores — a standalone prompt cannot score pairs it never receives, and it cannot re-score a pool it doesn’t hold.

Matching by hand is the review committee, relocated

Chapter 2 opened with a review committee: five reviewers, five private rubrics, scores that looked comparable and weren’t. Matching candidates to roles is the same failure moved to the other end of the program — and it usually gets less scrutiny, because by placement time everyone is in a hurry.

Watch what hand-matching actually does. A coordinator holds a candidate in one hand and a requisition in the other and forms an impression. One coordinator treats a missing OSHA 30 as disqualifying; another reads the requisition’s “we’ll train” and waves it through. One reads a felony as a hard stop on every role; another checks whether this particular employer is second-chance friendly. The candidate’s outcome depends on who picked up the file — and because none of the reasoning is written down, none of it can be audited. That is reviewer variance again, and at 108 pairs it compounds: no human scores pair #97 by the same standard they scored pair #3, before lunch, three weeks ago.

Then there is the problem that makes the bias permanent. Suppose mid-cycle you realize work authorization should weigh more, because citizen-only requisitions keep falling through late. To fix that honestly you would re-score every pair already reviewed. Nobody re-scores 108 pairs by hand, so the weights ossify — or drift silently from coordinator to coordinator, which is worse.

Traditional case management — the CRM-based tracking suites and grantee-management platforms most programs run on — gives you a list of candidates and a list of roles and leaves the pairing to judgment. Sopact Sense treats the pair itself as a record. The candidate’s credentials live in the Exit/Completion store, the role’s checklist lives in the Job Requisitions store, and the two join on reference keys (email, requisition_id) — centralization by keys, not by merging spreadsheets. An Intelligent Cell scores each pair against the checklist the moment the pair forms; when you tune a weight after the first five or ten pairs, the entire pool re-scores automatically. Same no-bias logic as application review: one rubric, applied on arrival, every score carrying its evidence. A human still verifies and can override — with the reasons in front of them.

Step 1 — Turn the checklist into a match rubric [DIY]

What you do. Decide how the Chapter 8 checklist becomes a 0–100 match score: which requirements carry the most weight, and — the part that keeps the score honest — which are hard fails that cap the score no matter how strong the rest of the candidate looks. Feed your checklist categories to any capable AI and draft the rubric by hand. This is thinking work, not product work, and you should own it.

What you get. One rubric: a weight per requirement category, a hard-fail cap rule, and band definitions written as mechanical rules, so two strangers scoring the same pair land on the same band.

Why it matters. The rubric is the thing applied identically to every pair — it is what makes the scoring unbiased. And the hard-fail cap is what keeps a high score truthful: a candidate who is a brilliant welder but not work-authorized for a citizen-only role cannot ride everything else to an 85. A hard fail caps the score low and writes down exactly why.

Real example — RiseWorks. The rubric weights the checklist categories from Chapter 8:

And the bands are rules, not vibes — the band comes from the rules; the 0–100 score orders candidates within a band:

The one-line rule that does the most work: a gap is coachable only if it can be closed before the requisition’s start-by date; everything else is hard. OSHA 30 two weeks before a November 15 start is coachable. The same OSHA 30 four days before it is not.

Prompt 1: Match Rubric Builder

PROMPT 1 — MATCH RUBRIC BUILDER   [DIY]
Chapter 9 · Case Intelligence series · Sopact Academy
Use in: any capable AI (Claude, ChatGPT). You design this once, by hand.
Purpose: turn a requirements checklist (Chapter 8) into a weighted 0–100
match rubric with a hard-fail cap and mechanical band rules.

------------------------------------------------------------
You are a placement-rubric designer for a workforce program. Your job is to
turn a role-requirements checklist into a match rubric that two strangers
could apply to the same candidate–requisition pair and land on the same band.

TASK
From the requirements checklist I paste below, produce:

1. WEIGHTS — assign each requirement category a weight so that a
  candidate–requisition pair yields a 0–100 match score. State each weight
  as a number. The weights must sum to 100.
2. HARD-FAIL CAP RULE — name the requirements that CAP the score no matter
  how strong the rest of the candidate is. Use this fixed test:
  a requirement is a HARD FAIL when no coaching, training, or paperwork
  completed before the requisition's start-by date can satisfy it
  (examples: citizen-only work authorization not met; a required CDL not
  held; a strict-background role where the record conflicts).
3. COACHABLE RULE — a gap is COACHABLE only when it can be closed before
  the start-by date (example: OSHA 30, earnable in ~2 weeks, against a
  start date more than 2 weeks out). Coachable gaps are score deductions,
  never caps.
4. BAND RULES — write the three bands as mechanical rules, exactly this
  structure:
  - STRONG: every hard requirement met; at most one coachable gap,
    closable before the start-by date.
  - PARTIAL: every hard requirement met; coachable gap(s) remain.
  - NOT-QUALIFIED: any hard fail.
  The band comes from the rules; the 0–100 score orders candidates
  within a band.

INPUT — paste your requirements checklist between the markers:
<<<
[paste the Chapter 8 requirements checklist here — categories, values,
hard/coachable flags, and the start-by date field]
>>>

OUTPUT FORMAT
Return exactly three blocks, in this order:
A. Rubric table: Requirement | Weight | Hard-fail cap? (yes/no + condition)
B. The hard-fail cap rule and the coachable rule, one line each.
C. The three band rules, verbatim in the structure above.

RULES
- Use only the requirements in my checklist. Do not invent categories,
 certifications, or requirements that are not in the input.
- Every weight is a number; the weights sum to 100.
- The coachable/hard test is the start-by-date test above — apply it
 mechanically, no exceptions and no judgment calls.
- The same input must give the same output every run. If something in my
 checklist is ambiguous, say AMBIGUOUS and ask, rather than guessing.
------------------------------------------------------------

Step 2 — Score one pair by hand [DIY]

What you do. Before trusting the rubric with a pool, run one real candidate against one real requisition in any AI chat: compute the score, name the band, list the coachable gaps with their fix and timeline, and name any hard fail. This is your calibration run — still fully DIY.

Here is a real pair. The candidate is Marcus D., who earned his AWS D1.1 at exit (Chapter 5). The requisition is the MIG Welder Apprentice role whose checklist Chapter 8 extracted:

Candidate — Marcus D.: AWS D1.1 credential earned · work-authorized · valid driver’s license (no CDL) · clean background · missing OSHA 30

Requisition — MIG Welder Apprentice (regional fabrication shop): requires AWS D1.1 · work-authorized · valid license, no CDL · clean background for site access · OSHA 30 preferred — “we’ll train” · start by Nov 15

Apply the rubric and the shape of the output appears. Every hard requirement is met — credential, work authorization, license, background, all clear against the checklist. The single gap, OSHA 30, is coachable on the rule: it can be earned in about two weeks, well before November 15, and the requisition itself says “we’ll train.” No hard fail, one closable gap: the pair lands in the strong band, with the note “needs OSHA 30 — 2-week fix, before the Nov 15 start.”

Now check the rubric against your gut, because this is when a mis-built rubric is cheap to fix. If a coachable gap is capping the score like a hard fail, or a hard fail is not capping, you have found it on one pair instead of after 108 bad scores. Fix the rubric, not the individual score.

Prompt 2: Score One Pair

PROMPT 2 — SCORE ONE PAIR   [DIY]
Chapter 9 · Case Intelligence series · Sopact Academy
Use in: any capable AI (Claude, ChatGPT). Your calibration run — score one
real candidate against one real requisition before trusting the rubric
with a pool.
Purpose: validate that hard fails cap, coachable gaps deduct, and the band
rules behave.

------------------------------------------------------------
You are scoring one candidate against one role's requirements checklist,
using the match rubric I provide. Apply the rubric mechanically — your job
is consistency, not generosity.

TASK
1. Check the candidate against EVERY item on the checklist. For each item,
  state: met / gap, and quote the exact candidate fact or checklist line
  that decides it.
2. Compute the 0–100 match score using my weights.
3. If any HARD FAIL is unmet (per the rubric's cap rule), CAP the score and
  name the requirement that caps it.
4. List every COACHABLE gap with its fix and rough timeline, and test each
  against the start-by date (example: "OSHA 30 — ~2-week fix — start-by
  Nov 15 — closable in time").
5. Assign the band by the mechanical rules:
  STRONG = all hard requirements met, at most one coachable gap closable
  in time · PARTIAL = all hard met, coachable gap(s) remain ·
  NOT-QUALIFIED = any hard fail.
6. CALIBRATION CHECK — if the score behaves wrong (a coachable gap capping
  like a hard fail, or a hard fail not capping), say RUBRIC DEFECT and
  name the fix. The rubric gets fixed before scaling, not the score.

INPUTS — paste between the markers:
<<< RUBRIC
[paste your Prompt 1 output here]
>>>
<<< CANDIDATE
[paste one candidate record here — credentials, certs, license, work
authorization, background, availability]
>>>
<<< REQUISITION
[paste one role's requirements checklist here, including the start-by date]
>>>

OUTPUT FORMAT
Return exactly:
A. Item-by-item check: Checklist item | Met/Gap | Deciding evidence (quoted)
B. Score: the 0–100 number, and CAPPED + reason if a hard fail applies
C. Coachable gaps: gap | fix | timeline | closable before start-by? (yes/no)
D. Band: STRONG / PARTIAL / NOT-QUALIFIED, with the one rule that decided it
E. RUBRIC DEFECT line — present only if the calibration check fails

RULES
- Judge only against items in the checklist. Do not invent requirements,
 credentials, or facts about the candidate.
- Every met/gap call quotes the evidence that decided it.
- A gap is coachable ONLY if it closes before the start-by date; otherwise
 it is hard. No exceptions.
- The same input must give the same output every run.
------------------------------------------------------------

Step 3 — Score every pair on arrival [SENSE] — what Sopact Sense generates

From here on, this is product output, not a prompt you run. A chat prompt scores the one pair you paste into it. Sense holds the stores — credentialed candidates in Exit/Completion, checklists in Job Requisitions, joined on email and requisition_id — so pairs form as requisitions open and candidates credential, and the rubric fires on each pair the moment it exists. Pair #1 and pair #108 are scored by the identical standard, and nobody pastes anything.

Two mechanisms do the work. An Intelligent Cell on the pair computes match_score_0to100 against the checklist, applies the hard-fail cap, splits the unmet requirements into coachable versus hard fail, and sets a fee-at-risk flag from retention signals — so a shaky match never reads as guaranteed placement revenue (that flag matters again in Chapter 10b). An Intelligent Row then assembles the pair into one Match Profile. Here is Marcus’s, as Sense generates it:

INTELLIGENT ROW — Match Profile · Marcus D. × MIG Welder Apprentice

Band: STRONG · one coachable gap · no hard fail · fee-at-risk: low. Action: enroll Marcus in OSHA 30 this week; confirm the seat with the employer.

Read what the split is doing. “Not qualified yet” has become two different sentences: develop him — the fix is two weeks is a plan, and this role is citizen-only and he is not — hard fail is an honest structural no with the reason attached. In a hand-matched pipeline both of those collapse into a silent pass-over that nobody can audit later.

And the tuning loop closes here. When RiseWorks raised the weight on work authorization after its first handful of pairs, all of the scored pairs — and every pair that formed afterward — re-scored against the new rubric at once. Bands shifted together, consistently, with no coordinator-by-coordinator drift. That is the honest version of recalibration, and it is the thing hand-matching structurally cannot do.

Prompt 3 — Match Scoring on Arrival

PROMPT 3 — MATCH SCORING ON ARRIVAL   [SENSE]
Chapter 9 · Case Intelligence series · Sopact Academy
This is product configuration — it runs on arrival in Sopact Sense, not in
a chat window. A chat prompt scores the one pair you paste; Sense holds the
stores (Exit/Completion for candidates, Job Requisitions for checklists,
joined on email and requisition_id), so every pair is scored the moment it
forms — and re-scored pool-wide when you tune a weight.

------------------------------------------------------------
WHERE IT SITS
An Intelligent Cell on the candidate–requisition pair record. Inputs: the
candidate's credential and eligibility fields (from Exit/Completion) and
the requisition's structured checklist with hard/coachable flags and
start-by date (from Job Requisitions, extracted in Chapter 8).

THE CELL'S INSTRUCTION
For this candidate–requisition pair, against the requisition's checklist:
1. Check every checklist item; record met / gap with the deciding evidence.
2. Compute match_score_0to100 with the program's weighted rubric.
3. Apply the HARD-FAIL CAP: citizen-only work authorization unmet, a
  required CDL not held, a strict-background conflict, or any gap not
  closable before the start-by date → cap the score and write the reason
  to the unmet-requirements field.
4. Split remaining gaps into COACHABLE ("OSHA 30 — 2-week fix") vs HARD
  FAIL ("citizen-only — not met"); write both lists to the pair record.
5. Assign the band by the mechanical rules: strong / partial /
  not-qualified.
6. Set a FEE-AT-RISK flag from retention signals, so a shaky match does
  not read as guaranteed placement revenue.

THE ROW'S ASSEMBLY (Intelligent Row — Match Profile)
One per-pair report, assembled from the Cell outputs:
 header: candidate × requisition · band · match_score · fee-at-risk
 body:   the item-by-item checklist table with evidence per call
 footer: the recommended action (development step with deadline, or the
         honest structural no with its reason)

SAMPLE RETURN (real pair — Marcus D. × MIG Welder Apprentice)
 AWS D1.1 (HARD)            met — credential earned at exit
 Work authorization (HARD)  met — role not citizen-only
 Valid license, no CDL      met
 Clean background (HARD)    met — site-access requirement
 OSHA 30 (COACHABLE)        gap — ~2-week fix; "we'll train"; start Nov 15
 Availability by Nov 15     met — coachable gap closes in time
 BAND: STRONG · one coachable gap · no hard fail · fee-at-risk: low
 ACTION: enroll in OSHA 30 this week; confirm the seat with the employer.

WHY THIS CAN'T BE A CHAT PROMPT
The pairs live in the stores. RiseWorks' 108 pairs formed as requisitions
opened and candidates credentialed; each was scored on arrival by the same
rubric, and when a weight changed, all 108 re-scored at once. A standalone
prompt has no store, no other pairs, and no way to re-score a pool it
never held.
------------------------------------------------------------

Step 4 — Read the whole pool [SENSE] — what the Assistant does over the stores

The second thing a standalone prompt cannot do: rank 108 pairs it doesn’t have. The Sopact Assistant (with the Claude MCP connection) works over the match records directly — every pair already carries its on-arrival score, band, and gap split, so pool-level questions are answered in plain language, in seconds.

Asked to read RiseWorks’ pool, the Assistant returns four things.

The funnel, banded. 108 pairs → 20 strong / 51 partial / 37 not-qualified. A candidate is placed when the score clears the threshold, a seat is open, and they accept — which is how the funnel narrows to 29 placed. Every band assignment is auditable back to the checklist item that produced it.

The development pipeline. The 51 partials are the richest list in the pool. The ones whose only gap is coachable — an OSHA 30, a forklift cert, a scheduling fix — are near-misses one short intervention away from strong. Hand-matched pipelines pass these candidates over silently; surfaced, they become a development list with a fix and a deadline per name.

The supply/demand gap. Because both sides are structured, the Assistant can say precisely where matching fails for structural reasons:

Neither of those is visible while requirements sit in prose and matching lives in coordinators’ heads. Twenty-five unfilled requisitions next to twenty-nine surplus candidates is not a paradox — it is the program’s next two strategic decisions, stated as data.

The what-if, before you commit. Ask “what if credential match weighs more?” and the Assistant shows which of the 108 pairs change bands and which checklist item moved them — before you adopt the change. Borderline pairs route to a human with the gap list attached, and the human can override any call with the evidence in front of them and a reason on record. Unbiased doesn’t mean unhuman; it means the human starts from one standard instead of several private ones.

Prompt 4 — Pool, Near-Misses, and the Gap

PROMPT 4 — POOL, NEAR-MISSES, AND THE GAP   [SENSE]
Chapter 9 · Case Intelligence series · Sopact Academy
Run this in the Sopact Sense Assistant over your store. The Assistant
(with the Claude MCP connection) reads every scored pair — a standalone
prompt cannot rank 108 pairs it doesn't have.

------------------------------------------------------------
ASSISTANT PROMPT A — the banded funnel
"Across all scored candidate–requisition pairs, show the funnel: total
pairs → strong / partial / not-qualified → placed (score clears threshold
AND a seat is open AND the candidate accepts). For each band, name the
checklist items that most often decided it."

WHAT IT RETURNS (RiseWorks):
 108 pairs → 20 strong / 51 partial / 37 not-qualified → 29 placed.
 Not-qualified clusters on two hard fails: citizen-only work
 authorization and required CDLs. Every band call is auditable back to
 the checklist item that produced it.

ASSISTANT PROMPT B — the development pipeline
"List the partial matches whose ONLY gap is coachable — fixable before the
requisition's start-by date. For each: candidate, role, the gap, the fix,
and the deadline."

WHAT IT RETURNS (RiseWorks):
 The near-miss development list from the 51 partials — candidates one
 short cert or scheduling fix away from strong (the OSHA-30-shaped gaps),
 each with a fix and a date. These are the placements hand-matching
 silently passes over.

ASSISTANT PROMPT C — the supply/demand gap
"Across open requisitions and credentialed candidates, show where matching
fails structurally: which hard requirements leave requisitions unfilled,
and which tracks have surplus candidates."

WHAT IT RETURNS (RiseWorks):
 25 requisitions stay unfilled — clustered on citizen-only work
 authorization and CDL licenses the program doesn't train for — while
 29 credentialed candidates are surplus (more welders and CNAs than open
 seats this quarter). One side points at recruiting/curriculum; the
 other at opening new employer demand.

ASSISTANT PROMPT D — the what-if
"If I change this weight [name it], show which pairs change bands and
which checklist item moved them — before I adopt the change."

WHAT IT RETURNS (RiseWorks):
 A before/after across all 108 pairs — bands shift together,
 consistently, and you see the consequence of the tuning before you
 commit. Borderline pairs route to a human with the gap list attached;
 overrides are recorded with a reason.
------------------------------------------------------------

Common mistakes (and what to do instead)

Letting instinct set the weights. If the rubric lives in a coordinator’s head, every coordinator has a different one, and the candidate’s outcome depends on who picked up the file. Write the weights and the hard-fail list down once, and apply them to every pair — that single act removes most of the variance.

Treating a coachable gap like a rejection. “Needs OSHA 30” is a two-week development plan, not a no. A pipeline that discards every imperfect candidate throws away its partial band — 51 of RiseWorks’ 108 pairs — which is where most placements actually come from.

Letting a strong candidate rescue a hard fail. The temptation runs the other way too: a brilliant welder scored 85 against a citizen-only role he cannot legally take helps nobody — least of all the candidate, who loses weeks to a dead end. Cap hard fails without exception and write the reason to the record.

Tuning weights without re-scoring the pool. Change a weight mid-cycle and score only the new pairs against it, and you have two standards — early pairs judged one way, late pairs another. Either re-score everything (automatic in Sense) or don’t tune.

Reading “not-qualified” as a candidate failure. RiseWorks’ 37 not-qualified pairs cluster on citizen-only and CDL — structural mismatches, not training failures. That cluster is recruiting and curriculum intelligence. Treat it as a program signal, not 37 individual disappointments.

What you have now

Every candidate–requisition pair scored against the Chapter 8 checklist on arrival, banded strong / partial / not-qualified by mechanical rules, with coachable gaps separated from hard fails and a fee-at-risk flag on each. A development pipeline pulled from the partial band, a supply/demand gap stated precisely enough to act on, and a rubric you can tune knowing the whole pool re-scores together. All of it auditable, and all of it the input the capstone rolls up: the 29 placements this scoring produced are the outcome rows Chapters 10a and 10b turn into reports.

Why this works

Because one rubric runs on every pair the same way, matching is unbiased by construction — reviewer variance is zero because there is only one reviewer standard. Because scoring happens on arrival, pair #108 costs the same as pair #1, and the score exists before anyone is in a hurry. Because every band traces to a checklist item, any call can be audited or overridden in seconds. And because tuning re-scores the whole pool at once, the rubric improves without the matching becoming inconsistent. The skeptic’s one-liner: same rubric, every pair, on arrival — hard fails cap, coachable gaps become plans, and nobody’s outcome depends on who picked up the file.

The one thing to do this week

Take one open requisition’s checklist from Chapter 8 and score your credentialed candidates against it by hand, using Prompts 1 and 2. Mark each gap coachable or hard by the start-by-date rule. One scored role will show you two things you cannot currently see: the near-misses you are passing over, and whether your instinct-based matching would have survived an audit.

Video walkthrough (coming soon)

A screen-by-screen walkthrough — configuring the match Cell, watching Marcus’s pair score on arrival, and pulling the banded funnel and the 25-versus-29 gap from the Assistant — is in production. Check back on the Academy.

Who this is for

Placement coordinators holding a spreadsheet of candidates in one tab and a spreadsheet of roles in the other, matching by memory. Workforce programs whose placement rate depends on which staffer worked which employer. Anyone who has quietly passed over a candidate for a gap that was two weeks from fixed. If your matching process can’t survive the question “would a different coordinator have made the same call?”, this is the fix.

Score your matches in Sopact Sense — sopact.com/academy.

Next in the series: How to Turn a Cohort into a Funder Impact Report — the capstone. The placements this chapter scored join everything the series has collected, and the cohort rolls up into a cited report — first for funders, then (same data, investor lens) for investors.