Articles
How to win an AI hackathon
Build the right team, pick a problem you can demo, aim at the event's criteria, and follow a 72-hour plan from locking the idea to submitting early.
By Starfield LabsPublished

Winning an AI hackathon comes down to four things: a focused problem, a working demo early, a clear view of how the event scores projects, and a short, honest pitch. Teams that get all four often place above teams with stronger engineers who lost focus or ran out of time. This piece covers the team, the problem, the criteria and a 72-hour plan, plus the mistakes that cost the most.
It builds on three other pieces. For the shape of an event and what to pack, read What to expect at your first AI hackathon. For a sample rubric with score levels, read How hackathon judges score projects. If you do not code, read AI hackathons for beginners with no coding experience.
Who should be on the team?
Strong AI hackathon teams cover four roles. One person can hold two of them.
| Role | What they own |
|---|---|
| AI engineer (one or two) | Calling the model, writing and testing its instructions, the backend |
| Front end or full stack | The screens a judge will actually click |
| Problem expert | Checking that the problem is real and the answer fits the people who have it |
| Pitch lead | The video, the write-up and any slides; presents the project |
You can enter alone, and a team of one counts as a team on Starfield Labs. Still, a team of three or four can split the work above and keep going when one person is stuck. Find teammates before the start if you can: the Starfield Labs Discord and the event's team finder are the places to look. Hours spent forming a team after the start are hours not spent building.
How do you choose a problem you can demo in time?
The most common reason teams fall short is a problem that sounds impressive but needs data, training time or infrastructure nobody can assemble in a weekend. Test each idea against four rules:
- It runs on models you can call today. You are building on top of a hosted or open-weight model, not training your own.
- Something clickable exists by the end of the first day. If you cannot picture a rough version working by hour 24, the scope is too big.
- There is a real user. "A nurse who spends an hour a shift on handover notes" beats "the healthcare industry".
- The value is clear in 30 seconds. If a judge cannot see what the project does from its first screen, it starts behind.
For ideas sized to a weekend, with what to cut from each, see AI hackathon project ideas you can demo in a weekend.
How do you aim at the judging criteria?
Each event on Starfield Labs sets its own judging criteria, and judges score each project against them. Look for them on the event's page and in its rules, and read them before you pick an idea, not after you build. Starfield Labs starts every event with four default criteria, each weighted the same, which the organizers may keep or change:
- Innovation. Is the idea new, or a fresh angle on an old problem? Ask yourself whether this only became possible with today's models. An existing product with a chat box added rarely scores well here.
- Technical execution. Is it well built, and does it work? A demo a judge can run, a repository with real work across the event, and a model that does real work all count.
- Impact. How useful is it, and for whom? Name a specific user, the problem they have, and what changes for them. Some events also ask about a business case; if yours does, add a short note on who would pay and why.
- Presentation. How clearly does the team explain and show it? Clarity beats production value.
Your event's criteria may differ, and an event with a partner theme may add its own. Score your project against the real list a few hours before the deadline, and fix the lowest weighted score first.
How should you structure the demo video?
When an event asks for a video, a clear structure helps judges follow it. A plan for about four minutes:
| Time | What to show |
|---|---|
| 0:00 to 0:30 | The problem, for whom, and why it matters now |
| 0:30 to 2:30 | The project working on real input, on the path you rehearsed |
| 2:30 to 3:30 | Why it matters: the user, the impact, and a business case if the event asks for one |
| 3:30 to 4:00 | The team, what does not work yet, and what comes next |
Keep to the event's limits on length and format, and check them early. A short video that explains the problem and shows the project working beats a polished one that buries the demo.
What does a 72-hour plan look like?
Here is a sample plan you can adapt to your event's timeline. For a 48-hour event, keep the order and shrink each block.
Hours 0 to 6: lock the idea. Do not write code until the team agrees on one idea. Run a short idea session, pick the idea with the strongest demo moment, and write a one-sentence problem statement where everyone can see it. Read the event's rules and its submission form now, so nobody is surprised at the end.
Hours 6 to 24: build the core loop. Get the single most important interaction working end to end. If the project summarizes documents, get a real document going in and a real summary coming out. No settings pages, login or onboarding until the core loop works.
Hours 24 to 48: polish the demo path. Decide the exact sequence of screens and actions you will show. That path is the product for now. Fix every bug on it, and leave the bugs off it for later. Keep a working copy of the demo at all times, and try changes on a separate copy.
Hours 48 to 60: record the video and write the submission. Record early, since you may need to record again if something breaks. Write the summary and the README while the details are fresh. If the event asks for slides, keep them to about eight to ten: problem, solution, a screenshot of the demo, the user and the impact, the team, and next steps.
Hours 60 to 72: submit and prepare for questions. Submit with time to spare, then check every link and file in what you submitted. On Starfield Labs you can keep editing a submitted project until the deadline, so an early submit costs nothing. Use the last hours to prepare for judges' questions, not to add features.
Which mistakes cost the most?
- Changing the idea after hour 12. A new problem halfway through almost always means a weaker submission.
- One big commit at the end. Judges may look at your repository, and steady commits across the event make the work easy to trust.
- A demo only you can run. A project that works only on one laptop is hard to judge. If the event asks for a demo link, deploy early and test it from another device.
- Too much machinery in the AI layer. Chaining five model calls where one would do adds delay and more ways to fail. Keep the model's part simple and reliable.
- Overclaiming. Say what the project does not do yet. Judges notice when a demo is staged.
- Leaving the submission to the last minute. Uploads fail, links break and forms ask for things you did not expect.
Where to go next
- The whole field and how taking part works: AI hackathons: the complete guide
- Choosing a model and a stack: Best AI APIs for hackathons
- Submissions, teams and rules on Starfield Labs: the Help desk
When you have a plan, find an event at starfieldlabs.ai/ai-hackathons and enroll.
Keep reading
Related articles and tutorials
- Tutorial

PaLM2 Tutorial: Create your own AI-powered Virtual Assistant
AI hackathon tutorial: build a chat-style virtual assistant with Google's PaLM2 API and a Streamlit app in Python, step by step.
- Article

Best AI APIs for hackathons
How to choose a model API for a hackathon project, what Claude, GPT, Gemini, IBM Granite and open-weight models are each good at, and how to keep your stack small. Facts checked 2026-11-19.
- Article

AI hackathons: the complete guide
What an AI hackathon is, who runs them, what teams build, what you can win, and how to take part on Starfield Labs from enrolling to submitting.
- Tutorial

OpenAI Whisper tutorial: How to use Whisper to transcribe a YouTube video
AI hackathon tutorial: download YouTube audio with Pytube and transcribe it with OpenAI Whisper in a few lines of Python.