Got a project in mind? Book a free 30-minute call

Saadaan Hassan
Case study

Hire-on-Rank: Hiring on Performance, Not Resumes

Hire-on-Rank: Hiring on Performance, Not Resumes

Summary

A hiring platform where developers prove themselves in timed hackathons and recruiters hire from the scores, not resumes. Any commit pushed after a team submits is caught and shown to the judges.

Built at

Dotcode Solutions
Dotcode Solutions

My part

My RoleLead Full Stack Engineer (backend owner)
Stack
DjangoDjango REST FrameworkFastAPIWebSocketsPostgreSQLNext.jsReactTypeScriptTailwind CSSTanStack QueryGitHub API

The problem

A resume tells you what someone says they can do, and a coding puzzle tests something much narrower than real work. Hire-on-Rank, which I built for a client while at DotCode, takes a different route. Developers compete in timed, judged hackathons, earn experience points and a rank from the results, and recruiters find and contact them based on that record. Its line is "Compete. Rank Up. Get Hired."

My part

I built the entire backend: the API, the competition and judging engine, ranking, teams, recruiter discovery, messaging and the deployment. I also worked on the web app and the marketing site alongside a frontend developer, including the admin's submission review, scoring each team member individually, the chat interface, and moving sign-in to secure cookies.

The rule it never breaks

A submission can't quietly change after it's in. When a team submits, the backend records the latest commit in each of their repositories as a baseline. Any commit pushed after that is counted and shown to the judges next to the submission, and the published rules say plainly that late commits mean disqualification.

How a competition runs

  1. An admin sets it up: the type (frontend, backend, full stack or UI/UX), the registration window, the dates, the team size, and weighted judging criteria.
  2. Developers register, alone or as a team, inviting teammates by username or by email, even people who haven't joined the platform yet.
  3. The team leader submits what that type of competition needs: repository links, a live URL, a demo video, a Postman collection, or a Figma link for design entries. Every repository is checked against GitHub to confirm it exists and is public.
  4. Status follows the calendar. Competitions move from upcoming to in progress to completed as the dates pass, and extending the end date reopens one automatically.
  5. Judges score each criterion out of 100. For teams, every member can be scored individually, and the team's score is their average.
  6. Approving the results ranks the submissions, with ties going to whoever submitted first, and awards experience points in a single transaction.

Ranking

Each competition carries a pool of experience points (EXP). First place earns all of it, and each place below earns 10% less, down to 10% for tenth place. Everyone on a team gets the same award. Every 250 EXP is a level, and levels map to seven tiers: E, D, C, B, A, S and NL. A public leaderboard can be filtered by tier.

What recruiters get

Recruiters search candidates by skills, interests, university, degree, minimum level and minimum tier, with ten ways to sort, then open a candidate's profile. Starting a conversation with a candidate spends one "connect" from the recruiter's plan.

Decisions worth explaining

Checking GitHub without hammering it

Checking every repository on every page view would mean one GitHub request per submission. Instead, the backend stores a baseline commit at submission, caches each check for five minutes, and asks GitHub about a whole page of repositories in a single GraphQL query. It only fetches exact commit counts for repositories that have actually moved. Admins can force a fresh check with one button, and every repository is checked again when a competition closes.

Spending a connect exactly once

Connects are deducted inside a database transaction that locks the recruiter's record, so two quick clicks can't open two conversations with one connect. Promo codes use the same locking, and their usage limits are enforced by the database itself.

A separate service for real-time chat

The main API runs on Django's synchronous workers, which suit ordinary requests but not long-lived connections. Messaging, read receipts, attachments and recruiters' private notes run through the API, and a small FastAPI WebSocket server adds live delivery and typing indicators, checking the same sign-in tokens before it accepts a connection. That server is built but not switched on in production yet.

Private files stay private

Public images and private files (environment files submitted with entries, resumes, payment proofs and chat attachments) live in separate storage buckets. Private files are only reachable through signed links that expire after an hour. Sign-in tokens moved out of browser storage into secure HTTP-only cookies, alongside email verification, Google sign-in and token rotation.

Running it

The API runs on a VPS behind Nginx with TLS, managed by systemd and deployed from GitHub Actions. An admin dashboard tracks user growth, the sign-up and verification funnel, and competition, registration and submission numbers. The first hackathon has run end to end on the live platform, from registration to published results.

Limits

  • Real-time chat is built but not enabled in production; messages currently arrive through the regular API.
  • GitHub checks run when a list is viewed, when an admin refreshes, and when a competition closes, not continuously. A webhook-based version was planned but isn't live.
  • Paid entries are confirmed by an admin from a payment proof; there's no payment gateway yet.
  • There's no automated test suite yet. The API is exercised through a 90-request Postman collection, and automated tests are the next thing I'd add.
Project Showcase

System Visuals

The competition page's rules, starting with no late GitHub commits after the deadline, and its weighted judging criteria
Freelance and contract

Have a similar engineering problem?

Let’s discuss your requirements, constraints, and what a useful solution would look like.