HackOps AI

Inspiration

Every hackathon we'd competed in ran on the same disconnected stack - Devfolio or Unstop for registration, a WhatsApp group for chaos, Google Sheets for judging. These tools are great at logistics and completely silent on the decisions that actually determine whether an event runs well: who should team up, who's stuck and needs help, and which project is actually good. We kept watching judges manually read dozens of READMEs under time pressure, and participants sit blocked waiting for a mentor who was busy answering the same basic question for the fifth time that day. Nobody had built the operations layer -- so I did.

What it does

HackOps AI is an AI-operations layer for hackathons, serving organizers, participants, mentors, judges, and sponsors. We scoped it to three features that work end-to-end: AI Team Matching groups solo participants into rosters with complementary — not identical — skills, so you don't end up with four frontend devs on one team. AI Mentor Assistant takes a participant's blocker, gives an instant first-pass answer, and routes them to the best-fit mentor by expertise tag instead of a first-come queue. AI Project Evaluation scores every submission against a fixed rubric (Innovation, Technical Complexity, Completeness, UX) and renders it as a live radar chart with written feedback, so judging is fast and consistent instead of twelve different judges applying twelve different standards.

How we built it

Next.js 14 with the App Router and Tailwind/shadcn for the frontend, Supabase for auth and data (Postgres + Realtime), and Google's Gemini for the AI layer, called through Next.js API routes so there's no separate backend service to manage. Team matching runs on a deliberately simple one-hot skill vector with complementarity scoring rather than embeddings — fast, explainable, and easy to defend in front of judges. Mentor matching uses tag-overlap between a participant's stated problem area and mentor expertise tags for the same reason — simple, fast, and transparent rather than a black box. Project evaluation sends the README, file structure, and description through a fixed-rubric prompt and gets back structured JSON, which we render live as a Recharts radar chart. We deliberately scoped the build to these three features and documented everything else — nine Tier 1 features and thirteen Tier 2 ideas — as an explicit roadmap rather than trying to half-build all twelve, because a judging rubric rewards working and polished over broad and unfinished.

Challenges we ran into

Deciding what not to build was harder than building what we did — we had eight-plus viable feature ideas and had to cut hard to three, protecting the last stretch of time for polish and rehearsal instead of chasing more scope. Getting the AI evaluation to feel trustworthy rather than gimmicky took real iteration — early versions scored off the README alone, which felt shallow, so we pushed to have it reason over actual repo structure instead of just prose. We also hit real infrastructure friction: migrating off a deprecated Gemini model version mid-build, wiring Supabase auth (email/password plus Google OAuth) correctly with redirect URLs across both local and production environments, and making sure our AI-generated data was actually persisted server-side rather than living only in browser state, which we caught and fixed before it undermined the "real platform" story we were telling.

Accomplishments that we're proud of

Shipping three genuinely working AI features instead of a slide full of promises — every one of them takes real input and returns a real, structured, demoable output. We're proud of choosing transparency over hype: our matching logic is simple by design and we can explain exactly how it works instead of hiding behind "AI magic." And we're proud of building something that doesn't just showcase AI for its own sake — it's addressing a real coordination gap we personally felt as competitors before we ever started building the tool to fix it.

What we learned

That disciplined scope is a feature, not a limitation — cutting from eight ideas to three made every one of the three better, not weaker. That "AI-powered" claims only earn trust when you can show your work — being able to say plainly how team matching or mentor routing actually functions mattered more in practice than reaching for a fancier-sounding architecture we couldn't defend. And that the gap between a demo that looks good and a demo that survives technical questioning is entirely about whether your data and claims are actually real underneath the UI — something we had to go back and fix once we noticed it ourselves.

What's next for HackOps AI

A real-time leaderboard and organizer analytics dashboard, both straightforward once evaluation data lives in a proper database rather than local state. A small retrieval-based FAQ bot for event logistics questions, separate from the technical Mentor Assistant. Multi-model resilience — automatic failover to a second LLM provider if our primary one rate-limits under real event load. And longer-term, the features we've deliberately held back as roadmap rather than half-built: sponsor talent discovery, a real-time leaderboard, judge calibration to normalize scoring across evaluators, and eventually opening the platform up beyond a single event to any hackathon that wants an operations layer instead of just a registration form.

Built With

• elevenlabs
• gemini
• next.js
• react
• supabase
• typescript