Inspiration

As computer science students, we know how intimidating it can be to get started with open source. You might already know several programming languages and have worked on your own projects, but finding a repository you can realistically contribute to is a different challenge.

GitHub has an enormous collection of open-source projects, but figuring out which ones match your skills, interests, and experience can take a lot of time. GitHub's "good first issue" label helps a little, but searching it gives everyone the same list, and a lot of those issues are old or already claimed. Even after finding something interesting, understanding an unfamiliar repository can be overwhelming.

That got us thinking: what if discovering the right open-source project could be as simple as saying "Open Sesame"?

What it does

OpenSesame is a platform that helps CS students discover open-source repositories that match their skills, interests, and experience.

We built it around three main features:

Discover: Explore open-source repositories from around the world through an interactive 3D globe.

Match: We read your public GitHub repos (the languages you use, how recently you used them, and the frameworks in your dependency files) and Gemini rates each skill from 1 to 5. Then we rank active open-source repos against those skills. Each match shows why it fits, what you'd learn there, its open beginner issues, and recent activity: new beginner issues today, issues picked up this week, and stars gained this week.

Understand: Pick a beginner issue and get a coach walkthrough. The coach reads the issue, the maintainers' comments, the README and the contributing guide, then gives you setup steps, files to look at, hints, and a PR checklist pitched at your skill level. It never writes the fix, and it flags projects that have rules about AI-written contributions.

Rather than spending hours browsing through repositories and reading unfamiliar documentation, students can narrow down their options and find a more approachable starting point.

How we built it

CATALOG (runs every hour)
  n8n --POST /refresh--> FastAPI --search + fetch--> GitHub API
                            |
                            v  save
          Tiger Cloud (Postgres + TimescaleDB)
            - catalog: repos and their beginner issues
            - hypertables: repo snapshots, "issue appeared" / "issue picked up" events
            - continuous aggregate: daily history per repo

MATCH (student opens the app)
  Frontend (Vercel) --GET /matches/{username}--> FastAPI
    1. public repos, languages, dependency files   <-- GitHub API
    2. skills rated 1-5 (structured output)        <-- Gemini
    3. rank the catalog with a fixed formula           (Python)
    4. recent activity for the top matches         <-- Tiger Cloud

COACH (student picks an issue)
  POST /coach --> issue + comments + README/CONTRIBUTING (GitHub) --> Gemini --> walkthrough

Every piece has one job:

  • GitHub tells us what exists right now.
  • Gemini does two things: it turns your GitHub activity into a skill list, and it writes the coach walkthrough. Both use structured output, so a successful call always comes back as JSON we can use. Gemini never ranks repos.
  • The ranking is a fixed formula in Python:

$$ \text{score} = 0.6 \cdot \min\left(\sum_{s \in S} \frac{p_s}{5} w_s,\; 1\right) + 0.25 \cdot \frac{\min(g, 5)}{5} + 0.15 \cdot a $$

where S is the set of your skills that appear in the repo, pₛ is your proficiency (1 to 5), and wₛ is how much of the repo uses that technology (its share of the code, plus 0.5 for a matching repo topic). The variable g is the number of open, unassigned good first issues. The activity factor a is 1 if the repo was updated within the last 30 days, 0.5 if updated 31–90 days ago, and 0 otherwise.

Same skill list plus same catalog gives the same order. The catalog refreshes every hour and your skills get re-rated after 7 days, so your matches change over time, but you can always see why a repo ranked where it did. The "why it fits" line is filled in by Python from your matched skills, the beginner issue count and the activity numbers.

  • Tiger Cloud holds the catalog plus two hypertables: a snapshot of every repo on every refresh, and an event whenever a beginner issue shows up or gets picked up. A continuous aggregate rolls the snapshots up by day. GitHub can't tell you "stars a week ago" or "this issue got claimed Tuesday." Our history can.
  • n8n kicks off the catalog refresh every hour.

