The Organizer Integrity Checklist
A practical, phase-by-phase checklist you can use for every event. Print it, bookmark it, share it with your co-organizers.
Pre-Event Setup
Before registration opens
Rules & Policies
Write a clear honor code
Define what "original work" means, what's allowed (frameworks, libraries, AI tools), and what's not (pre-built projects, recycled submissions).
Define your AI tools policy
State whether AI coding tools are allowed and what disclosure is required. We recommend: allow with disclosure.
Set team size limits
Define minimum and maximum team sizes. State that only registered team members may contribute code.
Define consequences for violations
State what happens if rules are broken: warning, score reduction, disqualification, or exclusion from future events. Be specific.
Registration & Submission Setup
Add honor code acceptance to registration
Require participants to agree to the honor code as part of the registration process (checkbox).
Require GitHub repository URL in submissions
Add a required URL field for the public GitHub repository. Specify that repos must be created after the hackathon starts.
Add demo requirement to submission form
Require a live demo URL or specify that a live demo will be required during judging.
Add AI tools disclosure field
Include an optional text field for teams to disclose which AI tools they used.
Set submission deadline enforcement
Use automated deadline enforcement so submissions physically cannot be added after the deadline.
Judge Preparation
Share technical Q&A templates with judges
Give judges specific questions to ask: architecture decisions, biggest bugs, code walkthrough requests.
Brief judges on integrity expectations
Ask judges to flag anything that seems off: suspiciously polished projects, teams that can't explain their code, or demos that seem pre-recorded.
Check for conflicts of interest
Ensure judges don't evaluate teams where they have personal or professional connections.
During the Hackathon
Active monitoring and support
Kickoff
Review the honor code verbally during kickoff
Don't just show a slide. Walk through the key points and explain why integrity matters for a fair event.
Remind teams to create fresh GitHub repos now
Give a clear timestamp: "Your repo should be created starting from right now." This prevents confusion later.
Collect initial team ideas
Have each team share their initial idea and planned approach. This creates a baseline for comparison.
Mid-Event Check-Ins
Run a midpoint check-in
Ask teams to share progress. Frame it as mentorship. Projects should be rough and incomplete - a polished project at 50% is suspicious.
Monitor for team size violations
For in-person events, note if extra people are consistently working with a team. For virtual events, check active participants in team channels.
Be available for rule clarifications
Teams will have questions: "Can I use this library?" "Does this starter template count as pre-work?" Answer promptly and consistently.
Judging & Submission Review
When submissions close
Automated Integrity Checks
Run automated checks on all submissions. Use a platform that handles this for you, or build your own verification pipeline.
Run repository timeline verification
Verify that development activity falls within the hackathon window.
Verify team member contributions
Ensure all contributors match the registered team.
Check for duplicate or recycled submissions
Cross-reference submissions against other events.
Review integrity reports for flagged items
Focus manual review on submissions that automated checks flag for attention.
Manual Verification (Flagged Submissions)
For submissions that automated checks flag, conduct deeper verification.
Conduct a technical Q&A with the team
Ask the team to explain their architecture, walk through their code, and demonstrate features off-script.
Request a live demo with unexpected inputs
Ask the team to demonstrate the product using inputs they haven't rehearsed.
Discuss findings with the team
Give teams a chance to explain any flags before making decisions.
Post-Event
After results are announced
Document any integrity issues found
Record what was flagged, what was investigated, and what decisions were made. This helps improve future events.
Review your rules for gaps
Did any integrity issues arise that your rules didn't cover? Update them for next time.
Gather feedback on fairness
Ask participants in your post-event survey: "Did you feel the competition was fair?" This surfaces concerns you might have missed.
Share what worked with other organizers
The hackathon community benefits when organizers share their integrity practices. Consider writing about your experience.
Quick Reference Summary
Before the Event
- - Write honor code
- - Set AI tools policy
- - Define team size limits
- - Require GitHub repos
- - Require live demos
- - Brief judges
During the Event
- - Review rules at kickoff
- - Collect initial ideas
- - Run midpoint check-ins
- - Monitor team sizes
- - Answer rule questions
After Submissions
- - Run automated integrity checks
- - Review flagged submissions
- - Technical Q&A for flags
- - Document decisions
- - Gather fairness feedback