-
The GAUGE landing page. Enter any target tech role, and our engine instantly scrapes live job boards to map real-world employer demand.
-
Instantly view live market demand mapped in a 3D WebGL space. Identify critical missing skills before applying to your next target role.
-
Input your current tech stack to dynamically recalculate your Readiness Score. Watch the 3D nodes turn green as you close the market gap
-
The complete GAUGE intelligence dashboard. Track your Readiness Score, monitor trending skill gaps, and explore interactively in real-time.
-
Stuck on a technical gap? Let Google Gemini AI instantly generate a personalized, week-by-week learning roadmap with curated tutorials.
Inspiration
Every student applies to jobs without knowing what they’re missing.
They get rejected — not because they lack ability, but because they’re blind to the gap between their skills and real market demand.
Job descriptions are noisy, inconsistent, and constantly changing. There is no single source of truth that tells you:
- what actually matters right now
- how much each skill matters
- how close you are to being job-ready
We built GAUGE to make that invisible gap visible — instantly, mathematically, and in real time.
What it does
GAUGE is a real-time skill demand radar for any career.
Enter a job role, and GAUGE analyzes live job postings to extract the most in-demand skills in the market. It then visualizes this as an interactive radar, where:
- Node size = how frequently a skill appears in real job listings
- Color = whether demand is rising, stable, or declining
- Overlay = your current skills vs market expectations
GAUGE then computes a personalized Readiness Score that tells you exactly where you stand.
For every missing high-impact skill, GAUGE generates a focused, step-by-step learning path using AI — so you know exactly what to do next.
GAUGE doesn’t just tell you what to learn — it shows you why it matters right now.
The Mathematics Behind the Readiness Score
To ensure the Readiness Score is not arbitrary, we formalized it using a weighted normalization model.
Let:
- $S_{req}$ = set of required skills extracted from job data
- $f_i$ = frequency of skill $i$ across all job listings
The weight of each skill is:
$$ W_i = \frac{f_i}{\sum_{k=1}^{|S_{req}|} f_k} $$
Let the user’s skill set be $U$, where:
$$ s_i = \begin{cases} 1, & \text{if } i \in U \ 0, & \text{otherwise} \end{cases} $$
The final Readiness Score $R$ is:
$$ R = \left( \sum_{i=1}^{|S_{req}|} W_i \cdot s_i \right) \times 100 $$
This ensures the score reflects real market value, not just the number of skills a user lists.
How we built it
We designed GAUGE as a fast, reliable system with a clear separation of concerns:
Frontend
- React + Vite for fast rendering
- Zustand for lightweight state management
- Custom interactive radar visualization (WebGL / Three.js)
Backend
- FastAPI for high-performance async processing
- Python-based pipeline for scraping and parsing job data
Data Engine
- SerpAPI to fetch real-time job listings
- Custom parsing logic to extract and normalize skill keywords
AI Layer
- Google Gemini API to generate structured learning roadmaps from detected skill gaps
Caching Layer
- Redis-based caching to reduce latency and handle API limits
- Preloaded datasets for demo reliability while preserving real data integrity
Challenges we ran into
1. Unstructured Data Parsing
Job descriptions are inconsistent and noisy. Extracting accurate skill signals required building robust normalization logic (e.g., distinguishing "Java" vs "JavaScript").
2. Latency & API Limits
Fetching live job data and generating AI responses introduced delays. We solved this with caching and precomputed results while maintaining real-data integrity.
3. Frontend–Backend Synchronization
Ensuring smooth UI updates while waiting for asynchronous backend responses required careful state orchestration.
4. Visualization Design
Designing a radar that is both visually intuitive and information-dense was challenging — it had to communicate insights instantly without explanation.
Accomplishments that we're proud of
- Turning messy, unstructured job data into a clear, real-time signal
- Building a system that feels alive and reactive, not static
- Creating a scoring model that is simple, explainable, and grounded in data
- Delivering a visually intuitive experience that requires almost no explanation
What we learned
- Real-world data is messy — extracting signal is harder than building models
- Simplicity in UX creates more impact than adding more features
- AI is most powerful when it is guided by structured data, not used blindly
- Demo reliability is as important as system capability
What's next for GAUGE
We see GAUGE as a long-term bridge between education and employment.
Next steps:
- User accounts to track Readiness Score over time
- Personalized progress tracking and skill decay modeling
- Direct integration with learning platforms (Coursera, Udemy, etc.)
- Employer-side dashboards to discover near-ready candidates
Our goal is simple:
Make career readiness measurable, transparent, and actionable for everyone.
Log in or sign up for Devpost to join the conversation.