Planning for what happens after the hackathon decides whether a weekend prototype becomes a lasting project or a forgotten repository. The first steps are ownership, licensing, documentation and an honest team conversation.
Most prototypes are built under time pressure, so the choices made once the event closes matter more than the demo itself. The wider story of online events is told in the covid-19 hackathon hub guide, which this page complements.
This guide is an independent editorial resource. It is not run by any hackathon organiser, platform, sponsor, university or public body, and it takes no entries, registrations or payments.
What usually happens once the demos are over
When judging ends, a team is left with a working but fragile prototype, a repository full of shortcuts, and a group of tired people with different plans. Some members want to move on to the next event. Others want to keep building. A few may want to turn the idea into a business. None of those outcomes is wrong, but they need to be named early, because a team that never talks about them tends to drift apart by default.
A useful way to frame the conversation is to separate three questions. First, who wants to keep working on the project, and for how long? Second, who owns the work, and under what terms was it entered into the event? Third, what is the smallest next step that proves the idea is worth more effort? Answering them in this order avoids the common trap of spending weeks polishing code that nobody has the right, or the time, to continue.
For people who are new to the format, the earlier stages are covered in the hackathon for beginners checklist, and the sign-up side is explained in the guide on how to join a hackathon. This page picks up where those end.

Deciding whether the prototype deserves a second life
Enthusiasm at the end of an event is not evidence. A better test is to look at what the prototype actually demonstrated. Did it solve a real problem for a real group of users, or did it mainly show off a clever technique? Did anyone outside the team try it and ask for more? Could the core idea survive without the sponsor’s application programming interface or the free credits that came with the event?
It also helps to be honest about the rough edges. Prototypes often hard-code data, skip authentication, ignore accessibility and store personal information carelessly. For anything that handles personal data, the shortcuts taken for a demo should be reviewed before real users touch it, in the same spirit as the privacy principles discussed elsewhere on this site.
If the answer to most of these questions is no, there is nothing shameful in shelving the project. A short write-up of what was learned, a tidy repository and a clear note in the README that the work is archived is a perfectly good outcome. If the answer is yes, the next step is to settle who owns what.
Ownership and licensing come first
Many teams assume that because they wrote the code, they can do anything with it afterwards. Often that is true, but the rules of the specific event decide. On the Devpost platform, the terms of service state that, as published when this page was prepared, makers retain title and ownership of their software and submissions unless the official rules of a hackathon clearly require a transfer and an award is actually paid. That means the entry rules, not the platform default, are the document to read.
Other organisers word it differently. The official rules of one large cloud-vendor contest state that all submissions remain the intellectual property of the individuals or organizations that developed them, while still granting the sponsor a licence to use the entry for the contest. A team that wants to continue should read the rules page of its own event, note any licence granted to the organiser, and keep a copy, because the page may be taken down once the event is over.
Team ownership matters too. If several people wrote the code, each of them may hold rights in it, depending on the law and any agreement between them. A short written note, signed or confirmed by every member, that says who contributed what and how the project may be used avoids arguments later. This is general information rather than legal advice, and teams with commercial plans should speak to a qualified lawyer.
Then there is the licence on the code itself. The maintainers of the choosealicense.com site explain that a creative work, including code, is under exclusive copyright by default and that without a licence nobody else can copy, distribute or modify it without risk. GitHub’s open source guides add that making a GitHub project public is not the same as licensing it. A repository pushed to a public page at the end of a hackathon, with no licence file, therefore invites interest but gives other people no clear permission to build on it.
Turning a demo repository into something others can use
A prototype repository is written for the people who made it. A project that is meant to last has to be understandable by a stranger. The open source guides recommend that a project include an open source licence, a README, contributing guidelines and a code of conduct, which together set expectations and protect everyone involved.
In practice the first clean-up pass usually covers these items:
- Write a README that says what the project does, who it is for, how to run it and what state it is in.
- Remove API keys, passwords and private data from the history, and rotate any credential that was ever committed during the rush.
- Replace hard-coded values with configuration, and document the settings.
- Add a licence file that matches the decision the team made about ownership.
- List the known shortcuts honestly, as issues, so that newcomers know where the weak points are.
Turning the shortcuts into written issues is more useful than it sounds. The guidance on building a community advises maintainers to try explicitly labeling issues that are simple enough for beginners to tackle, which gives new contributors a way in. A hackathon team that still has energy can use the same approach to recruit help from other people who liked the demo.
Projects that accept outside contributions also need a policy on who may contribute what. The same guides on legal matters describe how a simple contributor agreement might require contributors to confirm, with a click, that they have the rights necessary to contribute under the project licence, while heavier versions can require legal review. Small projects often choose the simplest approach that fits their risk.
Open source, portfolio piece or small organisation
After the clean-up, teams usually settle on one of three paths, and it is possible to move between them later.
Open source project
If the aim is public benefit, as with many civic and health tools, a public repository with a clear licence and a small, responsive group of maintainers is often the best fit. It spreads the workload and lets other people adapt the tool to their own city or community. The cost is attention: someone has to answer questions, review changes and keep the documentation current, or the project quietly goes stale.
Portfolio piece
Some participants simply want a finished, presentable example of their work. In that case the goal is quality rather than growth: a short case study, a stable demo, a clean commit history and a clear explanation of the individual contribution. This path needs the least coordination and is the easiest to combine with study or a full-time job.
Small organisation or business
Where the team wants to charge for the product or accept funding, a legal structure becomes necessary. The United States Small Business Administration notes that a business structure affects the ability to raise money, the paperwork to file and personal liability, which is why the choice is usually made before taking money. Rules differ by country and state, and a qualified adviser should confirm the details for a specific team.
Keeping the team and the momentum going
Whatever the path, the project survives only if somebody keeps working on it. A few habits help ordinary teams keep going after the adrenaline of the event wears off.
- Pick a modest next milestone, such as a working version for one real user, rather than a long roadmap.
- Agree on a regular, short meeting time, and a place to record decisions so that absent members can catch up.
- Name one person as the maintainer for each area of the code, so that questions have an owner.
- Decide in advance what happens if a member leaves: who keeps the access, the domain names and the accounts.
- Thank the people who helped, including mentors and organisers, and tell them what became of the project.
It is also reasonable for the plan to be smaller than the original pitch. Many lasting projects started as a single feature that people actually used, and grew from there. A team that has already worked through roles and communication during the event, as described in the other hackathon guides on this site, has a head start.
Finally, remember that the event itself was a snapshot. Judges, sponsors and prizes are gone the next day, but the code, the notes and the relationships remain. Handled well, those are the real result of the weekend.
Frequently asked questions
Can a team keep working on a project after the event?
Usually yes, but the official rules of the specific event decide. Platforms such as Devpost state in their terms that makers keep ownership unless the rules clearly require a transfer, so read the rules page for your event and, if needed, ask a qualified lawyer.
Does making a repository public mean other people can reuse it?
Not automatically. Public hosting lets others view and fork a repository under the host’s terms, but reuse beyond that depends on the licence. Add a licence file so that the permissions are clear.
Should every hackathon project become a company?
No. Many projects are better as open source tools, learning exercises or portfolio pieces. A company structure makes sense only when the team intends to take money or sell something.
What should be cleaned up before sharing the code?
Remove secrets and personal data, write a README, add a licence, and list the known shortcuts as issues so that newcomers understand the current state.
