CareerLens

Bridging the Gap Between Industry Demands and Graduate Skills Through AI-Powered Career Mapping and Personalized Learning Roadmaps.

Comment

About the Project: CareerLens

Inspiration

Every year, millions of engineering students graduate with strong foundational coursework but find themselves at a crossroads when transitioning into the tech industry. Traditional campus curriculum cycles move in years, while industry job descriptions evolve in months. Students frequently struggle with unanswered questions:

"Which specific technologies make me qualified for a Cloud or Machine Learning role?"

"How do my current skills mathematically measure up to real market expectations?"

"What should I learn next to maximize my employment readiness?"

Most available career guidance tools are either generic surveys with static recommendations or ungrounded generative AI chatbots prone to hallucinations. We were inspired to build CareerLens — a deterministic, data-grounded intelligence platform anchored in real occupational taxonomies (O*NET 31.0), live industry job demands, and rigorous mathematical models, augmented with Google Gemini AI for contextualized explanations.

What We Learned

  1. Deterministic Foundations vs. Generative Augmentation

We learned that user trust in career recommendations relies on explainable, deterministic mathematics. Generative AI should not guess match scores; rather, vector mathematics and occupational data should compute the core metrics, while Large Language Models (LLMs like Gemini) provide natural-language reasoning, mentoring, and study roadmaps.

  1. Occupational Data Standardization and NLP

Working with real-world datasets like O*NET 31.0 and unstructured job descriptions taught us the critical importance of canonical skill normalization. A candidate writing py, Python3, k8s, or postgres must map into canonical entities before computing similarity metrics.

  1. Modern Mobile and Cross-Platform Systems Engineering

Migrating from Flutter's legacy Android v1 embedding to the modern v2 embedding gave us deep insights into the Android Gradle Plugin (AGP 9.1+), Kotlin 2.4 compilerOptions DSL, and low-level build system mechanics across multi-drive operating system environments.

How We Built CareerLens

  1. High-Level Architecture

CareerLens is built as a modular two-tier architecture:

Backend Core: High-performance asynchronous REST API powered by FastAPI (Python 3.12), spaCy NLP, and SQLite (WAL mode).

Mobile Frontend: An Android application built with Flutter and Dart 3, adhering to a custom Material 3 Obsidian Neural dark design system.

+--------------------------------------------------------+ | Flutter Mobile App | | (Profile CRUD · Match Gauge · Gap Sheet · Roadmap) | +---------------------------+----------------------------+ | HTTP (http://10.0.2.2:8000) +---------------------------v----------------------------+ | FastAPI Backend | | * Skill Normalizer & spaCy NLP Extractor | | * Deterministic Cosine Similarity Engine | | * Priority Gap Analyzer & Roadmap Engine | | * Gemini 2.5 Flash Explainability Service | | * YouTube Data API v3 Learning Pipeline | +--------------------------------------------------------+

  1. Mathematical Formulations

A. Deterministic Career Matching via Cosine Similarity

To evaluate how closely a student's technical repertoire aligns with an industry target role, we represent both the student's profile and the career role as n-dimensional vectors in a shared skill space:

$$ \mathbf{u} = \big[u_1, u_2, \dots, u_n\big]^T \quad \text{(Student Skill Vector)} $$

$$ \mathbf{v} = \big[v_1, v_2, \dots, v_n\big]^T \quad \text{(Role Requirement Vector)} $$

Where:

$u_i \in [0, 5]$ denotes the student's self-assessed proficiency in skill $i$.

$v_i \in [1, 5]$ denotes the essential importance of skill $i$ defined in O*NET role taxonomy.

The overall Career Match Percentage is computed using the Cosine Similarity Metric:

\frac{\sum_{i=1}^{n} u_i v_i} {\sqrt{\sum_{i=1}^{n} u_i^2} \cdot \sqrt{\sum_{i=1}^{n} v_i^2}} $$

The final score displayed to the student is mapped to a bounded percentage:

$$ \text{Match Percentage} = \max\left(0.0, \, \min\left(100.0, \, \cos(\theta) \times 100\right)\right) $$

B. Skill Classification Threshold

Each required skill $s_i$ is categorized into one of three operational states using a dynamic threshold ratio $\alpha = 0.6$:

$$ \text{Status}(s_i) = \begin{cases} \textbf{Matched}, & \text{if } u_i \ge \alpha \cdot v_i \ \textbf{Developing}, & \text{if } 0 < u_i < \alpha \cdot v_i \ \textbf{Missing}, & \text{if } u_i = 0 \end{cases} $$

C. Skill Gap Prioritization Formula

To prevent students from feeling overwhelmed by long lists of missing competencies, we designed a Priority Impact Formula that balances role centrality with real-time market demand:

$$ \text{Priority}(s_i) = \text{Importance}(s_i) \times \text{DemandScore}(s_i) $$

Where:

$\text{Importance}(s_i) \in [1, 5]$ from O*NET taxonomy.

$\text{DemandScore}(s_i)$ is derived from mock job description frequency aggregation:

$$ \text{DemandScore}(s_i) = \begin{cases} 3, & \text{High Market Demand} \ 2, & \text{Medium Market Demand} \ 1, & \text{Low / Foundational Demand} \end{cases} $$

Missing skills are ranked in descending order of $\text{Priority}(s_i)$, ensuring that learning efforts yield the highest immediate hiring leverage.

  1. AI and Multi-Modal Resource Integration

Google Gemini 2.5 Flash: Translates raw similarity matrices into structured mentoring advice via endpoints such as /api/explain/match and /api/explain/roadmap.

YouTube Data API v3 & SQLite Cache: Fetches high-relevance, curated video tutorials for every missing milestone skill, featuring fallback heuristics for offline or network-limited operation.

Challenges Faced and Solutions

  1. Migrating from Deleted Flutter Android v1 to v2 Embedding

The Challenge: Flutter 3.47+ completely deprecated and deleted the legacy Android v1 embedding. The original application lacked modern Gradle build files (settings.gradle.kts, build.gradle.kts, gradlew), triggering the hard failure:

Build failed due to use of deleted Android v1 embedding.

The Fix: We rebuilt the entire Android wrapper using modern Kotlin DSL (.kts), configured dev.flutter.flutter-gradle-plugin, introduced MainActivity : FlutterActivity(), declared namespace = "com.careerlens.app" under AGP 9.1+, and updated manifest metadata to .

  1. Windows Cross-Drive Kotlin Cache Bug

The Challenge: When building the debug APK, the Kotlin compiler crashed with:

java.lang.IllegalArgumentException: this and base files have different roots: C:\Users...\Pub\Cache... and D:\Downloads...

The Fix: Because the global Pub cache lived on C: while the workspace was located on D:, Kotlin's default incremental compiler attempted to resolve relative paths across distinct Windows drive letters. We resolved this by explicitly configuring non-incremental compilation in gradle.properties:

kotlin.incremental=false kotlin.incremental.useClasspathSnapshot=false

  1. Material 3 Breaking Changes

The Challenge: A recent Flutter Material 3 update strictly separated CardTheme (a widget) from CardThemeData (a theme property), causing a compileFlutterBuildDebug failure in lib/main.dart.

The Fix: Refactored cardTheme: CardTheme(...) to cardTheme: CardThemeData(...), ensuring full zero-warning compatibility across Dart 3 and Flutter 3.47+.

The Result

A unified, data-grounded career mapping system validated with 92/92 automated unit and integration tests passing, running natively on Android with sub-second response times, and built to empower engineering graduates with actionable clarity on their path to tech careers.

Built With

Share this project:

Updates

Submission history