Most internal mobility programs die quietly. Nobody shuts them down. They just stop working, and nobody notices for two or three quarters because there's no scheduled moment where someone looks at the actual numbers. Open roles sit unfilled. Good internal candidates get rejected with vague reasons. Certain teams never get looked at. And by the time someone in leadership asks "why isn't internal mobility working," the trail is cold.
The fix isn't a dashboard somebody glances at once. It's a fixed monthly audit — same checks, same thresholds, same remediation steps — that HR can run without pulling a data scientist into every meeting. This kit covers the four things that actually break internal mobility: match rates, time-to-offer, manager rejection reasons, and adverse-impact flags. Each one gets a KPI, a query you can hand to your BI person, a red-flag threshold, and a specific thing to do when it trips.
Why monthly beats quarterly (and why "when we have time" means never)
Internal mobility problems compound in a way that's easy to miss. A matching rule that silently stopped surfacing candidates from a reorganized department doesn't announce itself. It just produces fewer and fewer internal shortlists, and recruiters quietly fall back to external hiring because "there weren't any internal people." Three months later the pattern looks permanent.
Monthly cadence matters because the signals are small and cumulative. A single manager rejecting internal candidates with "not a culture fit" isn't a scandal. The same manager doing it eleven times across two quarters, concentrated on candidates from one business unit, is something you can now name and act on. You only catch that if you're counting every month.
The other reason monthly works: remediation is cheaper when the drift is small. Fixing a taxonomy mismatch that's two weeks old is a config change. Fixing one that's been silently filtering candidates for six months means re-opening closed requisitions and explaining to people why they were never considered.
The four KPIs worth scheduling
Four metrics, what each one tells you, and the threshold where you stop watching and start fixing.
Stop losing track of critical skills.
Talioly helps you track, develop, and certify your workforce efficiently.
- Centralized skill profiles
- Automated training reminders
- Competency gap analysis
No credit card required
| KPI | What it measures | Healthy range | Red-flag threshold |
|---|---|---|---|
| Match rate | % of internal applications that produce at least one qualified shortlist match | 55–70% | Below 45%, or a drop of 15+ points month-over-month |
| Time-to-offer (internal) | Median days from internal application to offer | 18–30 days | Median above 40 days, or P90 above 70 days |
| Manager rejection reason distribution | % of rejections using vague/non-skill reasons | Under 20% vague | Over 35% vague, or one reason spiking |
| Adverse-impact flag | Selection rate parity across protected groups (4/5ths rule) | Ratios above 0.80 | Any group ratio below 0.80 |
The ranges aren't universal law — a company with a tight taxonomy and good skill profiles will run hotter match rates than one still cleaning up data. Set your own baseline in month one, then watch for movement against it. Absolute numbers matter less than sudden drift.
Match rate: the metric that quietly hides your best people
Match rate is the first thing to break and the hardest to notice, because low matches look like "no good internal candidates exist" rather than "our matching logic is broken."
What actually causes it. This usually happens when a taxonomy change, a reorg, or a renamed job family breaks the join between candidate skills and role requirements. Someone updates role codes in the HRIS, the matching rules still reference old codes, and the overlap silently drops to near zero for affected roles. Nobody edits the matching engine, so nobody suspects it.
A second common cause: skill profile staleness in one segment. If a department hasn't refreshed profiles in a year, their people stop matching anything new and that whole group quietly falls out of shortlists.
Here's a starting query to watch match rate by role family so you can spot a localized collapse instead of staring at a single company-wide average:
``sql
SELECT
r.rolefamily,
COUNT(DISTINCT a.applicationid) AS applications,
COUNT(DISTINCT CASE WHEN m.matchscore >= 0.70
THEN a.applicationid END) AS matchedapps,
ROUND(
100.0 * COUNT(DISTINCT CASE WHEN m.matchscore >= 0.70
THEN a.applicationid END)
/ NULLIF(COUNT(DISTINCT a.applicationid), 0), 1
) AS matchratepct
FROM internalapplications a
JOIN roles r ON r.roleid = a.roleid
LEFT JOIN matchresults m ON m.applicationid = a.applicationid
WHERE a.createdat >= datetrunc('month', currentdate - interval '1 month')
AND a.createdat < datetrunc('month', currentdate)
GROUP BY r.rolefamily
ORDER BY matchrate_pct ASC;
``
Sort ascending. The role families at the top of that list — the ones sitting at 10% match rates while the company average looks fine at 60% — are where your matching logic broke.
Remediation playbook for low match rate:
-
Pull the 10 lowest-matching role families from the query above.
-
For each, manually check 3 candidate-to-role pairs you'd expect to match. If a human can see the fit and the engine can't, it's a logic problem, not a supply problem.
-
Confirm role codes and skill taxonomy references line up between the HRIS and the matching rules. Broken joins show up here.
-
Check profile freshness for the affected candidate pool. If profiles are stale, the fix is a targeted revalidation, not a matching change.
-
If the matching thresholds themselves drifted (someone tightened
match_score >= 0.85), re-tune against a known-good set of historical successful placements.
A lot of this connects to how you've set up shortlisting in the first place. If you're relying on titles instead of verified skills, your match rate will look artificially low the moment titles stop mapping cleanly to actual work. The approach in shortlisting rules that match verified skills to internal vacancies without relying on titles is worth revisiting when match rates don't recover after a config fix.
Time-to-offer: where internal candidates get out-waited by external hires
Internal candidates lose roles to speed, not quality. An external applicant moves through a crisp funnel; an internal applicant gets stuck waiting on a current-manager conversation, a backfill question, or an approval nobody owns. The requisition stays open, an external hire comes through faster, and the internal person never hears a clear no.
A typical example: an internal application sits for nine days before the first screen because the recruiter is treating internal apps as lower priority than the external pipeline. Then it waits another twelve days on a "release conversation" with the current manager that nobody scheduled. The median time-to-offer creeps to 44 days. Meanwhile external offers go out in 21. The internal mobility program isn't losing on talent — it's losing on process latency.
Watch the stages, not just the total:
``sql
SELECT
stage,
COUNT(*) AS n,
ROUND(PERCENTILECONT(0.5)
WITHIN GROUP (ORDER BY daysinstage), 1) AS mediandays,
ROUND(PERCENTILECONT(0.9)
WITHIN GROUP (ORDER BY daysinstage), 1) AS p90days
FROM internalapplicationstagedurations
WHERE enteredstageat >= currentdate - interval '30 days'
GROUP BY stage
ORDER BY median_days DESC;
``
The stage with the ugliest P90 is your bottleneck. Nine times out of ten it's "awaiting current-manager release" or "awaiting approval." Those are process gaps, not talent gaps.
Remediation playbook for slow time-to-offer:
-
Put an SLA on each stage and measure against it, not against the total. "Current manager responds to release request within 5 business days" is enforceable; "move faster" is not.
-
Default the release conversation to a scheduled step at application, not something that gets improvised after a verbal offer.
-
Give recruiters a shared SLA for internal apps so they don't deprioritize them against external volume.
-
Escalate any application past the P90 threshold automatically — a weekly list of "stuck internal apps" sent to the mobility owner does most of the work.
This is exactly the kind of thing that falls apart when an internal marketplace gets treated like a passive job board instead of an operational service with actual owners and response times. The governance and matching-SLA framing in running your internal marketplace like an operational service pairs directly with time-to-offer monitoring.
Manager rejection reasons: the signal everybody ignores
Rejection reasons are a goldmine that most audits skip because the data is messy free-text. The pattern you're looking for is simple: vague, non-skill reasons concentrating in specific managers or against specific candidate sources.
"Not a culture fit." "Not quite ready." "Looking for something different." These aren't rejection reasons — they're the absence of one. When a manager rejects a verified-skill match with language that can't be checked against anything, that's where bias and lazy gatekeeping hide.
The useful version of this metric isn't "how many rejections" — it's what share of rejections reference an actual skill or requirement gap versus something with no measurable basis. You want the vague share trending down over time.
``sql
SELECT
managerid,
COUNT() AS totalrejections,
SUM(CASE WHEN LOWER(reason) ~ '(culture|fit|ready|different|chemistry|gut)'
AND LOWER(reason) !~ '(skill|experience|certif|requirement)'
THEN 1 ELSE 0 END) AS vaguerejections,
ROUND(100.0 SUM(CASE WHEN LOWER(reason) ~ '(culture|fit|ready|different|chemistry|gut)'
AND LOWER(reason) !~ '(skill|experience|certif|requirement)'
THEN 1 ELSE 0 END) / NULLIF(COUNT(),0), 1) AS vaguepct
FROM internalrejections
WHERE rejectedat >= currentdate - interval '30 days'
GROUP BY managerid
HAVING COUNT() >= 3
ORDER BY vague_pct DESC;
``
The regex is crude on purpose — it's a flag, not a verdict. A manager sitting at 70% vague rejections across a dozen decisions gets a conversation, not an accusation. Sometimes the reason really is legitimate and just badly recorded. Often it isn't.
Remediation playbook for vague rejections:
-
Require a structured rejection reason tied to a specific requirement or skill gap. Free-text can stay, but it can't be the only field.
-
For managers above the vague threshold, review their last 5 rejections against the candidate's verified profile. Look for cases where a qualified person was turned away without a checkable reason.
-
Feed back the data to the manager directly. Most people correct behavior when they see their own rejection pattern next to peers'.
-
Where vague rejections correlate with one candidate source — a specific team, location, or tenure band — escalate to the adverse-impact check below.
Worth keeping in mind: managers rarely reject people maliciously. They reject on instinct and backfill the reason. The structured-reason requirement works because it forces the instinct to become a claim, and a claim can be checked.
Adverse-impact flags: the check you cannot afford to skip
This is the one with legal and ethical weight, and it's the one most internal mobility programs never run until legal asks for it. The 4/5ths rule is the standard screen: if any protected group's selection rate falls below 80% of the highest group's rate, you have an adverse-impact flag that needs explaining.
Run this on internal mobility decisions specifically — shortlist-to-offer conversion — not just hiring overall. Internal mobility bias looks different. It shows up as certain groups applying but never advancing, or advancing but stalling at the manager-review stage.
``sql
WITH rates AS (
SELECT
grouplabel,
COUNT() AS applicants,
SUM(CASE WHEN outcome = 'offer' THEN 1 ELSE 0 END) AS offers,
1.0 SUM(CASE WHEN outcome = 'offer' THEN 1 ELSE 0 END)
/ NULLIF(COUNT(*),0) AS selectionrate
FROM internalmobilityoutcomes
WHERE decidedat >= currentdate - interval '90 days'
GROUP BY grouplabel
)
SELECT
grouplabel,
applicants,
offers,
ROUND(selectionrate, 3) AS selectionrate,
ROUND(selectionrate / MAX(selectionrate) OVER (), 3) AS impactratio
FROM rates
ORDER BY impactratio ASC;
``
Note the 90-day window, not 30. Adverse-impact math needs enough volume per group to mean anything. Running it on 30 days of data for small groups produces noise that swings wildly and triggers false alarms. Run the flag monthly, but on a rolling 90-day window.
Remediation playbook for an adverse-impact flag:
-
Confirm the group sizes are large enough to be meaningful. A ratio of 0.50 based on 4 applicants is not a signal.
-
Trace where the drop-off happens — application, shortlist, manager review, or offer. The stage tells you where to look.
-
If it concentrates at manager review, cross-reference with the vague-rejection query above. These two often light up together.
-
Document the analysis and the action regardless of outcome. "We checked, found X, did Y" is the record that matters if anyone asks later.
-
Loop in legal/compliance before interpreting borderline cases. This is not a metric to freelance on.
This is not a metric to freelance on.
A real scenario: a 1,200-person services firm
A professional services company with around 1,200 employees had an internal mobility program that looked fine on the surface — a marketplace, open roles, an application flow. Internal fill rate had drifted down over two quarters and nobody could say why.
When they ran the monthly audit, three things surfaced fast. Match rate for two role families had collapsed to roughly 12% after a job-family rename broke the taxonomy join — an easy fix, but it had been silently killing matches for about five months. Median internal time-to-offer was sitting near 41 days, almost all of it stuck in an unscheduled "current-manager release" step. And one department's candidates were advancing to manager review but getting rejected with vague reasons at roughly twice the rate of everyone else.
None of these were visible in the top-line fill rate number. They only showed up when the checks ran by role family, by stage, and by group. After fixing the taxonomy join, adding a release-conversation SLA, and giving two managers their own rejection data, internal offers over the next quarter went up — not dramatically, but enough that recruiters stopped defaulting to external pipelines for those families.
The whole diagnosis took one person about half a day a month. That's the actual cost of running this. It's not a big program. It's just a scheduled habit with the right four questions.
When this kit makes sense — and when it doesn't
Run this if you have at least a few dozen internal mobility decisions a month, structured data in an HRIS or ATS you can query, and an actual owner for the program. The audit only works if someone acts on the red flags.
Skip or simplify it if your volume is small — under maybe 20 decisions a quarter. At that scale, monthly SQL is overkill and you're better off reviewing every case by hand. The adverse-impact math especially will just produce noise.
This is a bad idea if nobody owns remediation. An audit that surfaces problems no one is accountable for fixing becomes a monthly reminder that things are broken, which is worse than not knowing. Assign the owner before you schedule the first run.
Setting it up so it actually runs every month
The failure mode for any audit kit isn't the queries — it's that it runs twice and then gets dropped when someone's busy. A few things keep it alive:
-
One owner, one calendar hold. Same person, same recurring slot. Not "the team."
-
Baselines from month one. Record your actual ranges before you trust the thresholds. Your healthy match rate might be 50%, not 65%.
-
A standing red-flag log. When something trips, write down the flag, the finding, and the action. This becomes your history and your compliance trail.
-
Automated stuck-item alerts between runs. The time-to-offer escalations and the rejection-reason flags don't have to wait for the monthly review — route them weekly to the owner so the slow stuff doesn't fester for 29 days.
The audit doesn't need to be fancy. Four queries, four thresholds, four playbooks, half a day a month.
Start with one role family or team to prove impact quickly before rolling the audit company-wide.
The audit doesn't need to be fancy. Four queries, four thresholds, four playbooks, half a day a month. What makes internal mobility work isn't a better algorithm — it's noticing, on a schedule, when the ordinary parts quietly stop doing their job.
The audit doesn't need to be fancy. Four queries, four thresholds, four playbooks, half a day a month. What makes internal mobility work isn't a better algorithm — it's noticing, on a schedule, when the ordinary parts quietly stop doing their job.
What makes internal mobility work isn't a better algorithm — it's noticing, on a schedule, when the ordinary parts quietly stop doing their job.
Ready to elevate your team's skills?
Join 500+ companies using Talioly to boost skill visibility, streamline training, and drive performance growth.