Inspiration

USC's alumni network is one of the most valuable things a Trojan has, but using it for a job search is painful. Students don't know which alumni are hiring or willing to refer, so they send cold LinkedIn messages that mostly go unanswered. Alumni who do want to help get scattered DMs with generic resumes and no context, and they have to read each resume line by line to see whether the student fits the role.

The alumni side has more to gain than people think. Many companies pay a referral bonus when a referred candidate is hired, and referred candidates usually get a closer look from recruiters than cold applicants. That gives alumni a faster, more direct way to bring people they trust onto their team. Both sides want the same thing, but there's no trusted place built around a specific opening. That's the gap we set out to fill.

What it does

Trojan-link is a USC-only space where alumni post openings on their own teams and students request referrals directly.

  • Verified Trojans only. Everyone signs up with a USC email and confirms it with a one-time code.
  • Alumni post real openings. Each post includes the team, requirements, application steps, and deadline, plus whether the alum is open to referral requests or only to questions.
  • Students search and reach out. They filter by company, industry, location, job type, and work mode, then send a Request Referral or an Ask a Question. Each student and role gets one thread with a clear status (pending / interested / declined).
  • Resumes as versions. Students upload a PDF or DOCX, or type their resume in. It's turned into an editable draft they confirm before using it. When they send a request, the backend saves a frozen copy of that resume, so the alum sees exactly what was submitted.
  • Tailor for This Role (AI). Claude suggests job-specific edits. Each one shows the original text, the new text, the reason, and the requirement it targets. Accepted edits become a new tailored version; the base resume never changes.
  • Review with AI (for alumni). Claude breaks the job into its requirements. For each one it marks evidence found, partial, or missing, quotes the student's resume, and suggests follow-up questions. It gives no verdict and no score, so the alum stays the decision-maker.
  • Connections and Persona. Profiles and alumni discovery help students find people beyond a single job post.

How we built it

We split the work across three people and agreed on two contracts early: a single structured resume format (contact, summary, education, experience, projects, skills) and a shared REST API. That let everyone build in parallel.

  • Backend: Python + FastAPI, SQLAlchemy 2 and Pydantic v2, on SQLite to keep the setup simple for a one-day build. Authentication uses JWT with bcrypt-hashed passwords. The verification code is stored only as an HMAC hash. It expires after 10 minutes and allows 5 attempts.
  • Resume import: pypdf and python-docx extract the text, Claude organizes it into resume sections, and a rule-based parser takes over if the AI isn't available.
  • AI: The Anthropic Claude API with structured outputs. Every response must match a Pydantic schema, so the frontend always gets predictable JSON. Results are stored along with a hash of the exact input they analyzed, so clicking again doesn't call the model twice.
  • Frontend: React + TypeScript. Wherever the frontend's request formats differed from our core API, we added thin adapter endpoints instead of rewriting either side.
  • Testing: pytest with FastAPI's TestClient. The model call is mocked, so the full flow (register → post a job → tailor → send → AI review) runs without an API key.

Challenges we ran into

Keeping the AI honest. A resume tool that makes things up is worse than no tool. Prompt rules ("never add skills or numbers the student didn't write") help, but they aren't a guarantee, so the code checks every AI result:

  • A suggested edit is dropped if its original text doesn't match the resume, or if it adds a number or a skill that appears nowhere in the resume.
  • In alumni review, each quote the model gives must appear word for word in the frozen resume copy, and quotes that don't are removed. If $E_r$ is the set of verified quotes for requirement $r$, then $$ \text{status}(r) = \begin{cases} \text{evidence found} & \text{if the model said so and } |E_r| \ge 1 \ \text{partial} & \text{if the model said evidence found but } |E_r| = 0 \end{cases} $$ and the model's other labels are kept as they are.

Helping without judging. We wanted the AI to save alumni time, not rank candidates. So the review lists evidence for each requirement, gives no hire/no-hire verdict or score, and is explicitly told never to consider protected characteristics.

Messy resume files. Real PDFs and DOCX files have tables, columns, and odd bullet characters. We handled tables and list bullets during extraction and kept a rule-based fallback. Students always review the draft before it's used.

Failing gracefully. If the AI is down or not configured, its endpoint returns a clear error and nothing else breaks. Students can still edit and send requests, and alumni can still read and reply.

Integrating in one day. Three people building separate modules hit the usual mismatches: different field names, ID types, and response shapes. The shared contracts and small adapter endpoints kept us from breaking each other's code.

Accomplishments that we're proud of

  • A complete flow built in one day: USC email verification, job posts with search and filters, resume upload and versioning, referral threads with statuses and messages, and both AI features.
  • AI that won't make things up. In our tests, when the AI suggested a made-up "50,000 users" metric, the code caught it and dropped the suggestion. When it cited a resume quote that wasn't there, the quote was removed and the finding was downgraded.
  • Fair by design. The alumni review lists evidence for each requirement without a verdict or score, so the AI helps alumni read, not judge.
  • Privacy built in. A resume is visible only to its owner and to the alum who received the request. The original file is shared only if the student chooses to share it.
  • A product that works for both sides. Students get a direct line to people who can refer them. Alumni get qualified, verified candidates for their own team.

What we learned

  • Trust in AI output has to be built into the code. Structured outputs plus code-side checks were far more reliable than prompt instructions alone.
  • Design for both sides of the marketplace. The product only works if alumni have a reason to show up, which pushed us to focus on referral bonuses, faster hiring, and less resume-reading.
  • Agree on contracts first. One shared resume format and API saved us hours of merge pain.
  • Keep the stack small for a hackathon. SQLite and simple table creation instead of Postgres and migrations let us spend our time on the features that matter.

What's next for Trojan-link

  • Role recommendations based on a student's confirmed resume and interests.
  • Referral tracking so alumni can see which referrals moved forward, and follow their impact (and their bonuses).
  • Richer alumni tools: bulk review, filters, and reminders for pending threads.
  • Production setup: Postgres with migrations, real verification emails, and cloud file storage.
  • Evaluating the AI on real, consented resumes to measure accuracy and fairness.
  • Beyond USC: verified alumni boards for other universities.
Share this project:

Updates

Submission history