Capability Graph Engine

Turn candidate evidence into defensible hiring decisions.

CGE is an API for outsourcing firms, recruiting platforms, and hiring teams that need to rank engineers by proven capability, transferable depth, ramp speed, and source-aware trust.

Open HR workspaceGet API access
Current fit84%
Ramp speed79%
Trust82%

Strong match: demonstrated backend evidence, low-risk FastAPI transfer, and client-ready gap notes.

Why it matters

Keyword screens miss the candidates your clients would actually accept.

Find near-ready candidates that keyword screens reject

Separate code proof from resume claims and LinkedIn corroboration

Explain client submissions with strengths, gaps, and ramp paths

Keep evidence profiles separate from final match decisions

Commercial value

Built for teams that must shortlist quickly and justify every submission.

CGE answers the questions sales, recruiters, and technical stakeholders ask before a candidate reaches the client: can they do the job, how fast can they ramp, what proof exists, and what still needs validation?

Reduce false rejections

Rails, Django, Flask, FastAPI, React, Vue, and similar stacks are evaluated by transferable capability, not exact keyword overlap.

Protect client trust

Every score is backed by source authority, role relevance, gap severity, and a practical ramp explanation.

Rank at portfolio scale

Use org-scoped roles and candidate profiles to compare large pools without rebuilding the same evidence on every match.

Source-aware match demo

This is how CGE turns raw candidate sources into a shortlist decision.

Not a skill matcher. CGE reads role actions, separates source authority, computes fit, and explains why the candidate is ready, rampable, or risky for this specific client role.

Strong match

Demonstrated backend evidence with low-risk framework transfer.

Calibration v2026.05Severity scale 0-100
84%

Current fit

Credible fit on the role's central work, not broad profile overlap.

79%

Ramp speed

How quickly transferable capabilities reduce practical ramp cost.

82%

Trust

Reliability across demonstrated, claimed, and corroborated sources.

76%

Upside

Realistic expansion value without treating future potential as required.

Why This Decision

GitHub

Strong demonstrated backend ownership

Repository evidence supports service design, API implementation, debugging, and production-style maturity.

Transfer

Low-risk framework transfer

Django and REST API primitives reduce the ramp cost into FastAPI service work.

Resume

Resume supports client-facing seniority

Claimed ownership, review, and stakeholder collaboration reinforce the shortlist explanation.

Top Gaps

Rampable28/100

FastAPI-specific conventions

Python web experience transfers strongly, but direct FastAPI depth should still be validated.

Ask for one API design walkthrough or a short FastAPI pairing task.
Watch34/100

Incident ownership depth

Debugging is visible, but end-to-end production incident ownership is less explicit.

Use interview time on triage examples, observability, and post-incident decisions.
Rampable46/100

Kubernetes operations

Useful adjacent context for the environment, not a direct blocker for the current backend role.

Keep as a ramp plan item unless the client requires platform ownership.

Role Requirements by Work Area

Backend service core

Direct role behaviors from owning services, reviewing APIs, debugging, and evaluating tradeoffs.

  • Service Designdirect
    Demonstrated
  • API Designdirect
    Demonstrated
  • Debuggingdirect
    Demonstrated

Transferable stack depth

Framework and data-modeling primitives that make the missing exact stack rampable.

  • Django Patternstransferable
    Demonstrated
  • REST APItransferable
    Demonstrated
  • ORM Modelingtransferable
    Demonstrated

Client submission support

Evidence that helps recruiters explain fit while keeping validation needs visible.

  • Code Reviewdirect
    Claimed
  • Stakeholder Communicationadjacent
    Corroborated
  • Kubernetes Operationsadjacent
    Claimed

Transfer Paths

Django MVCFastAPI services

Improves ramp speed

ORM modelingPostgreSQL review

Reduces gap severity

Production debuggingIncident triage

Improves interview focus

Source Trust

GitHubHigh confidence

Demonstrated evidence receives the highest authority.

ResumeMedium confidence

Claimed evidence enriches the profile but does not override code.

LinkedInMedium confidence

Corroborates timeline and public profile continuity.

Workflow

Hook CGE into the evaluation path you already have.

1

Normalize roles once

Store a role_profile_id so every candidate is compared against the same direct, transferable, adjacent, and expansion requirements.

2

Build candidate profiles

Create reusable candidate_profile_id records from GitHub, resume PDFs or text, and user-supplied LinkedIn exports.

3

Run source-aware match

Use saved IDs or raw sources to compute current fit, ramp speed, strategic upside, trust, and final label.

4

Ship the shortlist

Return ranked decisions, recruiter-safe explanations, bounded gaps, transfer paths, and source summaries your team can defend.

Real-world API usage

Add CGE where hiring decisions already happen.

ATS and CRM enrichment

Attach CGE labels, source trust, strengths, gaps, and interview focus areas to existing candidate records.

Marketplace ranking

Rank submitted candidates by current fit, ramp speed, strategic upside, and confidence for each client role.

Audit and client review

Keep candidate evidence profiles, match audit rows, warnings, and source summaries available for later explanation.

API-first

Use profiles for evidence. Use source-aware match for decisions.

Register an account or create an organization-scoped API key. Decompose roles with /api/v1/roles, build candidate evidence with /api/v1/candidates, then call /api/v1/match/source-aware for the final score and explanation.

  • Fit label and overall score
  • Current fit, ramp speed, upside, and trust
  • Direct, transferable, adjacent, and expansion lanes
  • Source trust for GitHub/code, resume, and LinkedIn
  • Strengths, gaps, transfer paths, and interview focus
Request API accessOpen HR workspace
Recommended production flow
POST /api/v1/roles
Authorization: Bearer cge_live_...

{
  "title": "Senior Backend Engineer",
  "description": "Own Python services, APIs, debugging..."
}

POST /api/v1/candidates
{
  "candidate_ref": "ana-123",
  "candidate_repo_path": "https://github.com/ana/payments-api",
  "resume_text": "...",
  "linkedin_text": "..."
}

POST /api/v1/match/source-aware
{
  "role_profile_id": "role-uuid",
  "candidate_profile_id": "candidate-uuid"
}