How to Win a Hackathon: 10 Tips From 500+ Events
Estimated read time: 8 minutes
How do you win a hackathon? Winners are typically decided in the first two hours, not the last two — they pick a tractable problem, agree on what "done" looks like, read the judging rubric before coding, build a working skeleton early, and design the demo before writing meaningful code. The rest of this playbook breaks down the 10 tips to win a hackathon that consistent winners apply across formats and prize sizes.
Most teams who walk away with the prize money usually picked a tractable problem, agreed on what "done" looks like, and started shipping before the free pizza arrived. The rest of the field is still arguing about the tech stack at hour four.
This playbook is for developers who have entered a few hackathons, placed somewhere in the middle of the leaderboard, and want to understand what the consistent winners do differently. It is not a list of motivational quotes. These are 10 tips to win a hackathon, drawn from patterns we have seen across hackathons HackerEarth has designed and run for global enterprises including Google, Microsoft, Elastic, Flipkart, and Brillio.
A warning before we start: most of these tips will contradict instincts you have built up from regular software work. Hackathons are not jobs. The optimal strategy is different.
Before the hackathon starts
1. Read the judging rubric before you read the problem statement (Hackathon Tip #1)
The judging rubric tells you what the organizers will reward. The problem statement tells you what they want built. These are not the same thing.
A rubric that weights "innovation" at 40% rewards a clever angle on a boring problem. A rubric that weights "technical complexity" at 40% rewards depth over polish. A rubric heavy on "business viability" wants a pitch deck as much as a demo. Research on hackathon judging from the MLH Organizer Guide confirms that judging criteria — not raw technical merit — drive most outcome variance.
Most teams skim the rubric once and never look at it again. The teams who win re-read it before every major decision — feature scope, demo prep, even slide order. If "user experience" is 25% of the score, your three hours of polish on the landing page is not wasted time.
If the rubric is not published, ask. Organizers will usually share it. If they refuse, assume the judges are scoring on demo quality and storytelling, because that is what unguided judging defaults to.

2. Pick a hackathon problem you can finish, not one you want to solve
Ambition kills more hackathon teams than bad code does. The team that wants to "build a generative AI agent that automates legal contract review" at a 36-hour event will spend 30 hours on the agent framework and four hours discovering it doesn't work on real contracts.
The winning move is to scope down hard. A problem you can finish has three properties:
- The core demo works without internet, third-party APIs going down, or a specific person being awake
- A judge can understand what it does in under 30 seconds
- The "wow" moment happens within the first minute of the demo
If your idea fails any of these tests, cut scope until it passes. You can always add stretch features once the core works.
3. Form your hackathon team around skill gaps, not friendships
The four-person team of backend developers is the most common losing configuration at hackathons. They build something technically interesting that demos badly and pitches worse.
A team that wins a 24–48 hour event usually has, at minimum:
- One developer who can ship a working frontend fast
- One developer comfortable with backend and infrastructure
- One person who handles the pitch, slides, and demo script
- One generalist who debugs, integrates, and fills gaps
You can compress this into three people if someone doubles up. You cannot compress it into four backend developers, no matter how good they are. The team with weaker individual coding skills and a strong presenter beats the team of brilliant engineers who can't explain what they built.
During the build
4. Build a working hackathon skeleton in the first 25% of the time
This is one of the strongest patterns we observe across the hackathons we run — across formats, prize sizes, and skill levels.
By the end of hour six of a 24-hour hackathon, your team should have:
- A deployed or locally-running app that responds to one input and produces one output
- The shape of the demo flow even if every screen is placeholder
- The integration between frontend and backend working at the most basic level
This skeleton will look embarrassing. It is supposed to. The point is that you now have something to improve rather than something to finish. Teams who spend the first day planning and the second day building lose to teams who spend the first day building something terrible and the second day making it less terrible.
5. Use AI coding tools deliberately, not constantly, during the hackathon
Most developers today use AI coding assistants in normal work. According to the 2024 Stack Overflow Developer Survey, more than 75% of developers report using or planning to use AI tools in their development workflow. At a hackathon, the temptation is to use them for everything. This is a mistake.
AI coding assistants are excellent for boilerplate, API integration code, throwaway UI scaffolding, and converting between formats. They are unreliable for the parts of your project that judges will actually scrutinize: the novel logic, the integration glue between systems, and the parts where your idea is different from every other team's idea.
The teams who win use AI to move fast on the 80% of code that doesn't matter, then write the 20% that does matter themselves, with full understanding. The teams who lose ask the AI to build the differentiated part of their project and then spend the demo Q&A unable to explain how it works.
If you cannot explain a piece of code in your demo, the judges will sense it. They will ask about it specifically.

6. Design the hackathon demo before you write the code
Write the demo script — the actual 90-second walkthrough you will give the judges — before your team writes a meaningful line of code. The script forces clarity about what the project is.
A demo script for a hackathon project should fit on one page and include:
- The problem in one sentence, framed around a specific person
- The "before" state — what someone does today
- The trigger — what action starts the demo
- The "aha" moment — the specific thing the judges should remember
- The close — why this matters at scale
If you cannot write this script before you start coding, you do not know what you are building yet. Stop and figure it out. Two hours spent on the script saves six hours of building features that don't appear in the final demo.
The final stretch
7. Treat the last four hours of the hackathon as a separate project
The end of a hackathon is not "more building time." It is a different phase entirely, with its own deliverables: a polished demo, a submission video, a deck, written documentation, and submitted code.
In the last four hours of a 24-hour event, do not start new features. Do not refactor. Do not "just fix this one bug." The bug will spawn three more. Lock the code, then:
- Record the demo video — twice, so you have a backup
- Walk through the live demo five times to find the points where it breaks
- Build the slide deck if your event requires one
- Write the README so judges who don't see your demo can still evaluate you
- Submit everything 30 minutes before the deadline, not 30 seconds
The teams who submit at the deadline buzzer are usually the teams whose demo doesn't quite work. The teams who submit early have time to fix the things they find while testing.
8. Optimize the hackathon demo for the room, not for technical correctness
A demo that runs on localhost with a flaky API call is a demo that will fail in front of judges. The conference Wi-Fi will drop. The third-party service will rate-limit. The laptop will run out of battery at the worst possible moment.
Hardcode your demo path. Mock the external services. Have screenshots ready as a fallback. If your project depends on an LLM call, have a cached response ready for the demo if the live call fails. Judges do not penalize you for "the demo gods being unkind" — they penalize you for not making it to the punchline.
This advice will offend a certain kind of engineer who thinks demos should reflect production reality. They are not wrong about production. They are wrong about hackathons. The judge has six minutes per team and will not see your beautifully resilient retry logic. They will see whether the screen showed the thing or didn't.
9. Pitch the hackathon problem harder than the solution
Most teams demo their solution and assume the problem is obvious. It is not. Judges sit through 30 to 100 demos. The teams whose problem statement lands are the teams who get remembered.
A strong hackathon pitch spends roughly 30% of its time on the problem and 70% on the solution. Most teams do 5% on the problem and 95% on the solution, then are surprised when judges score them low on "impact."
If your problem is "developers spend too much time on X," tell us how much time, in what context, with what consequences. If your problem is "small businesses struggle with Y," tell us about one specific small business. Specificity is the difference between a problem judges remember and a problem they forget by the next team's demo.

10. Submit your hackathon project even if you think you lost
Plenty of teams who think they bombed end up placing. Plenty of teams who think they nailed it don't. The judging criteria you assumed were dominant may not have been. The category you didn't realize you qualified for may pay out.
More importantly, the submission itself is valuable independent of the result. Your code goes into your portfolio. The project becomes a conversation piece in interviews. The team you built with may become collaborators on something else.
The developers we see consistently win hackathons over time have lost more hackathons than the developers who give up after one bad result. This is not a motivational point — it is an observation about which demographic shows up in the winners' circle five years in.
What hackathon organizers reward, and why
The 10 tips above optimize for a specific reality: hackathon judging is fast, partial, and demo-dependent. Judges form opinions in the first 30 seconds and spend the rest of the demo looking for evidence to support those opinions. The ACM SIGCHI research on hackathon evaluation backs this up — early impressions dominate scoring decisions.
This is not because judges are lazy. It is because judging 40 demos in a day forces shortcuts. The teams who understand this design their entire approach around the first 30 seconds — the hook, the problem statement, the visible "aha." The teams who don't, build great projects that lose to worse projects with better openings.
For developers reading this who run or sponsor hackathons inside your own company, this asymmetry is worth thinking about. The teams that win your internal events are not necessarily the teams building the most valuable things. They are the teams best at communicating value under time pressure. If you want different outcomes, design different judging — longer evaluations, written submissions, follow-up calls with finalists.
A note on the source of these patterns: Based on our experience designing and running hackathons for 500+ global enterprise customers, organizers who design judging carefully get better projects. Organizers who copy a generic rubric get the same demo-driven optimization every time. To learn more about how structured hackathon programs support innovation discovery, developer engagement, or platform adoption goals, see HackerEarth Hackathons.
Frequently asked questions about winning a hackathon
How do I pick a winning hackathon idea?
Pick a problem you can finish in the allotted time, not one you want to solve. A winning hackathon idea has three traits: the core demo works without external dependencies, a judge can understand it in under 30 seconds, and the "wow" moment lands in the first minute of the demo. Scope down aggressively until your idea passes all three tests.
What makes a good hackathon team?
A good hackathon team is built around skill gaps, not friendships. The minimum effective team has one fast frontend developer, one backend/infrastructure developer, one strong presenter who owns the pitch and demo script, and one generalist who debugs and integrates. A team of four backend engineers, no matter how skilled, almost always loses to a balanced three-person team.
How important is the demo at a hackathon?
The demo is usually the single most important factor in hackathon outcomes. Judges typically see 30–100 demos and form opinions in the first 30 seconds. Optimizing the demo path — hardcoded inputs, cached API responses, screenshots as fallback — matters more than production-quality code. Write the 90-second demo script before you write any code.
Should I use AI coding tools during a hackathon?
Yes, but selectively. Use AI coding assistants for boilerplate, scaffolding, and API integration — the 80% of code that doesn't differentiate your project. Write the novel logic yourself, because judges will ask about it in Q&A and you need to be able to explain it. Teams that AI-generate their differentiated logic tend to lose on technical questioning.
How long before the deadline should I submit?
Submit at least 30 minutes before the deadline, not 30 seconds. Treat the last four hours as a separate phase dedicated to recording the demo video twice, walking the live demo five times, writing the README, and locking the codebase. New features added in the final hours almost always introduce bugs that show up during judging.
What if I think my team lost — should I still submit?
Always submit. Plenty of teams who think they bombed end up placing because their judging category or weighting was different than they assumed. Beyond placement, the submission itself becomes a portfolio piece, an interview talking point, and a foundation for follow-on work with your teammates.
Next steps
If you run hackathons inside your organization — for innovation discovery, developer engagement, or platform adoption goals — the way you structure the event determines what kind of work you get back. Run your next enterprise hackathon with HackerEarth Hackathons to design judging that surfaces the projects you actually want, or launch a HackerEarth Sprint to drive measurable developer engagement beyond participation counts.










