10 Tips to Win a Hackathon: A Developer's Playbook
Estimated read time: 8 minutes
How do you win a hackathon? In our experience running hackathons, 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.
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.
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
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. The MLH Organizer Guide notes that published criteria are intended to guide judges, though judges ultimately retain discretion over which projects they find most impressive.
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. For more inspiration on scoping, see this list of 50+ hackathon ideas spanning beginner to advanced difficulty.
3. Form your hackathon team around skill gaps, not friendships
In our experience, the four-person team of backend developers is one of the most common losing configurations 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. For more on team composition, see how to form a winning team for hackathons.
During the hackathon 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.
In our experience, 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. Recent developer surveys, including the Stack Overflow Developer Survey, report that roughly 76% of developers are using or plan to use AI tools in their 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 of the hackathon
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.
In our experience, strong hackathon pitches spend far more time on the problem than most teams do — closer to a third of the pitch on the problem, rather than a token sentence or two. Teams that give the problem almost no airtime are often 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. In our experience, judges form opinions within the first 30 seconds of a demo and spend the rest of it looking for evidence to support those opinions — which is why the strategic decisions a team makes in the first couple of hours (what to build, how to frame it) tend to determine the outcome. Across the hackathons HackerEarth has run, this pattern is consistent: 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.
Organizers who design judging carefully tend to get better projects; organizers who copy a generic rubric tend to get the same demo-driven optimization every time.
Frequently asked questions about winning a hackathon
How do I pick a winning hackathon idea?
Work backwards from the judging rubric, not forwards from your interests. If the rubric weights innovation highly, a clever twist on a familiar problem beats a familiar take on a novel one; if it weights technical complexity, pick a problem that justifies real depth in one subsystem rather than shallow coverage of three. The counterintuitive move: ideas that sound boring in a one-line pitch often win, because they leave room for the demo to overdeliver, while ambitious ideas set expectations the build cannot meet.
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. That buffer exists for the failure modes you cannot predict: submission portals slow to a crawl in the final minutes as hundreds of teams upload at once, video files fail to attach, GitHub repos turn out to be private, and devpost-style forms silently reject fields you thought you completed. A 30-minute buffer lets you refresh the page, re-upload a corrupted video, flip a repo to public, or email organizers while they are still responsive — none of which is possible at T-minus-30-seconds.
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. HackerEarth Hackathons supports configurable judging rubrics, multi-round evaluation, and submission workflows designed for enterprise scale — run your next enterprise hackathon with HackerEarth Hackathons to design judging that surfaces the projects you actually want.