We built the design in Figma. The backend is FastAPI with an async GitHub client (max 8 requests at once), SQLModel and Tiger Cloud, deployed on Render. The frontend, including the 3D globe, is build with TypeScript, React and deployed on Vercel with GitHub login through Auth0, and our domain is from GoDaddy.

Challenges we ran into

One of our biggest challenges was narrowing down the problem we actually wanted to solve. We initially explored different ideas before realizing that finding a suitable open-source project was a challenge we could relate to as CS students.

Another challenge was figuring out how to make OpenSesame more than another GitHub search tool. We wanted personalized recommendations to be genuinely useful rather than simply filtering repositories by programming language.

Designing the interactive globe also required balancing visual appeal with usability. We wanted it to make discovery engaging without distracting from the actual purpose of the platform.

We also had to think carefully about how to present project compatibility in a way students could understand and trust. That's a big part of why the ranking is a formula we can explain, not an AI's opinion.

On the backend:

  • GitHub's search limit. Search only allows 30 requests a minute, so a live search per student was never going to work. We build the catalog in the background instead. Search asks for repos with 100 to 20,000 stars, pushed in the last 90 days, with more than two good first issues. Then we keep licensed repos that aren't archived or forks, drop pull requests, and only keep issues with no assignee.
  • A refresh takes about a minute. That's too long to hold a request open, so the endpoint starts the job in the background and returns right away. A lock stops two refreshes from running at once.
  • Not faking activity. The first time we see a repo, every issue looks new, so we skip "appeared" events on a repo's first refresh. A repo that shows up under two languages only gets one snapshot per refresh.
  • Gemini isn't always available. Structured output guarantees the shape of a successful answer, not that you get one. The main model sometimes comes back with "high demand," so we retry that call on a second model.
  • Keeping Gemini honest. Each prompt has strict rules and two worked examples. The skill analysis only rates what's in the data and doesn't pad thin profiles. The coach gives hints, not code.

Accomplishments that we're proud of

  • Matches you can explain. Every score breaks down into skill fit, beginner issues and recent activity.
  • An activity history GitHub doesn't keep, built from our own hourly snapshots.
  • A coach that helps you start without taking the contribution away from you.
  • The whole pipeline running end to end: n8n triggers the refresh, Tiger stores the history, and the frontend shows live matches on the globe.

What we learned

Building OpenSesame reminded us that having access to information isn't the same as knowing what to do with it.

We learned the importance of defining our target users, understanding their frustrations, and designing features around those needs rather than adding functionality just because we could.

On the technical side, we gained experience working with repository data, personalized matching, frontend development, and integrating different parts of an application under hackathon time constraints. A few things stood out:

  • AI is good at fuzzy calls, like "how well does this person know Python?" Anything with a right answer, like ranking, should be code.
  • Time-series data shows change. "Beginner issues here get picked up within a week" tells you more than a star count.
  • This was our first time using a time-series database. Hypertables made "last 7 days" queries easy, and the continuous aggregate keeps daily history without recomputing it.
  • Rate limits shape your architecture. GitHub's is the reason our catalog lives in our own database.

What's next for OpenSesame

We'd love to take OpenSesame further by improving the accuracy of our recommendations:

  • Count your other contributions. Merged PRs to other people's repos should feed your skill list too, not just your own repos.
  • Go and Rust frameworks. We already fetch go.mod and Cargo.toml, but so far we only read JavaScript, Python and Java dependency files.
  • Fix your own skill list. If Gemini gets a rating wrong, you should be able to correct it.
  • A LeetCode-style view. Issues sorted by difficulty, with each repo's merge rate for first-time contributors.
  • Follow-up questions in the coach, so you can ask about the files it pointed you to before you open your PR.

Our long-term goal is to make open-source participation more approachable for students who want to apply their skills to real projects but aren't sure where to begin.

Built With

Share this project:

Updates

Submission history