Chapter 15: Judging & Rubrics
Fair, transparent, and actually useful
Judging is the moment where all the work teams have done gets evaluated. A good judging process feels fair, energising, and constructive — even for teams that don't win. A bad one feels arbitrary, rushed, or biased. This chapter helps you design rubrics, choose judging formats, and run a process that participants trust.
Designing your rubric
A rubric is simply the scoring framework judges use to evaluate projects. Without one, judges default to gut feel — which leads to inconsistent results, implicit bias, and unhappy participants.
Common criteria
Most hackathon rubrics include some combination of these:
Innovation & creativity — Is the idea novel? Does it approach the problem in an interesting way? Or is it a rehash of something that already exists? Score higher for creative problem framing, not just flashy features.
Technical execution — Does the prototype actually work? How well was it built given the time constraints? Is the code clean, the demo functional, the architecture sound? Remember the 25% rule: teams achieve about a quarter of their ambitions. Judge what they built, not what they planned.
Impact & viability — Does this solve a real problem? Could it actually be used by real people? Is there a path from hackathon prototype to something meaningful? For business-focused events, this might include market potential and business model.
Presentation & communication — Can the team explain what they built, why it matters, and how it works? A great project with a terrible demo is harder to evaluate than a good project with a clear story.
A sample scoring system
A simple 20-point scale works well:
Criterion | Points | What judges are looking for |
Innovation & creativity | 5 | Novel approach, creative problem-solving |
Technical execution | 5 | Working prototype, code quality, completeness |
Impact & viability | 5 | Real-world relevance, potential for continued development |
Presentation | 5 | Clear story, effective demo, good Q&A |
Total | 20 |
Each criterion scored 1–5:
1 = Needs significant improvement
2 = Below average
3 = Meets expectations
4 = Above average
5 = Exceptional
Customising for your event
Adapt the rubric to your objective:
Recruitment-focused events: Weight technical execution higher
Innovation challenges: Weight creativity and novelty higher
Community events: Consider adding "teamwork" or "newcomer inclusion" as a criterion
Sponsor challenges: Add criteria specific to the sponsor's goals (e.g., "Best use of [Sponsor] API")
Impact-focused events: Weight viability and real-world relevance higher
Keep the total criteria to 4–6. More than that and judges spend too long per project, scores become inconsistent, and the rubric becomes overwhelming.
Judging formats
Presentation-style (best for small events, <15 teams)
Teams present to all judges in sequence. Each team gets 2–5 minutes to present plus 1–2 minutes of Q&A.
Pros: Every judge sees every project. Judges can ask questions. Presentations create energy.
Cons: Time-consuming with many teams. Presentation skill matters a lot (which may or may not align with your event's goals). Later presenters may be disadvantaged as judges get tired.
Science fair style (best for medium events, 15–30 teams)
Teams set up at their tables/stations. Judges rotate through, spending 3–5 minutes at each booth.
Pros: More efficient for larger groups. Teams demo naturally (on their own screens). Multiple judging conversations happen simultaneously.
Cons: Judges don't all see every project, so you need to coordinate which judges visit which teams. On-site teams may have an advantage over online teams (for hybrid events).
Asynchronous video review (best for online and hybrid events)
Teams submit demo videos (2–5 minutes). Judges watch and score on their own time.
Pros: Eliminates format bias (online teams aren't disadvantaged). Judges can review at their own pace. Videos can be re-watched for careful evaluation.
Cons: Less interactive — judges can't ask clarifying questions. Video quality varies. Some teams are better at video production than building.
Two-stage judging (best for large events, 30+ teams)
Stage 1: All teams are scored (often asynchronously). Top teams become finalists.
Stage 2: Finalists present live (in person or via video call) to all judges.
Pros: Efficient for large events. Finalists get proper attention. Creates a natural dramatic arc.
Cons: Non-finalists may feel dismissed. Requires more time and coordination.
Briefing your judges
This is worth repeating from Chapter 11 because it's that important. Schedule a briefing session and cover:
The rubric in detail. Walk through each criterion. What does a "3" look like vs. a "5"? Use examples if possible. Judges who've calibrated together produce more consistent scores.
The context. Remind judges of the event's objective, the challenges, and what teams have been working on. Share the participant profile — are these mostly students? Professionals? First-timers?
Judging etiquette:
Be encouraging, even with weaker projects. Teams invested hours of their weekend.
Ask constructive questions: "What would you do next?" rather than "Why didn't you do X?"
Score against the rubric, not against each other. Judge each project on its own merits.
Be mindful of bias: unconscious bias toward confident presenters, flashy UIs, or familiar technologies is real. The rubric exists to counteract this.
Format-specific guidance:
For hybrid events: judge projects by their output, not their format. A project built by a remote team is not inherently less impressive than one built on-site.
For asynchronous judging: watch the full demo video before scoring. Don't score based on the first 30 seconds.
Running judging day
Before judging starts
Verify all submissions are in BuilderBase and accessible to judges
Confirm all judges have access to the judging portal
Do a quick test — can a judge open a submission, watch the demo, and submit a score?
Brief judges one last time (quick recap if needed)
During judging
Have someone coordinating judge movements (for science fair style) or monitoring progress (for async)
Be available to answer judge questions
Gently remind judges who are falling behind
Monitor for any technical issues (demo videos not playing, scoring portal problems)
After judging
BuilderBase automatically compiles scores and calculates rankings
Review the results before announcing. Are there any ties? Any obvious scoring errors?
For ties, have a pre-defined tiebreaker: either the judges discuss and vote, or a specific criterion serves as the tiebreaker
Verify winner information (correct team name, correct project) before going on stage
Common pitfalls
Rushing the judging. If judges feel pressured to score quickly, quality drops. Build enough time into your schedule.
Inconsistent scoring. Without a rubric briefing, one judge's "3" is another's "5". Calibration matters.
Presentation bias. A team with a polished presenter can overshadow a team with better technical work. Your rubric should balance this.
Format bias (hybrid events). On-site teams with face-to-face judge interactions tend to score higher than remote teams — unless you use asynchronous judging to level the field.
Not celebrating non-winners. The closing ceremony should acknowledge every team's effort, not just the winners. Applause for each project, shoutouts for creative approaches, and a general message of "you all built something real this weekend" goes a long way.
Key takeaways:
Build a rubric with 4–6 criteria, scored on a clear scale (e.g., 1–5 per criterion, 20 points total)
Customise criteria to match your event's objective
Choose your judging format based on event size and format (async video works best for hybrid)
Brief judges thoroughly — walk through the rubric, calibrate expectations, emphasise fairness
BuilderBase handles score compilation and winner calculation automatically
Celebrate every team, not just winners — people remember how the event made them feel
