CareerLift

Home Screen
Analysis Page
Tracker Page(Calender View)
Upload Page
Tracker Page(List View)

Inspiration

Navigating today’s job market can feel like a maze, especially when you're unsure how your current skills align with your dream job. Reading long job descriptions, mapping them to your experience, and figuring out where to improve is overwhelming and time-consuming. We wanted to change that.

We imagined a tool where users could upload their resume, paste a job description, and instantly get a personalized, AI-driven analysis showing skill gaps, strengths, and a roadmap to success.

CareerLift was born a smart, AI-powered career assistant that does the thinking for you.

What it does

CareerLift helps answer a crucial question: "Am I a good fit for this job? If not, what should I improve?" It provides:

Resume & Job Description Parsing (LLM-powered)
Skill Gap Analysis using Agentic AI
Strengths Recognition
Personalized Learning Path with resource recommendations
Natural language summary of fit and suggestions
All presented in a clean, interactive Skill Analysis Card UI

How we built it

CareerLift is built as a full-stack AI-powered web application with modular, scalable architecture. The core idea was to enable seamless communication between the frontend (React), backend (Flask), and an Agentic AI system powered by LangChain and LLaMA 3 (via Groq).

Working Link

https://w3qk3yvwxp.us-east-1.awsapprunner.com/

Tech Stack

Frontend: Built using React.js with Tailwind CSS for styling. Dynamic components such as resume uploader, job input fields, and the skill analysis card were designed to be reusable and reactive.

Backend (Flask):

API routes were organized using Flask Blueprints (api_routes, resume_routes, etc.)
CORS, dotenv, and proper logging were added to handle environment variables and clean deployment.
Endpoints receive raw text from the frontend, handle pre-processing, and invoke LangChain agents to generate AI responses.

Resume & JD Parsing:

Initially attempted using traditional regex and NLP parsing (e.g., Python scripts), but accuracy was poor.
Switched to LLM-based parsing with Groq-hosted LLaMA 3, called via custom parse_resume() logic.
Prompts are stored in clean .txt templates and filled dynamically for consistency.

LangChain Agent System: We built a fully functional Agentic AI system with:

CareerGapAgent: Compares skills from resume vs job
get_gap_analysis_chain() and run_gap_analysis() abstract the prompt chaining logic
LLM calls are stateless and wrapped in async-safe Python functions
Prompt structure is enforced to return React-friendly JSON for direct UI rendering

LLM & Inference:

Using LLaMA 3 (8B) on GroqCloud, which is a fast inference and free to use
LangChain manages the prompt orchestration and tool integration
Ensured structured output using strict JSON prompt templates to avoid hallucinations

File Upload & Resume Parsing:

Frontend lets users upload resumes as PDF/text
Backend extracts raw text and feeds it to the parser
Parsed skills/experience are then turned into structured JSON used in later analysis

Skill Analysis UI:

Dynamically renders: -- Summary -- Table of Skills to Improve -- Strength tags -- Recommendations and suggestions -- Conclusions
Used conditional rendering and defensive coding to handle incomplete LLM responses

Challenges we ran into

Building an agentic AI application like CareerLift was both exciting and complex. Here's a breakdown of the key hurdles we encountered along the way:

Designing a Real Agentic Workflow (Not Just GenAI): Moving beyond simple prompt calls to build a multi-step, reasoning-capable LLM agent was a major design challenge.
Resume & JD Parsing Issues: Parsing real-world resume and job data accurately proved difficult with traditional methods, prompting a switch to LLM-based extraction.
Handling Inconsistent LLM Outputs: Ensuring consistent, structured JSON output from the LLM was tricky due to hallucinations and missing fields.
Packaging LangChain in Production-Ready Format: Integrating LangChain cleanly into our Flask backend required careful code structure, environment management, and async safety.
Frontend Rendering of Dynamic Data: Dynamically displaying structured LLM output in React needed flexible UI components that could handle evolving schemas and nested data.
Testing With Real-World Resumes: Testing on real resumes exposed edge cases in formatting and phrasing that earlier mock data hadn’t revealed.

Accomplishments that we're proud of

Designed a true agentic AI system that doesn’t just generate text but intelligently plans actions using LLM tools and chains.
Accurately parsed messy, real-world resumes and job descriptions into structured data using LLaMA 3 via Groq for reliable downstream analysis.
Created a clean, responsive React frontend that dynamically renders complex LLM outputs like tables, tags, and suggestions with style and flexibility.
Integrated LangChain into a production ready Flask backend that runs smoothly with modular agents, clear routing, and scalable structure.

What we learned

Agentic AI requires more than prompting: Building structured chains and tools is key to creating intelligent, goal driven behavior.
Real world resumes are messy: We learned how to build robust LLM prompts and parsing techniques to extract usable data reliably.
LLMs need guardrails: We discovered the importance of formatting constraints, consistent schemas, and fallback mechanisms.
Frontend needs to be LLM-aware: Building components that can handle dynamic, nested, and evolving output was essential.

What's next for CareerLift

We plan to integrate public benchmarks and datasets (like Stack Overflow Developer Surveys, LinkedIn Skills Graphs, etc.) to provide better context when scoring users’ skills.
We can introduce multi agent collaboration, where multiple cooperative LLM agents functions. One for parsing, one for mentoring, another for planning, that collaborate dynamically to improve recommendation quality and adaptability.
We could also make the Learning Path Builder interactive which allow users to customize their learning plans using drag-and-drop UI, integrated with APIs from Coursera, YouTube, or Medium to fetch the right resources live.