Career-Path

Career Path System Design.

Inspiration

Most students don't choose careers — they inherit them. A parent's opinion, a trending YouTube video, a friend's salary screenshot, or sheer fear of uncertainty often decides the path more than self-understanding does. We kept running into the same two broken tools: career quizzes that spit out a single label like "You are suitable for engineering" with zero explanation, and chatbots that respond with generic platitudes like "follow your passion." Neither helps a student actually reason through a decision.

That gap felt personal too — one of us went back and forth for a while on the exact same stability-versus-passion tradeoff this project models, with no good way to actually reason through it. That experience is part of why we wanted to build something different — a tool that doesn't tell a student what to become, but helps them see what might realistically happen if they choose Path A versus Path B, based on who they actually are.

What it does

Career Path is an NLP-powered decision-support system that compares two very different careers — Software Developer and Content Creator — against a student's personality, habits, and constraints.

The student answers a short set of open-ended questions in plain English. The system extracts behavioral traits from those answers (technical interest, risk tolerance, patience, financial pressure, creativity drive, etc.), builds a personal profile, and runs that profile against two structured career models. It then shows:

Best-case, expected-case, and difficult-case trajectories for each path
A personalized tradeoff table (income stability, risk, entry barrier, feedback clarity, etc.)
Conflict warnings when a student's stated priorities contradict each other (e.g., wanting both guaranteed income and full creative freedom)
A "what-if" simulator that lets the student tweak inputs like daily hours and instantly see how the trajectories shift

At the end, the student makes their own call — Developer, Creator, or "not sure" — fully informed, with no recommendation pushed on them.

How we built it

The core idea was to keep the intelligence inside an explainable pipeline rather than a black-box model:

Questions → spaCy NLP → Trait Classification → Student Profile
→ Career Models → Scenario Simulation → Tradeoff Analysis
→ Conflict Detection → What-if Simulation → Student Decision

NLP layer: We used spaCy for tokenization, POS tagging, noun-chunk and verb extraction, and negation detection, so the system understands what a student said and whether it was negated.
Trait classification: Extracted phrases are mapped to human traits (e.g., "stable income" → financial_pressure, "experiment" → independent_creator_behavior) using a curated phrase-to-trait lookup, with each trait scored HIGH/MEDIUM/LOW.
Career models: We formalized each career as a staged system — Developer (Learning → Entry → Growth) and Creator (Exploration → Growth → Monetization) — each with explicit trait requirements per stage.
Simulation & scoring: A rules engine compares the student's trait profile against each career model to generate timeline scenarios and a personalized tradeoff table.
Conflict detection: A second rules pass checks for contradictory trait pairs and surfaces them as plain-language warnings.

Everything was built in Python, with spaCy doing the heavy NLP lifting and a lightweight interface tying the steps together into one flow a student can walk through.

Challenges we ran into

Ambiguous language: Free-text answers don't map cleanly to traits. "I can work about three hours daily" is easy; "I guess I'm okay with waiting, depends" is not. We had to constantly refine our phrase-to-trait dictionary and negation handling to avoid misreading intent.
Avoiding bias in the career models: It would have been easy to make one career look objectively "better." We spent real time making sure the stage requirements and tradeoff factors were grounded and balanced rather than reflecting our own preferences.
Keyword matching's ceiling: Rule-based extraction is explainable but brittle — synonyms, sarcasm, and indirect phrasing slip through. We knew early on this would need to evolve.
Designing conflict detection without being preachy: We wanted the system to flag real contradictions without sounding like it was judging the student's choices.
Keeping the system a mirror, not an *oracle*: The hardest design constraint was discipline — at every step we had to resist the urge to add a "recommended for you" output.

Accomplishments that we're proud of

Built a fully explainable pipeline — every trait, scenario, and warning can be traced back to a specific phrase the student typed, with no opaque model in between.
Designed two complete, stage-based career models from scratch, each grounded in realistic timelines.
Built a working conflict detector that catches contradictory priorities most quiz-style tools never check for.
Implemented a live what-if simulator so the experience feels exploratory rather than one-shot.
Stayed true to our core principle throughout: the system never tells the student what to become.

What we learned

A lot about practical NLP — POS tagging, noun-chunk extraction, and negation handling go a long way before you need anything heavier.
How much implicit knowledge goes into something as "simple" as a career path — formalizing it into stages and trait requirements took far more thought than expected.
That explainability and personalization are often in tension, and rules-based systems force you to make that tradeoff explicit instead of hiding it.
That designing for a student's agency — not just their outcome — fundamentally changes how you build the product.

What's next for Career Path

AI-powered mock interview layer: Integrate an LLM (e.g., via the Google Gemini API) as an optional add-on that conducts a short conversational interview — asking natural follow-up questions and probing trait signals more deeply than static questions can — while keeping the current rule-based pipeline as the explainable core the rest of the system relies on.
Move from keyword matching to semantic similarity (embeddings) so the trait classifier understands paraphrased or indirect language, not just exact phrase matches.
Add more career paths beyond Developer and Creator, each with its own staged model.
Validate career models against real outcome data, possibly in partnership with career counselors or alumni surveys.
Richer multi-trait scoring instead of single HIGH/MEDIUM/LOW buckets, to capture nuance in borderline profiles.
Lightweight ML classifier trained on labeled student responses, layered on top of the rules engine rather than replacing it — keeping explainability intact while improving accuracy.
Mobile-friendly interface so students can run the simulator from anywhere. //Test code for nlp import spacy

nlp = spacy.load("en_core_web_sm")

text = "I like structured learning but I enjoy building things on my own"

doc = nlp(text) def process_user_answer(text): # Step 1: NLP extraction spacy_output = spacy_extract(text)

print("SPACY OUTPUT:", spacy_output)

# Step 2: categorisation
traits = categorize_traits(spacy_output)

print("TRAITS:", traits)

return {
    "raw_nlp": spacy_output,
    "traits": traits
}

answer = "I like structured learning but I enjoy building things on my own"

result = process_user_answer(answer)