Inspiration
I was inspired by a real struggle that I kept running into as a computer science major in a tough job market. Every time I read internship job descriptions, I realized that I wasn't qualified to apply because many of the qualification listings were things I had never even heard of. I always told myself, wouldn't it be nice if about a year ahead of the application season, I could read those job descriptions ahead of time, learn the tools required, and build projects to demonstrate those? This way of thinking was inspired by the fact that I work as a student career advisor at Whitman College. Though I am myself a student, I've been trained to review students' resumes and help them land jobs and internships. So I know how crucial it is to line up experiences on a resume with job description requirements. So, I start wondering, wouldn't it be nice to have an ai agent that could read the job descriptions of the positions you are interested in, and build you a roadmap so that you can prepare yourself ahead of time and be a competitive applicant?
What it does
DuckPath is a web app that turns a job title into a complete, free prep plan. You type a role (such as "Machine Learning Engineer", "Data Analyst", "UX Designer" ) and it reads real job postings to figure out what skills actually matter for that role right now. Then it maps out a step-by-step learning path: where to learn each skill for free, a concrete project idea to prove you know it, job simulations to practice the actual work, interview practice resources, and a networking kit with LinkedIn search terms and a cold email template you can copy and send.
The whole thing is built around the issue that the way most people prepare for a job is vague and not tailored to the position. Duckpath fixes that.
How we built it
We split the app into layers, one file per layer, one person per file to be able to work in parallel without constantly overwriting each other's code.
The data spine is two API calls (JSearch to pull real job postings, and Groq (a free LLM API running Llama 3.3) to read those postings and extract the skills, interview signals, and experience employers actually ask for.
We curated by hand the learning resources, job simulations, and networking templates, deliberately avoiding to use AI since because it could have confidently invented URLs that didn't exist and mislead the users. The project ideas and alternative proof paths (open source contributions, technical writing, competitions) are AI-generated because there's no "wrong" answer there. And projects are a place where creativity in generating ideas is only a strength.
The front end is Streamlit, which let us build a real working UI without either of us knowing frontend development. We used Graphviz to render the skill roadmap as a connected node graph. The UI was inspired by the neetcode 75 roadmap to data structures and algorithm.
Challenges we ran into
GitHub blocked our first push. We accidentally put a real API key into .env.example (the template file that's supposed to have placeholder text only). GitHub's secret scanning caught it and rejected the push. We had to revoke the key, fix the file, and amend the commit.
We ran into merge conflicts. Working on the same repo as two people means sometimes you both push changes to the same file at the same time. Git doesn't know which version to keep. We had to learn git stash, git pull --no-rebase, and git checkout --ours to work around the issue, and work on our communication system to prevent further similar problems.
Our role-matching function matched "machine learning engineer" to the "AI engineer" bucket because "machine learning" appeared as a keyword there first. It took a while to notice because the function still returned something, just the wrong thing. We also had a keyword "quant" that matched the word "quantum" as a substring, so "Quantum Computing Researcher" was being routed to quantitative analyst simulations.
Accomplishments that we're proud of
We shipped 173 passing tests. For two people who started this project learning what a virtual environment was, that feels like a real thing.
The longest-match algorithm we built for role matching, where the function keeps searching for a better match instead of stopping at the first keyword it finds, solved a genuinely tricky problem cleanly. It's a small piece of code but it took real debugging to understand why the naive version was wrong.
We also caught real data bugs with our tests. The duplicate-links test found four roles in our job simulations data where we'd accidentally used the same generic URL for multiple named entries. We probably wouldn't have been able to spot this on our own without the tests.
We also built a product that we believe has real value and will contribute significantly to CS majors career journeys. Something that can make a difference into students' and even professionals' careers. This is ultimately our biggest accomplishment.
What we learned
How Python virtual environments work and why they exist The full Git workflow: branching, committing, pushing, pulling, resolving conflicts How to call an LLM API and get structured JSON back instead of free text How to write tests that mock API calls so they run instantly without hitting the network That conftest.py exists and why you need it when a module creates a client at import time The difference between a module's public interface and its private implementation details
What's next for DuckPath
The curated resources only cover about 20 skills right now. We want to add the skills that actually show up most often when people run real searches.
We also want to let users save their roadmap. Right now every search starts fresh. If you could log in and pick up where you left off, track which steps you've completed, and see your progress over time, the app becomes a tool you come back to instead of a one-time lookup.
We also plan to make the app personalized based on what you already know, resume gap analysis, and a way to connect with other people prepping for the same role.
Log in or sign up for Devpost to join the conversation.