NEUROPATH

-Don’t just score the candidate, build their learning path.

Comment

Inspiration

Hiring today is broken on both sides. Candidates upload resumes that get swallowed by black-box Applicant Tracking Systems (ATS), while hiring managers spend hours reading through vague job descriptions. Most existing tools only answer one simple question: "Does this candidate fit?" by returning an arbitrary fit score $S \in [0, 1]$.

We wanted to answer a much more practical question: "How do we get this candidate role-ready?"

We built Neuropath to bridge the gap between static skill matching and dynamic onboarding. Instead of treating keyword misses as rejections, we saw an opportunity to convert skill gaps into a structured, executable roadmap for growth.

What it does

Neuropath is an adaptive onboarding intelligence platform that converts unstructured resumes and job descriptions into personalized, DAG-based learning roadmaps.

  • Dual-Source Skill Extraction: Extracts skill inventories from candidate resumes ($R$) and job descriptions ($J$).
  • Semantic Skill Normalization: Maps skill variants to canonical forms (e.g., mapping React.js $\rightarrow$ React or recognizing that PostgreSQL satisfies a broader SQL requirement).
  • Hierarchy-Aware Gap Analysis: Computes true skill missingness without relying on superficial keyword checks.
  • Adaptive Graph Planning: Structures missing skills onto a Directed Acyclic Graph $G = (V, E)$ to compute a topological learning sequence.
  • Explainable Reasoning: Displays evidence directly from the job description to justify why each missing skill matters.
  • Interactive Dashboard: Visualizes skill dependencies using a React Flow graph alongside a step-by-step learning timeline.

How we built it

We designed Neuropath using a hybrid architecture that pairs flexible AI with deterministic graph planning:

1. Hybrid Extraction & Weighting

We pass unstructured text through Gemma 3 via API to extract JSON skill arrays. To weight skill urgency in the job description, we calculate a weighted importance score $W(s)$ for each extracted skill $s$:

$$W(s) = \alpha \cdot \text{Freq}(s) + \beta \cdot \text{PosWeight}(s) + \gamma \cdot \mathbb{I}_{\text{required}}(s)$$

where $\mathbb{I}_{\text{required}}(s) \in {0, 1}$ flags critical requirements (e.g., "must have", "hands-on").

2. Embedding-Assisted Normalization

For ambiguous skills, canonical matching is fallback-resolved using cosine similarity on sentence-transformers embeddings ($e_s$ and $e_c$):

$$\text{Sim}(s, c) = \frac{e_s \cdot e_c}{|e_s| |e_c|}$$

If $\text{Sim}(s, c) \ge \theta_{\text{threshold}}$, the skill is mapped to the canonical node $c$.

3. DAG Pathing Algorithm

Let $V_{\text{missing}} \subset V$ be the set of identified skill gaps. We expand $V_{\text{missing}}$ with their required prerequisite nodes $P(v)$ to form the full graph subgraph $G' = (V', E')$. The exact learning sequence is computed via topological sorting:

$$\text{Indegree}(v) = 0 \implies v \text{ is ready to learn}$$

4. Full-Stack Tech Stack

  • Backend: Built with Python, Flask, pypdf, and python-docx.
  • AI / NLP: Gemma 3 via Google Generative AI API, sentence-transformers (all-MiniLM-L6-v2), and PyTorch.
  • Frontend: Developed in Next.js 14, React 18, TypeScript, Tailwind CSS, React Flow, and Framer Motion.
  • Deployment: Containerized using Docker and Docker Compose.

Challenges we ran into

  • Preventing LLM Hallucinations in Pathing: Relying strictly on generative AI for ordering prerequisite chains led to cyclical dependencies. We solved this by constraining Gemma 3 strictly to parsing and reasoning, while keeping path topological sorting entirely deterministic using graph algorithms.
  • Multi-Stage Skill Normalization: Technical terms vary widely across candidate documents. Establishing a robust fallback cascade—exact alias resolution $\rightarrow$ taxonomy hierarchy lookup $\rightarrow$ embedding similarity thresholding—required careful tuning to avoid false positive matches.
  • State Management for Dynamic Graphs: Synchronizing backend DAG metrics directly with React Flow interactive visual nodes while maintaining high UI performance.

Accomplishments that we're proud of

  • Successfully combining flexible generative AI (Gemma 3) with deterministic DAG algorithms to achieve speed, auditability, and zero hallucination in learning paths.
  • Building a hybrid skill extraction pipeline that gracefully handles complex, messy resume formats.
  • Creating an intuitive, visual interface that turns dense talent data into clear learning timelines.

What we learned

  • How to architect AI software where Large Language Models handle unstructured semantic understanding while classical code handles structured logical planning.
  • Practical application of embedding cosine similarity, taxonomy trees, and directed acyclic graph algorithms in automated career reskilling.

What's next for Neuropath

  • Public Dataset Benchmarking: Validating extraction precision against standard datasets like O*NET ontologies and Kaggle job corpora.
  • Dynamic Skill Assessments: Adding quick diagnostic checks to each DAG step so candidates can test out of prerequisites they already know.
  • Enterprise LMS Integration: Enabling one-click export to enterprise learning systems for personalized employee onboarding.

Built With

Share this project:

Updates