DoraHacks

Turning Hackathons into a Growth Engine

Running one hackathon could be easy. Running a series that keeps attracting developers, producing real projects, and growing an ecosystem is a different game entirely.
Stacks figured it out. As a Bitcoin Layer 2 that brings smart contracts and dapps to Bitcoin, they've hosted 9 hackathons on DoraHacks since 2025. What started as individual events evolved into a system, which has become a model for how to build a developer community through hackathons.
A System, Not a One-Off
Most teams treat hackathons like marketing campaigns. Launch one, collect some submissions, announce winners, move on. Stacks did something smarter: they built a portfolio.
Their hackathons cover different angles. Some spotlight core products or tools like sBTC(https://dorahacks.io/hackathon/stackschallenge), Turnkey(https://dorahacks.io/hackathon/embedded-wallet), or USDCx(https://dorahacks.io/hackathon/stacks-usdcx), giving developers hands-on reasons to try new tools. Others ride industry waves, like vibe coding(https://dorahacks.io/hackathon/stacks-vibe-coding) or the x402 protocol(https://dorahacks.io/hackathon/x402-stacks). Some target specific regions, with dedicated events(https://dorahacks.io/hackathon/pitch-your-buidl-denver) for Latam developers or tied to ETHDenver. And once a year, they go big with BUIDL Battle: The Bitcoin Builders Tournament(https://dorahacks.io/hackathon/buidlbattle), a global competition open to anyone building on Bitcoin.

Why the variety? Different hackathons reach different people. A developer in São Paulo might skip a generic global event but show up for something designed for their region. Someone curious about AI-assisted coding might not care about protocol-specific challenges but will jump at a vibe coding hackathon. By diversifying their hackathon portfolio, Stacks casts a wider net and creates multiple entry points into their ecosystem.
The lesson for organizers is simple: think about what different segments of your target audience care about, and design events that speak to each of them.
Clear Rules, No Guesswork
Ambiguity kills participation. When developers don't understand what a hackathon is looking for, they either don't enter or they submit projects that miss the mark. Either outcome wastes everyone's time.
Every Stacks hackathon has a defined theme and explicit rules from day one. Eligibility requirements, submission formats, deadlines, and judging criteria are all published from day one. Participants don't have to guess whether their project qualifies or wonder how winners will be selected. This clarity has two benefits: it reduces the number of questions organizers have to answer, and it ensures that submissions are actually comparable when judging begins.

Specificity isn't limiting, it's focusing. The best hackathon submissions often come from constraints that force creative problem-solving within a defined space.
Be Responsive and Reliable
A hackathon isn't just a submission portal. It's a temporary community, and communities need communication.
The Stacks team stays engaged throughout every hackathon. They use DoraHacks' built-in messaging features, respond to questions in the dedicated “Ask Questions” section, and maintain presence in external channels like Discord or Telegram when needed. Participants building under deadline pressure can actually get help when they need it. This responsiveness matters more than many organizers realize.

Equally important is what happens when the hackathon ends. The Stacks team announces winners on time, every time. No delays, no vague "we're still evaluating" updates that stretch for weeks. Participants who invested effort into their submissions deserve a clear outcome, and prompt announcements respect that investment.
This reliability builds trust, and the opposite is also true: teams that go silent after submission deadlines or take months to announce winners develop reputations that hurt their future hackathons.
Scaling with Good (AI) Tools
The reason why Stacks keeps using DoraHacks(https://dorahacks.io/hackathon) to organize hackathons is based on some practical realities. One of them is that successful hackathons attract a lot of submissions. That's a good problem to have, but it's still a problem. Stacks handles the volume using DoraHacks' Hackathon AI features.
The AI screens submissions in real time, checking whether projects meet the stated requirements and flagging issues with clear reasoning. Incomplete entries, off-theme projects, and eligibility violations get caught automatically instead of eating up hours of human review time.
For final judging, the AI generates a shortlist of top candidates based on the winning criteria for each prize. Judges focus their attention on the strongest contenders rather than sorting through everything by their own eyes. Human judgment still makes the final call, but the filtering happens at machine speed.

The broader point applies beyond AI tools: as your hackathons grow, your processes need to scale with them. Whether that means adding extra manpower, inviting more judges, or building more SOPs for the team. But all of these could be time-consuming and even expensive. DoraHacks’ Hackathon AI OS(https://dashboard.dorahacks.io/premium) was just born to solve this.
The Formula
In 2026, Stacks keeps launching hackathons(https://dorahacks.io/org/3197) timed to new trends and community needs. Each one builds on lessons from the last. Developers who joined one event come back for another while new hackers keep joining. The community compounds through steady, repeated engagement rather than any single viral moment.
Their formula isn't complicated: dedication to showing up consistently and following through on commitments, good ideas that connect hackathon themes to what developers actually care about, and good tools that make scale manageable.
That formula works whether you're a blockchain protocol, a university club, or a tech giant trying to attract your first developers. Hackathons grow communities when organizers commit to running them well. Stacks shows what that commitment looks like over time.

*Stacks hackathons are hosted on DoraHacks. Explore upcoming events or start organizing your own at dorahacks.io.
About DoraHacks
DoraHacks(dorahacks.io) is the leading global hackathon community and open source developer incentive platform. DoraHacks provides toolkits for anyone to organize hackathons and fund early-stage ecosystem startups.
DoraHacks creates a global hacker movement in Web3, AI, Quantum Computing and Space Tech. So far, more than 30,000 startup teams from the DoraHacks community have received over $92M in funding, and a large number of open source communities, companies and tech ecosystems are actively using DoraHacks together with its BUIDL AI capabilities for organizing hackathons and funding open source initiatives.
Website: https://dorahacks.io/Twitter: https://twitter.com/DoraHacksDiscord: https://discord.gg/gKT5DsWwQ5Telegram: https://t.me/dorahacksofficialBinance Live: https://www.binance.com/en/live/u/24985985Youtube: https://www.youtube.com/c/DoraHacksGlobal

Par Steve Ngok, Directeur de la stratégie, DoraHacks
Introduction
Chaque entreprise construisant une plateforme pour développeurs dit la même chose : "Nous sommes entièrement consacrés à l'écosystème des développeurs." Elles engagent des équipes DevRel. Elles parrainent des hackathons. Elles remplissent les serveurs Discord de milliers de constructeurs pleins d'espoir. Puis elles regardent, confuses, alors que leur écosystème échoue à croître.
Voici la vérité inconfortable : la plupart des entreprises n'ont pas une bonne équipe DevRel pour commencer. Elles sont en sous-effectif, mal formées ou considérées comme un après-coup. Mais voici ce qui est pire : même les entreprises qui investissent massivement dans DevRel atteignent le même plafond. Une grande équipe DevRel de 10 personnes ne peut pas soutenir de manière significative 10 000 développeurs. Leur capacité a des limites strictes. Et ces limites deviennent celles de votre écosystème.

Vous avez passé des heures (peut-être des jours) à construire quelque chose dont vous êtes fier. Mais un projet solide ne garantit pas une soumission solide. La façon dont vous présentez votre travail compte tout autant que le travail lui-même. Les juges examinent des dizaines voire des centaines de soumissions, et celles qui se démarquent sont claires, complètes et faciles à évaluer.
Ce guide couvre ce qui sépare les soumissions gagnantes des soumissions oubliables.
0. Avant tout, lisez attentivement les exigences
Cela peut sembler évident, mais c'est là que de nombreux hackers trébuchent. Avant de commencer à rédiger votre soumission, lisez attentivement les exigences de soumission du hackathon. Comprenez ce qui est obligatoire, ce qui est optionnel et quel format est attendu.

By Steve Ngok, Chief Strategy Officer, DoraHacks
I just returned to Singapore from the US and noticed a lot has changed compared to last year. Progress, I'd say. When it comes to developer events, Singapore is getting closer and closer to San Francisco. Many leading tech giants and AI companies are setting up offices here, expanding their teams, and actively organizing developer events to grow their presence in Asia.
When I was chatting with a new friend from OpenAI's Singapore office about recent hackathons I've organized and attended, he asked me: "What's the vibe like at these hackathons lately?"
I paused for a moment.
I. What is Vibe Coding?
At DoraHacks(dorahacks.io), my mission is to design, launch, and organize hackathons with our partners. Since the rise of large language models and ever-evolving developer tools, vibe coding has become the central theme of my work.
If you haven't heard of vibe coding yet, it's the hottest term in the developer community in 2025, and probably will still be in 2026.
Ask AI, and it'll tell you: vibe coding is building products without writing code yourself. Instead, you use LLMs and advanced developer tools—just input simple instructions, and agents automatically design and develop products for you.
But breaking down the term and reflecting on my recent experiences, I believe vibe coding is a creative process where vibe comes first, then code.
The "vibe" is the creator's taste, aesthetics, intuition, and experience.
Vibe coding is the realization of that taste and aesthetics, the execution of intuition and experience, letting high-speed agents help bring products to life and iterate rapidly under the creator's direction.

II. Hackathons in the Post-Vibe-Coding Era
If you're reading this, I'll assume you're familiar with traditional hackathon setups.
In the post-vibe-coding era, hackathons have new formats, new definitions, and new purposes.
With vibe coding, you can deliver working products at incredible speed. Hackathon outputs have evolved from minimum viable products to highly usable, feature-rich products.
Because of this, hackathon design and rules become critically important.
Traditional rules prohibited over-reliance on AI.
Now, the expectation is to embrace AI—the more fluently you use it, the better.
Traditional bounties asked you to build something specific but perhaps a bit boring.
New challenges can be: "Build a tool people can't help but share" or "Build something you'd actually use every day."
Traditional hackathons typically had a 48-72 hour window.
Vibe hackathons could be 6-24 hours, organized weekly or monthly. Failure is allowed. Looking like a toy is allowed. Half-finished is allowed.
Traditional judging focused on product completeness and potential value.
New criteria: Would someone actually use your product for more than 3 minutes? Would they share it with others?

III. Who Should Run Vibe Coding Hackathons?
With vibe coding in the mix, hackathons should become a culture: rapid innovation, rapid iteration, constantly honing judgment, aesthetics, and intuition.
Code is no longer scarce. People with vibes are the new scarce resource.
So who should be organizing these hackathons? Here are some examples for you (AWS/Amazon Developer Tools [https://dorahacks.io/hackathon/awsvibecoding/detail] and blockchain layer-2 Stacks [https://dorahacks.io/hackathon/stacks-vibe-coding/detail]). In general, three types of players are best positioned:
1. Developer Tools Companies
If you're building tools that developers use to create, you should be running hackathons constantly. Your hackathons showcase what's possible with your stack, build community, and discover power users.
OpenAI should run Codex-focused hackathons, pushing developers to explore AI-native codingMicrosoft can run Azure AI and GitHub Copilot hackathons with their integrated ecosystemNVIDIA should organize hackathons around GPU-accelerated tools and inference APIs like NIM and NeMoCloudflare can host Workers and edge computing hackathons, challenging developers to build fast, globally distributed appsAnthropic with Claude Code, Cursor with their AI editor, Vercel with v0 and Next.js... the list goes on
Every developer tools company should ask: "Are we running enough hackathons?"
2. Companies with Vertical Use Cases
Enterprises with real-world problems and proprietary data are goldmines for hackathon challenges. They bring:
Authentic scenarios that can't be googledReal data (anonymized when needed)Clear success metricsPotential to adopt winning solutions
Their goals: internal innovation (solving problems that seemed unsolvable, improving efficiency in ways that weren't possible before) and talent discovery (finding the builders who "get it").
3. The Power Combo: Tools + Enterprise
Developer tools companies often have major enterprise clients. Why not co-organize?
Imagine AWS partnering with DBS Bank to run a fintech hackathon. Or Microsoft and a healthcare company co-hosting a medical AI challenge. The tools company brings the platform and developer community; the enterprise brings the real-world context and problems worth solving.
These partnerships create hackathons that are both technically exciting and commercially meaningful.
IV. How Often Should They Run?
The short answer: Anytime, Anywhere; All the time, Everywhere.
Traditional thinking says hackathons are big, expensive events you run once or twice a year. That model is outdated.
In the vibe coding era, hackathons should be:
Frequent: Weekly or monthly, not annuallyLightweight: 6-24 hours, not 48-72Always on: Running continuously across time zones and communities

The bottleneck used to be logistics, cost, and coordination. But with the right tools, this bottleneck disappears.
DoraHacks(dorahacks.io) helps developer tools companies and enterprises achieve "hackathons everywhere, all the time" through automated hackathon infrastructure and DevRel tooling. Submission management, judging workflows, prize distribution, community engagement—all streamlined so you can focus on the builders, not the operations.
The companies that embrace this will build the strongest developer ecosystems. The ones that stick to annual hackathons will fall behind.
So, when shall we expect the next cool vibe coding hackathon hosted by yourself?
About DoraHacks
DoraHacks(dorahacks.io) is the leading global hackathon community and open source developer incentive platform. DoraHacks provides toolkits for anyone to organize hackathons and fund early-stage ecosystem startups.
DoraHacks creates a global hacker movement in Web3, AI, Quantum Computing and Space Tech. So far, more than 30,000 startup teams from the DoraHacks community have received over $92M in funding, and a large number of open source communities, companies and tech ecosystems are actively using DoraHacks together with its BUIDL AI capabilities for organizing hackathons and funding open source initiatives.
Website: https://dorahacks.io/Twitter: https://twitter.com/DoraHacksDiscord: https://discord.gg/gKT5DsWwQ5Telegram: https://t.me/dorahacksofficialBinance Live: https://www.binance.com/en/live/u/24985985Youtube: https://www.youtube.com/c/DoraHacksGlobal

Par Steve Ngok, Directeur de la Stratégie, DoraHacks
Nous sommes en 2026. L'ère de la consommation passive de technologies est révolue. L'IA dévore le logiciel. Le code écrit du code, et les idées deviennent des applications en un clin d'œil.
Dans cette réalité, la vitesse est la seule monnaie qui compte. L'écart entre une idée et un produit expédié s'est effondré de mois à minutes. Si vous êtes PDG ou fondateur, prenez note : il n'y a qu'un seul endroit où l'avenir se forge en temps réel - les hackathons.
Vous trouverez des développeurs en profonde concentration, courant contre la montre pour transformer des idées brutes en prototypes fonctionnels. L'environnement frénétique récompense la vitesse et la créativité, incarnant la culture d'innovation à un rythme effréné de 2026. Des produits naissent, des technologies sont testées sous pression, des talents sont identifiés, et ceux qui émergent victorieux ont été prouvés dans l'arène la plus difficile que le logiciel puisse offrir.

Why (Good) Management Matters
Good management doesn't guarantee a successful hackathon, but neglecting it almost guarantees failure. If organizers go silent - no communication, no support, no ongoing promotion - participants lose confidence and momentum. Energy drains from the event, submissions drop off, and sponsors notice.
The live phase is where your preparation of the hackathon gets tested. Unexpected issues will arise, and how you respond defines your hackathon's reputation. Good management also protects your team from burnout. With clear processes in place, you can handle challenges calmly and still have energy for the finish line.
1. Keep Promotion Active Throughout
Marketing shouldn't stop once registration opens. Sustained promotion maintains momentum, attracts late-deciding participants, and builds visibility for your sponsors.
Leverage every channel available: newsletters, social media, and developer communities where your audience gathers. Collaborate with sponsors and partners by providing ready-to-use graphics and copy, and ask them to share through their own channels. A single mention from a well-known sponsor can sometimes outperform a week of your own posting.
Also remember to schedule your pushes strategically. A reminder before registration closes is significant, which catches people who intended to sign up but forgot. Announcing new judges or prizes or organizing new online/offline side events mid-hackathon can also reinvigorate interest.

2. Communicate with Hackers Promptly
Hackers always have questions, and responsive communication is one of the most impactful things you can do. Participants who wait hours for answers lose momentum and may abandon their projects - or worse, never start at all.
Set up dedicated support channels and make them easy to find. Aim to acknowledge questions daily, even if a full answer takes longer. When multiple people ask the same thing, update your FAQ or send an announcement to address it for everyone.
Platforms like DoraHacks provide built-in communication features that help organizers broadcast announcements and keep participants informed without juggling multiple tools. You can chat with hackers via private message, send group messages to specific segments of participants, and use the AI-powered Q&A tool to handle repeated questions automatically. Time saved, energy saved.

If your hackathon spans multiple time zones, consider designating team members to monitor channels during different periods so questions don't pile up overnight.
3. Provide Developer Resources
The resources you provide can make the difference between a completed project and an abandoned one. Share relevant documentation, tutorials, and starter templates. If sponsors offer tools or APIs, ensure their documentation is accessible and participants know how to get support.

Consider organizing office hours where participants can get help from mentors. Create a space for peer support — a dedicated channel for technical questions often reduces the load on your team while building community.
Monitor for common blockers and address them publicly with workarounds before they derail multiple teams.
4. Monitor Submissions and Stay Patient
Don't wait until the deadline to review what participants are building, but also don't panic if submissions are slow at first. The peak of submissions typically comes in the final week. Hackers need time to build, write documentation, create demos, and polish their work. Many are also balancing other commitments and, like everyone else, tend to procrastinate.

Keep doing what an organizer should do: promote, communicate, support. Check early submissions to see whether participants understand the requirements. If you notice widespread confusion, clarify your guidelines publicly while there's still time for teams to adjust.
DoraHacks' organizer dashboard lets organizers track submission progress in real time, making it easy to monitor trends without constantly refreshing spreadsheets or chasing updates manually, and more importantly, its AI reviewers can evaluate the submissions you received immediately (including its Github repo and its description) and give in-depth feedback, which saves your time identifying the real good hackers.

5. Manage Time and Keep Everyone Aligned
Establish a schedule for your team that covers critical hours without exhausting anyone. Rotate responsibilities and build in breaks, especially for multi-day events.
When timeline changes become necessary, communicate them quickly and clearly. Participants plan around your announced deadlines, and last-minute changes without notice create frustration. Do keep them updated.
Keep your team aligned through brief, regular syncs. Prepare for crunch periods — the final hours before submission deadlines typically see the highest activity. Reserve enough energy to handle these well.

Using a centralized platform like DoraHacks helps keep your team on the same page by consolidating submissions, participant communication, and event settings in one place, reducing coordination overhead and freeing up time for higher-value work.

6. Maintain Energy and Engagement
Long hackathons can possibly lose momentum in the middle. Share progress updates and celebrate milestones to remind participants they're part of something bigger. Consider hosting mid-event activities like AMAs, workshops, or casual social sessions.
Encourage participants to share work-in-progress on social media. Watch for signs of drop-off and send encouraging messages when needed, but balance engagement with respect for participants' focus time. Communicate early if you find high-quality projects joining early, because they could be an important builder in your community, especially if you’re building a new ecosystem or technology.

About DoraHacks
DoraHacks is the leading global hackathon community and open source developer incentive platform. DoraHacks provides toolkits for anyone to organize hackathons and fund early-stage ecosystem startups.
DoraHacks creates a global hacker movement in Web3, AI, Quantum Computing and Space Tech. So far, more than 30,000 startup teams from the DoraHacks community have received over $92M in funding, and a large number of open source communities, companies and tech ecosystems are actively using DoraHacks together with its BUIDL AI capabilities for organizing hackathons and funding open source initiatives.
Website: https://dorahacks.io/Twitter: https://twitter.com/DoraHacksDiscord: https://discord.gg/gKT5DsWwQ5Telegram: https://t.me/dorahacksofficialBinance Live: https://www.binance.com/en/live/u/24985985Youtube: https://www.youtube.com/c/DoraHacksGlobal

Nous sommes ravis de vous présenter la nouvelle fonctionnalité Juges Externes, une version mise à jour de la précédente fonctionnalité de jugement manuel, désormais disponible dans le Tableau de bord de l'organisateur.
Les Juges Externes vous offrent un moyen structuré d'inviter des juges, de définir des règles d'évaluation claires et de passer en revue les soumissions BUIDL directement sur la plateforme. Cela vous aide à combiner l'expertise humaine avec une notation structurée pour un processus de jugement plus clair et plus efficace. En même temps, des évaluations par IA sont également disponibles pour référence des juges.
▶︎ Regardez la vidéo pour voir comment fonctionnent les Juges Externes.

By Steve Ngok, Chief Strategy Officer, DoraHacks
The Introduction
For nearly a decade, the established financial order has viewed crypto with skepticism and disdain. To observers in ivory towers, the industry appeared as little more than a casino—a chaotic theater of speculation divorced from the real economy. For a long time, this criticism had merit.
But surveying the landscape of 2026, the early confusion has given way to structural clarity. The industry hasn't merely grown; it has bifurcated.
We are witnessing a decisive schism. On one side lies continued speculation: prediction markets, exchanges, volatility optimization. This remains a vibrant, if noisy, arena. But distinct from this, a more sober reality has emerged.
Stablecoins have become the TCP/IP of money. They are eating cross-border payments, devouring FX inefficiencies, and enabling entirely new economic primitives for AI agents.
In this landscape, early DeFi's "move fast and break things" mantra has been replaced by demands for determinism, compliance, and institutional scale. This is why the Circle and Arc(https://www.arc.network/) ecosystem has emerged as the dominant stack. They didn't just build a blockchain; they built an Economic Operating System. They did the hard, unglamorous work of regulatory integration and liquidity plumbing so you don't have to.
If you're a founder in 2026, you don't need to reinvent the wheel. The rails are laid by DoraHacks(https://dorahacks.io/) and its partners. The regulatory moat is dug. The liquidity is deep. The question is no longer whether we can put real-world assets on-chain, but what happens when money becomes as programmable as bits.
Here is where the alpha lies. Time to build for the future.
Track I: The Global Capital Expressway
From Simple Remittances to Programmable Settlement
1. The Core Thesis
The traditional cross-border payment system is trapped in a structural trilemma: you can have speed, you can have low cost, or you can have regulatory transparency, but you rarely get all three. The current correspondent banking model is a relic of the analog age, ill-equipped for the velocity of the internet economy.

The Circle and Arc ecosystem has finally solved this coordination problem:
CPN (Circle Payments Network) solves the "Last Mile," connecting the digital ledger to the global banking system.CCTP & Gateway solve liquidity fragmentation, unifying assets across fragmented blockchains.Arc provides the "Matching and Clearing Engine": delivering the sub-second certainty and low latency that Wall Street demands.
The Mission: To use Arc as the central clearing layer for global capital, building the next generation of commercial payment applications that render the SWIFT network obsolete.
2. The High-Value Opportunities
We are looking beyond basic payroll or merchant checkout. The real opportunity lies in re-architecting B2B flows and platform economics.
A. Programmable Trade Finance
The Thesis: "Funds arrive the second the cargo does."
The Problem: International trade runs on friction. Exporters wait 30–90 days for payment or rely on expensive, paper-heavy Letters of Credit. Trust is slow and costly.The Solution:Escrow: The importer locks USDC in a smart contract on Arc.Trigger: An Oracle feeds real-time logistics data (API) to the chain. "Cargo Signed" = "Payment Triggered."Settlement: The contract autonomously releases the USDC.Exit: CPN converts the USDC to local currency (e.g., Vietnamese Dong) and wires it to the exporter instantly.Why Arc? Only Arc’s sub-second finality and near-zero fees make it economically viable to trigger payments based on high-frequency logistics updates.The Builder Profile: Experts in supply chain ERP and logistics data.
B. The Internal Treasury Engine
The Thesis: "Stop burning millions on internal wires."
The Problem: A multinational like Toyota or Siemens has subsidiaries in 50 countries. When Brazil owes Germany, and Germany owes the US, they send wires back and forth, bleeding money on FX fees and float.The Solution:On-Chain Pooling: Subsidiaries convert local cash to USDC via CPN and pool it in a central Arc Treasury.Netting: A "Netting Algorithm" runs on Arc, calculating exactly who owes what to whom on a ledger.Settlement: You only move the difference.Off-Ramp: Subsidiaries pull liquidity back to local fiat only when needed.Why Arc? Privacy tooling protects internal financial data, while high throughput handles the complex math of real-time netting.The Builder Profile: Fintech architects and Enterprise SaaS founders.
C. The "Web3 Stripe Connect"
The Thesis: "A universal payout router for the gig economy."
The Problem: Platforms like Uber, Airbnb, or Upwork struggle to pay a global workforce. Sending $50 to a freelancer in the Philippines is often too expensive to justify.The Solution:Aggregate: The platform loads a single pool of USDC onto Arc.Distribute: One API call triggers thousands of payouts.Route: The smart contract acts as a router. Crypto-native user? Send to wallet. Traditional user? Route through CPN to their local bank.Why Arc? Batch processing capabilities allow for "micropayments" that are mathematically impossible on legacy rails.The Builder Profile: Payment gateway engineers and platform aggregators.
D. The Programmable Corporate Card
The Thesis: "Give your AI agent a credit card, but control the spending with code."
The Problem: Companies need to buy software globally, but corporate cards are dumb. They lack granular control, and you can't easily give one to an AI agent or a temporary contractor.The Solution:The Pool: A corporate USDC treasury on Arc.The Card: Instantly issue virtual Visa/Mastercard credentials via CPN.The Rules: Embed logic in the smart contract: "This card only works for AWS," or "Max spend $100/day."The Settlement: Transactions are settled instantly on-chain via StableFX.Why Arc? It moves financial control from the bank's policy department to the company's code repository.The Builder Profile: Expense management and B2B fintech teams.
3. The Technical Blueprint
For the developer, the architecture is now standardized. Here is how you build it:
Step 1: On-Ramp. Use the CPN API to generate Virtual IBANs. Fiat flows in; USDC is automatically minted to an Arc address.Step 2: Liquidity. Use the Gateway SDK to sweep USDC from fragmented chains (Ethereum, Solana) into your central Arc application.Step 3: Business Logic. Deploy your Solidity contracts on Arc.Payroll: distributeSalary(recipients, amounts)Trade: releaseFunds(proofOfShipping)Step 4: Off-Ramp. Call the CPN Payout API to burn USDC and trigger a local bank wire, or use Programmable Wallets to settle directly on-chain.
4. The Conclusion
"Build a bank that runs on code."
Understand your competition: You are competing against the friction of the 1970s banking system.
By combining the speed of Arc with the reach of CPN, you have the power to reduce global settlement costs by 80% and accelerate speed from "T+2 Days" to "T+0 Seconds." This is an entry ticket to a multi-trillion dollar market.
Track II: The On-Chain FX Revolution
From Manual Conversion to Algorithmic Liquidity Networks
1. The Core Thesis
The traditional Foreign Exchange (FX) market, the largest financial market in the world, is currently held back by an antiquated triad of inefficiencies: Settlement Latency (the T+2 day standard), Gatekeeping (only giants get the best rates), and Opacity (layers of hidden fees).
The combination of Circle and Arc dismantles this structure:
StableFX provides an institutional-grade price feed (RFQ mechanism), meaning "Inquiry equals Execution."Partner Stablecoins (e.g., MXNB, JPYC, BRLA) provide the necessary local currency anchors.Arc provides the execution environment where these currencies can be swapped in mere milliseconds.
The Mission: To utilize code to autonomously manage currency risk and eliminate the friction of exchange from cross-border commerce.
2. The High-Value Opportunities
We are looking beyond simple hedging or remittance apps. The real opportunity lies in deep financial engineering applied to global trade.
A. The Autonomous Multi-Currency Treasury
The Thesis: "Democratizing Apple’s treasury capabilities for the SME."
The Problem: A mid-sized cross-border e-commerce firm earns in Euros (EUR), pays server costs in Dollars (USD), and pays salaries in Yen (JPY). Traditional banking charges exorbitant spreads for these conversions, and finance teams often miss optimal windows due to manual processing.The Solution:Automated Strategy: The enterprise sets rules on Arc: "If EURC balance > 50,000 and EUR/USD rate > 1.08, automatically swap 50% to USDC."Instant Execution: Smart contracts monitor StableFX quotes via Oracle and execute immediately when conditions are met.Payroll: At month's end, USDC is automatically converted to JPYC at the best market rate and distributed to employee wallets.Why Arc? Only Arc supports this high-frequency monitoring and low-cost execution. Traditional banks cannot offer this level of programmability.The Builder Profile: Enterprise financial SaaS teams and ERP integrators.
B. The "1inch" for FX
The Thesis: "Best execution, globally and instantly."
The Problem: When converting USDC to EURC, prices vary between Uniswap, StableFX, and Curve. The user rarely knows where the best liquidity lies.The Solution:Aggregation: Build a dApp on Arc that connects StableFX (RFQ mode) with on-chain AMMs.Routing: When a user wants to swap $1M, the algorithm splits the order: 60% via StableFX (for depth) and 40% via AMM.Atomic Settlement: The user clicks once. The complexity is abstracted.Why Arc? Its high performance allows for the querying of multiple liquidity sources and trade execution within a single block.The Builder Profile: DeFi developers and Market Makers.
C. The Tokenized Carry Trade Protocol
The Thesis: "bringing Wall Street’s oldest strategy to DeFi rails."
The Problem: The Carry Trade, borrowing in a low-interest currency to invest in a high-interest one, has historically been the exclusive preserve of hedge funds and banks.The Solution:The Mechanism: A user deposits USDC.The Operation: The protocol borrows a low-rate currency (e.g., JPYC) in the background, swaps it via StableFX, and invests in a high-yield asset (e.g., Tokenized T-Bills).Risk Management: Utilizing Arc’s automation, the system executes millisecond-level liquidation if exchange rates hit a volatility threshold.Why Arc? This strategy requires extreme speed. Arc’s Deterministic Finality is the critical safeguard against liquidation failure.The Builder Profile: Quantitative trading teams and advanced DeFi architects.
D. The "Local-First" Checkout
The Thesis: "Pay in Pesos, Settle in Dollars. Zero Friction."
The Problem: A US-based Shopify merchant wants USDC, but their Mexican customer wants to pay in Pesos (MXN). Current credit card rails charge 3-5% in FX fees for this privilege.The Solution:Frontend: The buyer sees the price in MXNB (Mexican Peso Stablecoin).Payment: The buyer pays MXNB.Backend: The transaction hits Arc, instantly swaps MXNB to USDC via StableFX.Settlement: The merchant receives USDC. No banks involved. Total fees < 1%.Why Arc? Instant confirmation makes the checkout experience silky smooth, no "waiting for block confirmations."The Builder Profile: Payment gateway developers and e-commerce infrastructure teams.
3. The Technical Blueprint
For the developer, the integration path is clear:
Step 1: Pricing. Integrate the StableFX API (Oracle). This is a stream of executable quotes.Step 2: Assets. Ensure your smart contracts are compatible with ERC-20 standards for USDC, EURC, and Partner Stablecoins (JPYC, MXNB).Step 3: Execution. Build a swapCurrency(tokenIn, tokenOut, amount, minRate) function. Inside, call the StableFX settlement contract, passing the signed RFQ quote to finalize the atomic swap.Step 4: Interoperability (Optional). Use the xReserve pattern. If your strategy requires assets from the Bitcoin network, wrap them into the Arc ecosystem via xReserve to access FX liquidity.
4. The Conclusion
"Forex is the biggest market in the world, and it is still running on 1980s technology."
In this track, you are re-plumbing the vascular system of global trade.
By leveraging StableFX and Arc, you have the opportunity to build the next generation of foreign exchange applications: 24/7 operation, T+0 settlement, and zero banking fees. This is the Crown Jewel of Fintech.
Track III: The Silicon Economy
From Human-Computer Interaction to Machine-to-Machine Commerce
1. The Core Thesis
The current generation of Artificial Intelligence is defined by a structural paradox: infinite intelligence, yet zero financial agency. An AI Agent can plan a complex itinerary for a trip to Tokyo, but it is powerless to book the flight. It can write the code for a server, but it cannot rent the hardware. It is a brain in a jar, brilliant, but severed from the physical economy.
The Circle and Arc ecosystem provides the missing limb:
Circle Programmable Wallets grant each Agent a unique, policy-controlled on-chain identity.The x402 Protocol serves as the universal "negotiation language" for value (restoring the "Payment Required" status to the web).Gas Station resolves the UX friction, abstracting away the complexity of ETH and Gas so that payment feels like a simple API call.Arc provides the high-concurrency, deterministic environment required for machine-speed transactions.
The Mission: To construct the infrastructure and applications that allow AI to autonomously earn, spend, and manage assets. To grant economic sovereignty to the machine.
2. The High-Value Opportunities
We are looking beyond simple "crypto-browsers." We are looking for the fundamental rails of a machine-native GDP.
A. The API Negotiator
The Thesis: "The death of the monthly subscription; the birth of real-time bidding."
The Problem: Developers are currently forced to manually subscribe to dozens of APIs (OpenAI, Twilio, SerpApi), managing a chaotic ring of keys and credit card limits.The Solution:Dynamic Gateway: Service providers publish APIs on Arc with dynamic, load-based pricing.The Agent: Before calling data, the user’s AI Agent queries via x402: "Price check?"The Settlement: The provider responds: "0.002 USDC." The Agent verifies its budget and executes the payment instantly.Pay-As-You-Go: No subscriptions. No breakage. Millisecond settlement.Why Arc? High-frequency micropayments are economically impossible on legacy rails. On Arc, they are the standard.The Builder Profile: API aggregators and developer tool architects.
B. The "Pay-per-Context" Gateway
The Thesis: "Solving the 'New York Times vs. OpenAI' legal deadlock."
The Problem: Large Language Models (LLMs) need fresh data, but publishers are blocking scrapers because they aren't getting paid. The legal system is gridlocked.The Solution:Compliance: Publishers deploy x402 headers on their content.Micro-Access: When an AI scraper visits, it doesn't hit a paywall; it autonomously pays 0.01 USDC to the publisher's Arc wallet for the legal right to ingest that specific article.Revenue Flow: Capital flows instantly to creators and platforms, creating a sustainable "AI-Media" ecology.Why Arc? The negligible transaction fees make the $0.01 economy viable.The Builder Profile: Media-tech firms and Web3 browser plugin developers.
C. The "Budgeted Butler" Protocol
The Thesis: "Trust through code, not faith."
The Problem: You want your AI to buy your coffee and book your flights, but you will never give a hallucinating chatbot your credit card.The Solution:Scoped Permissions: Leverage the "Policy Engine" of Circle Programmable Wallets.The Rules: Issue the AI a sub-wallet with strict on-chain logic: "Max spend 50 USDC/day," "Transfer only to whitelisted addresses (Starbucks, Uber)," "Transactions > $100 require human biometric approval."Autonomy: Inside these guardrails, the AI operates with total freedom.Why Arc? On-chain policy execution is transparent and immutable, offering a flexibility that traditional bank risk models cannot match.The Builder Profile: Smart home hubs and Personal Assistant App developers.
D. Flash Bounties for RLHF
The Thesis: "The Reverse Turing Test."
The Problem: AI still gets stuck. It fails to read a blurred CAPTCHA or misunderstands the nuance of sarcasm.The Solution:The Request: The AI Agent encapsulates the difficult task into a "Micro-Bounty" and broadcasts it to Arc with a 0.5 USDC reward.The Human: A "micro-worker" anywhere in the world taps the notification, solves the CAPTCHA, or labels the data.The Payment: The AI verifies the input and releases funds instantly.Why Arc? This creates a global, frictionless labor market settled in USDC.The Builder Profile: Data labeling platforms and crowdsourcing networks.
3. The Technical Blueprint
For the engineer, the assembly instructions for a Silicon Economic Entity are as follows:
Step 1: Identity. Use the Circle Programmable Wallets API to instantiate a Smart Contract Account (SCA) for the AI.Critical: Configure Spending Policies (e.g., maxAmountPerDay = 10 USDC).Step 2: Protocol. Integrate the x402 (HTTP 402) standard.When the AI makes a request, the server returns 402 Payment Required along with a destination address and amount. The AI parses this and signs the transaction.Step 3: Gas. Configure Gas Station and Paymaster.
The AI holds only USDC. The Paymaster abstracts the gas fees in the background, ensuring the AI's logic loop is never broken by a lack of native tokens.
Step 4: Logic.
Deploy verification contracts on Arc. Ensure that successful payment triggers an Oracle or Event Listener to release the API key or service access off-chain.
4. The Conclusion
"Give your AI a wallet, not just a prompt."
Right now, your AI is like a genius locked in a library: it knows everything, but it can affect nothing in the physical world.
By combining the speed of Arc with the identity layer of Circle Wallets, you are handing that genius a key. You are architecting the GDP of the Machine Economy.
Track IV: Economic Leapfrog & Inclusion
From "Waiting for Aid" to "Accessing the Global Grid"
1. The Core Thesis
Traditional financial inclusion has failed not because of malice, but because of math. The unit economics of the legacy banking system are broken: the Customer Acquisition Cost (CAC) and service overhead for a user in a developing market far exceed the profit generated by their deposits. Banks simply cannot afford to open an account for $50.
The Circle and Arc ecosystem fundamentally alters this equation:
Arc's Negligible Gas Fees make a $1 transfer economically rational, not just charitable.Circle User-Controlled Wallets resolve the "Key Management" barrier, replacing terrifying seed phrases with familiar social logins and passkeys.USDC solves the "Volatility" problem, protecting the vulnerable from local currency inflation.
The Mission: To build the "Leapfrog Stack", minimalist, anti-inflationary, and disintermediated financial tools that serve the bottom 50% of the global population.
2. The High-Value Opportunities
We are talking about sustainable, scalable business models for the next billion users.
A. Reputation-Based Micro-Lending
The Thesis: "Digitizing the social capital of the village to access global liquidity."
The Problem: A fruit vendor in Kenya needs $100 for inventory. She has no credit score, so she is forced into predatory loans. Meanwhile, DeFi protocols sit on billions of dollars of idle capital that cannot be deployed without over-collateralization.The Solution:ROSCA 2.0: Move the traditional "rotating savings and credit association" onto Arc.The SBT: If a member repays on time, this behavior is minted as a Soulbound Token (SBT), a digital credit score.The Bridge: High-reputation ROSCA groups are bundled together to borrow from global DeFi pools at competitive rates (e.g., 10%), bypassing local loan sharks (100%+).Why Arc? Only Arc can handle the high volume of micro-repayment data while providing the transparent audit trail required by global lenders.The Builder Profile: Emerging market Fintech founders and DeFi protocol architects.
B. Pay-As-You-Go Asset Networks
The Thesis: "Streaming money for streaming utility."
The Problem: A low-income family cannot afford the upfront cost of a solar panel or a motorbike, despite having a steady cash flow to pay for it over time.The Solution:IoT + Blockchain: Connect the physical asset (solar panel) to an internet controller.Micro-Unlocking: The user pays 0.50 USDC via their Arc wallet.Smart Contract Logic: Payment confirmed -> Signal sent -> Device unlocks for 24 hours.Ownership: If payment stops, the device locks. Once the total principal is paid, an NFT represents full ownership transfer.Why Arc? The friction of traditional payments makes daily micropayments impossible. Arc makes them trivial.The Builder Profile: IoT hardware hackers and ReFi (Regenerative Finance) entrepreneurs.
C. The Programmable Aid Protocol
The Thesis: "Ensuring donor funds buy medicine, not alcohol."
The Problem: Humanitarian aid is plagued by two cancers: intermediary corruption (skimming off the top) and misuse of funds at the bottom.The Solution:Restricted Assets: Issue a "Wrapped USDC" on Arc specifically for aid.Allow-Listing: Code the token so it can only be transferred to whitelisted wallets (verified pharmacies, schools, grocery stores).Auto-Redemption: Vendors who receive the token can swap it 1:1 for liquid USDC instantly.Privacy: Use Zero-Knowledge proofs so the public sees the flow of funds to valid categories, without exposing the identity of the refugee.Why Arc? Programmable Money is the ultimate solution to the Principal-Agent problem in charity.The Builder Profile: GovTech developers and NGO technical partners.
D. Direct-to-Biller Remittances
The Thesis: "Don't send cash; settle the bill."

The Problem: A migrant worker sends money home for school fees. The cash is received, but due to urgent needs or lack of discipline, it is spent on other things. The sender wants control over the allocation of capital.The Solution:Aggregation: The platform integrates with utility and education providers in the destination country.Direct Payment: The sender in the US pays USDC in the app.Settlement: Arc settles the transaction in the background, converting via CPN to local fiat and paying the electric company directly.Certainty: The sender receives an instant digital receipt: "Bill Paid."
Why Arc? It acts as a global settlement layer that bypasses the slow, opaque correspondent banking chain.
The Builder Profile: Cross-border payment startups and Digital Nomad service providers.
3. The Technical Blueprint
In this track, User Experience (UX) is survival. Your users have low-end devices and spotty internet.
Step 1: The Invisible Wallet. Use Circle User-Controlled Wallets with PIN or Biometric recovery. If you ask a user to write down 12 words, you have already lost.Step 2: Gas Sponsorship. You must configure a Gas Station. The user should know they received "10 Dollars," not that they need "Arc Token" for gas. Abstract the blockchain away completely.Step 3: The Lite Stack. Build Progressive Web Apps (PWAs) or Telegram Mini Apps. The binary must be small; the interface must be fast.Step 4: Offline Tolerance. Design for latency. Allow users to sign transactions offline and broadcast them when the network reconnects.
4. The Conclusion

"Technology has no conscience, but builders do."

On Wall Street, being 1 millisecond faster might mean an extra million dollars in profit. But in the developing world, saving $1 in fees and moving money instantly means a family eats dinner tonight.

This track is about using code to eliminate the "Poverty Premium." By leveraging the power of Arc and Circle, you are building a ladder to economic freedom.

The Conclusion
The Time to Build is Now

History doesn't repeat but it rhymes. In the late 90s, we laid fiber optic cables that allowed the internet to scale. In the 2000s, Stripe and PayPal built the logic layer that enabled e-commerce to explode. Today, we're at a similar inflection point for the financial internet.
The opportunities outlined above - Borderless Payment Rails, Programmable FX, The Machine Economy, and Financial Inclusion - are not theoretical science projects. They are immediate, addressable markets worth trillions of dollars.
The legacy banking system's friction - 3-day settlement times, predatory remittance fees, walled gardens - is an anomaly that technology is now correcting.
Circle and Arc have provided the "AWS" for this financial revolution: scalable, compliant, and ready for deployment. Infrastructure risk has been removed. What remains is execution risk.
We are looking for founders who aren't interested in launching the next meme coin, but who are obsessed with unbundling the bank, rewiring global trade, and giving AI agents their own economic sovereignty.
The Economic OS is open. The API is live. It's time to build.

About DoraHacks
DoraHacks(dorahacks.io) is the leading global hackathon community and open source developer incentive platform. DoraHacks provides toolkits for anyone to organize hackathons and fund early-stage ecosystem startups.
DoraHacks creates a global hacker movement in Web3, AI, Quantum Computing and Space Tech. So far, more than 30,000 startup teams from the DoraHacks community have received over $92M in funding, and a large number of open source communities, companies and tech ecosystems are actively using DoraHacks together with its BUIDL AI capabilities for organizing hackathons and funding open source initiatives.
Website: https://dorahacks.io/Twitter: https://twitter.com/DoraHacksDiscord: https://discord.gg/gKT5DsWwQ5Telegram: https://t.me/dorahacksofficialBinance Live: https://www.binance.com/en/live/u/24985985Youtube: https://www.youtube.com/c/DoraHacksGlobal

0. More Than Just Winning Prizes
So you're ready to sign up for your first hackathon. Maybe you're a college student looking to build something cool over a weekend, or a solo developer hoping to explore new tech and meet like-minded people. Either way, welcome! You're about to experience one of the best ways to learn, build, and grow as a builder.
But here's something most beginners don't realize: the hackers who get the most out of hackathons aren't always the ones who win. Prizes are nice, but the skills, portfolio projects, and connections you gain last much longer.
This guide will help you avoid common beginner mistakes and set you up to thrive, whether you take home a prize or not.

1. Choose Your First Hackathons and Platforms Wisely
Not all hackathons are created equal. As a beginner, start with hackathons hosted by established companies, tech giants like Google and AWS in AI, or companies like Circle and Binance in crypto. These events tend to have clear rules, responsive organizers, and meaningful feedback from judges.
Trusted platforms help you filter signals from noise. DoraHacks(dorahacks.io) is one of the largest and most trusted hackathon platforms, hosting ongoing events in collaboration with leading companies and communities across AI, blockchain, and frontier tech. With hundreds of thousands of past projects archived on the platform, you can research hackathons before joining and learn from previous winners (something we'll cover more later). The platform's reputation means a baseline level of quality for both organizers and participants.
Be cautious with unfamiliar platforms or events with vague organizer information - your time is valuable, so spend it on hackathons that respect that.

2. Read the Rules Like Your Submission Depends on It (Because It Does)
This sounds obvious, but you'd be surprised how many submissions get disqualified because the hackers didn't follow the rules. Before you write a single line of code or description, read the hackathon rules carefully and understand what's actually required.
Pay attention to eligibility requirements; Check submission requirements like demo videos, GitHub repos, or any documentation; Note any restrictions; And understand the judging criteria.
Rules aren't red tapes. They're the contract between you and the organizers. Respecting them shows professionalism and ensures your hard work actually gets judged fairly.

3. Don't Be a Prize Farmer
It's tempting to submit the same project to every hackathon you can find, hoping something sticks. Resist this urge. Organizers and judges can spot a recycled, off-topic submission immediately, and it rarely ends well.
Most hackathons have a theme or focus for a reason. Even if there's an "open track," judges still evaluate how well your project aligns with the hackathon's goals. A blockchain hackathon isn't the right place for your unrelated matching app, no matter how polished it is.
Instead of spreading yourself thin across ten irrelevant hackathons, focus on a few that genuinely match your interests and skills. You'll produce better work and make a stronger impression on judges and sponsors who care about the same problems you do.
4. Communicate Early and Often
Many beginners treat hackathons like exams - head down, no talking, figure it out yourself. This is a mistake. Good hackathons have organizers, mentors, and community channels specifically to help you succeed. Use them.
If something in the rules is unclear, ask for clarification before you build the wrong thing. If you're stuck on a technical problem, reach out to mentors or post in the community Discord. If you're unsure whether your idea fits the theme, check with organizers early rather than finding out during judging. Like on DoraHacks(dorahacks.io), you can always message the organizers directly.
Don't suffer in silence when help is available.

5. Learn From Other Hackers
One of the most underrated benefits of hackathons is the chance to learn from other participants. You're surrounded by people solving similar problems with different approaches, skill levels, and perspectives.
Studying past submissions is one of the fastest ways to improve. On DoraHacks(dorahacks.io), you can browse numerous projects from previous hackathons (like this one: https://dorahacks.io/hackathon/awsvibecoding/winner), filter by category, and see exactly what winning teams submitted. Look at their demo videos, read their page, and examine how they presented their ideas. Pay attention to what made top projects stand out: clear problem statements, polished demos, strong alignment with hackathon themes. Equally valuable is noticing what weaker submissions lacked, so you can avoid the same mistakes.

During the hackathon itself, engage with other participants. Share what you're working on, ask what others are building, and don't be afraid to give and receive feedback. The hacker community is generally supportive, and today's fellow participant might be tomorrow's collaborator or co-founder.
6. Nail Your Submission Presentation
A great project with a terrible presentation often loses to a decent project with a great presentation. Judges have limited time and dozens of submissions to review. Make their job easy.
Your written description matters. Use clear language, structure your explanation logically, and don't assume judges have context you haven't provided. Screenshots, diagrams, and links to working demos all strengthen your submission.
Your demo video should be concise and clear. Explain the problem you're solving, show how your solution works, and highlight what makes it unique - all in one to three minutes unless the rules specify otherwise.

Think of your submission as a pitch. You're not just showing what you built - you're convincing judges why it matters.
7. Manage Your Time Wisely
Hackathons have deadlines, and they arrive faster than you expect. Poor time management is one of the most common reasons promising projects end up as incomplete submissions.
Reserve time at the end for your submission materials. Recording a demo video, writing documentation, and packaging everything properly takes longer than you think. Don't leave it for the last hour.
If you're working with a team, coordinate clearly on who's doing what. Parallel work is efficient, but only if everyone knows their responsibilities.
8. Embrace the Outcome and Keep Building
Hackathons are competitions, and competitions have winners and losers. You might pour your heart into a project and walk away with nothing. It stings, but it's completely normal.
What separates successful hackers from frustrated ones is how they respond. If you don't win, ask yourself what you learned. If your idea makes sense and you keep building seriously, opportunities will find you. Many successful projects didn't win their first hackathon but improved through iteration and eventually found their moment.

The hackathon ends, but your work doesn't have to. If you built something promising, keep developing it. Hackathon projects make excellent portfolio pieces, and continued progress shows potential employers or investors that you're serious.
Countless amazing projects sparked in hackathons only to disappear forever. The excitement fades, life gets busy, and that brilliant idea never sees another commit. Don't let yours be one of them.
Celebrate your wins, learn from your losses, and keep showing up. Consistency beats luck in the long run.
Conclusion: Play the Long Game
Your first hackathon is just the beginning. You'll make mistakes, learn lessons, and probably wish you'd done some things differently. That's fine - everyone starts somewhere.
The hackers who get the most out of hackathons treat each one as a step in a longer journey. They build skills, expand their network, and develop a track record of showing up and shipping. Over time, the wins come, not because they got lucky, but because they got better.
So find a hackathon that excites you on DoraHacks(dorahacks.io), read the rules, chat with organizers, learn from others, and keep building. The rest takes care of itself.
Happy hacking!

About DoraHacks
DoraHacks(dorahacks.io) is the leading global hackathon community and open source developer incentive platform. DoraHacks provides toolkits for anyone to organize hackathons and fund early-stage ecosystem startups.
DoraHacks creates a global hacker movement in Web3, AI, Quantum Computing and Space Tech. So far, more than 30,000 startup teams from the DoraHacks community have received over $92M in funding, and a large number of open source communities, companies and tech ecosystems are actively using DoraHacks together with its BUIDL AI capabilities for organizing hackathons and funding open source initiatives.
Website: https://dorahacks.io/Twitter: https://twitter.com/DoraHacksDiscord: https://discord.gg/gKT5DsWwQ5Telegram: https://t.me/dorahacksofficialBinance Live: https://www.binance.com/en/live/u/24985985Youtube: https://www.youtube.com/c/DoraHacksGlobal

Organizing a hackathon might look straightforward from the outside: set up a website/page, announce some prizes, and wait for submissions to roll in. In reality, a successful hackathon is the result of dozens of decisions made well before the event begins. You’ll see the differences between well/poorly-prepared hackathons on platforms like DoraHacks (https://dorahacks.io) clearly.
Poor preparation leads to predictable problems. Vague rules create disputes; Unclear target audiences result in failed marketing; Underestimating resource needs leaves you scrambling for sponsors before launch or burning out your team with unsustainable workloads…these issues are far easier to prevent than to fix mid-event.
Good preparation, on the other hand, creates a foundation that makes everything else smoother. Think of this phase as building the blueprint before construction begins. The more solid your blueprint, the sturdier the final structure. And you'll thank yourself when unexpected challenges arise and you have the bandwidth to handle them because you didn't skip the groundwork.

1. Define Your Theme, Goals, and Success Metrics
Before anything else, get clear on what your hackathon is about and what you want to achieve. Start by choosing a theme or focus area, which could be a specific technology like AI or blockchain, a problem domain like privacy or payment, or an open-ended challenge. Your theme attracts the right participants and helps sponsors see the relevance to their products.

Next, articulate your goals. Are you trying to grow a developer community, generate innovative solutions to a specific problem, give sponsors access to talent, or provide educational opportunities for beginners? Different goals lead to different design choices throughout the process.
Finally, define what success looks like in concrete terms. Set measurable targets such as number of registrations, number of valid submissions, hacker satisfaction, sponsor satisfaction, or media coverage. Having these benchmarks early helps you make tradeoffs when resources get tight and gives you a clear way to evaluate the event afterward.
That said, keep your targets grounded in reality. Consider the size of developer communities you can reach, the user base of any required technology, and how competitive your prize pool is compared to similar events. Ambitious but achievable goals motivate your team without setting everyone up for disappointment.
2. Identify What Resources You Need
Once you know your goals, map out the resources required to achieve them:
The budget needed for prizes, marketing, and tooling.Connections you have to reach out to potential sponsors, communities, or media outlets.Tools and platforms you'll need for submissions, communication, and judging.External contributors you need and how many hours per week they can commit.
Be specific. If you want a $10,000 prize pool, you need ready funding or sponsors willing to contribute that amount. If you want 500 participants, you need marketing reach to attract them. Identifying resource requirements early reveals gaps you need to fill before moving forward.
3. Understand Your Audience: Who and Where
Think carefully about who you want to participate. Are you targeting university students, early-career developers, experienced professionals, or a mix? Are you focused on a specific region, country, or going fully global? What skill levels and backgrounds do you want to include?
Understanding your audience shapes nearly everything: the language and tone of your marketing, the platforms where you promote the event, the complexity of your challenges, the size of your prizes, and even the timing of your hackathon. A hackathon for Southeast Asian university students looks very different from one targeting senior developers in North America.

Once you know who, figure out where they spend time online. This might be X, Discord communities, Reddit, LinkedIn, university mailing lists, or developer forums. Knowing where your audience gathers determines your marketing strategy.
4. Research Existing Hackathons
You don't need to figure everything out from scratch. Study how successful hackathons operate and learn from their approaches. Participate in a few hackathons yourself to experience them from a hacker's perspective. Read their rules, observe their communication style, and note what works and what frustrates you as a participant.
Explore platforms like DoraHacks (https://dorahacks.io)  to see how top hackathons structure their challenges, prizes, and timelines. Pay attention to how they write their rules, what submission requirements they set, and how they handle judging. Reach out to organizers of hackathons you admire and ask for advice — most are happy to share their experiences and lessons learned.
Learning from others helps you avoid common mistakes and adopt proven practices.

5. Clarify Team Roles and Responsibilities
Whether you're building a team from scratch or working within an existing organization, get clear on who does what. Typical roles include partnerships, marketing and community outreach, participant support, platform and technical operations, and judging coordination.
Assign clear ownership for each area and establish how decisions get made. Ambiguity about responsibilities leads to dropped balls and frustration. Even a small team benefits from explicit role definitions, and larger organizations need this even more to avoid duplication of effort or gaps in coverage.
Do set up regular check-ins to track progress and surface blockers early.

6. Choose Your Platform and Learn It Inside Out
Selecting the right hackathon platform is one of your most consequential decisions. DoraHacks (https://dorahacks.io)  is the best platform for you to kickstart without any fees, providing enough flexibility and a powerful organizer dashboard. Sometimes organizers also use private forms or spreadsheets for registration. Evaluate platforms based on submission and judging features, customization options, cost and pricing model, ease of use for both organizers and participants, and community or support available.

Once you choose a platform, learn it thoroughly from both perspectives, as a hacker and as an organizer. Set up a test hackathon and go through the organizer workflow: creating the event page, setting rules, configuring judging criteria, and managing submissions. Then experience it as a participant: register, submit a mock project, and see what the process feels like. Understanding both sides helps you write clearer instructions, anticipate participant confusion, and troubleshoot issues quickly during the live event.
7. Set a Realistic Timeline
Work backwards from your target hackathon date. Most online hackathons need one to two months of preparation, with more ambitious events requiring longer. Map out key milestones: when sponsorship outreach needs to start, when marketing launches, when registration opens and closes, when the hacking period runs, when judging happens, and when you announce winners.
Build in buffer time. Sponsor conversations take longer than expected, approvals get delayed, and unexpected issues arise. Account for external factors like school exam periods, major holidays, or competing events that might affect participation.
If the timeline feels impossibly tight, consider pushing the date back. A well-executed hackathon a month later beats a rushed one on your original date.
8. Decide If You're Ready
After working through all of the above, take an honest look at whether now is the right time to move forward. Do you have the resources you need or a realistic plan to get them? Is your team aligned and committed? Does the timeline work for everyone involved?
If gaps remain, it's better to address them before launching than to struggle through an under-resourced event. Consider joining another hackathon's organizing team first to gain experience, or scale down your ambitions to something more achievable for a first event.
When everything checks out, you're ready to move from step zero into active organizing.
Feel free to explore DoraHacks (https://dorahacks.io)  for more features supporting your hackathon, or talk to an expert  today (https://dashboard.dorahacks.io/contact-representatives)!
About DoraHacks
DoraHacks (https://dorahacks.io)  is the leading global hackathon community and open source developer incentive platform. DoraHacks provides toolkits for anyone to organize hackathons and fund early-stage ecosystem startups.
DoraHacks creates a global hacker movement in Web3, AI, Quantum Computing and Space Tech. So far, more than 30,000 startup teams from the DoraHacks community have received over $92M in funding, and a large number of open source communities, companies and tech ecosystems are actively using DoraHacks together with its BUIDL AI capabilities for organizing hackathons and funding open source initiatives.
Website: https://dorahacks.io/Twitter: https://twitter.com/DoraHacksDiscord: https://discord.gg/gKT5DsWwQ5Telegram: https://t.me/dorahacksofficialBinance Live: https://www.binance.com/en/live/u/24985985Youtube: https://www.youtube.com/c/DoraHacksGlobal

Par Steve Ngok, Directeur de la Stratégie, DoraHacks
Si vous regardez les données brutes, "le trading humain" est déjà un mythe.
Aujourd'hui, plus de 70% du volume de trading mondial, de la Bourse de New York aux marchés Forex, est exécuté par des algorithmes, pas par des mains.
Pendant des décennies, ce superpouvoir était un club exclusif. Il appartenait aux sociétés de trading à haute fréquence et aux fonds spéculatifs institutionnels disposant du budget pour une infrastructure de plusieurs millions de dollars et des armées de doctorants. Le trader de détail était laissé sur le banc de touche, armé de rien d'autre qu'un graphique et de son intuition, luttant contre des machines qu'il ne pouvait pas voir.

Salut communauté DoraHacks,
Aujourd'hui, nous introduisons le Mode Hackathon entièrement autonome supervisé (FAH) dans le tableau de bord DoraHacks. Il ajoute des capacités de co-organisation et consolide les fonctionnalités d'IA de hackathon existantes en une seule console, vous permettant de gérer l'automatisation de l'IA à partir d'un seul endroit.
FAH est supervisé. Les DevRels et les organisateurs de hackathons jouent un rôle crucial pour superviser et guider les progrès de vos hackathons. Ce que FAH permet à votre organisation de faire, c'est de réaliser des hackathons beaucoup plus grands et beaucoup plus nombreux avec votre équipe actuelle !

Launching Amazon Q’s First Global Flagship Hackathon
Author: Steve Ngok, Chief Strategy Officer, DoraHacks
Overview
Amazon Q is Amazon’s flagship AI product for developers. In a highly competitive AI tooling landscape, the Amazon Web Services (AWS) team partnered with DoraHacks to launch its first-ever global flagship hackathon, the AWS Global Vibe: AI Coding Hackathon ( https://dorahacks.io/hackathon/awsvibecoding ), designed to introduce Amazon Q and Amazon Kiro to developers worldwide and drive real, measurable adoption.
Powered by DoraHacks’ global developer network and AI capabilities, the collaboration was structured as a scalable, repeatable developer go-to-market (GTM) engine for Amazon, one that converts global developer interest into long-term product usage.
The First Global Flagship Hackathon for Amazon Q
AWS Global Vibe marked Amazon Q’s debut as a global, developer-facing hackathon brand. The hackathon invited developers globally to explore Amazon Q’s capabilities through hands-on building.
By harnessing the network and organizational tooling of DoraHacks, , AWS was able to:
Reach developers across multiple regions simultaneouslyShowcase real-world use cases of Amazon Q in production-grade workflowsPosition Amazon Q and Kiro as the default AI tools for modern developers, not just experimental products
A High-Impact Incentive Structure, Powered by a Partner Network
To ensure strong participation and high-quality submissions, the incentive structure was designed at scale.
AWS made up to $100,000 in startup activate credits available to winning teams.
In collaboration with DoraHacks, the hackathon was also supported by a host of elite sponsors including GitLab, SuperAI, Draper University, Minfy, Lovable, and arcanum.ai, contributing additional credits, AI services, and startup resources.
In total, developers competed for combined incentives worth over $700,000 USD, including cloud credits, AI tooling, and venture-facing opportunities.
DoraHacks leveraged its network of top Web3 ecosystems to onboard Circle, Somnia, Seedify, Zetachain, NodeOps, and Babylon as additional bounty sponsors, expanding the incentive surface area and providing developers with meaningful post-hackathon support.
Activating a Global Developer Network at Scale
Through DoraHacks’ global developer distribution and AI-powered campaign infrastructure, the hackathon achieved the following outcomes:
Reached 300,000+ developers and 30,000 startups worldwideConverted 900+ developer teams into the Amazon ecosystemReceived 200+ startup ideas and early-stage products built directly on Amazon Q
The focus was on real usage, real teams, and real conversion, turning experimentation into adoption.
From One Campaign to Long-Term Growth
Beyond the initial hackathon, AWS and DoraHacks established a deeper, long-term collaboration.
Across DoraHacks, one of the world’s most influential hackathon and developer platforms, Amazon Q (alongside Kiro) will become a default developer tool in large-scale hackathons organized by other leading companies and organizations.
Through ongoing credit programs and integrated developer workflows, AWS gains:
Continuous exposure across diverse ecosystemsRecurring touchpoints with new developersA sustained pipeline of qualified, high-intent users
This model transforms hackathons from isolated events into a persistent growth channel.
AI-Powered Judging Co-Pilot
A critical challenge in large-scale global hackathons is judging quality at speed. During the Amazon Q Global Vibe Coding Hackathon, the AWS team leveraged DoraHacks’ Hackathon AI Judging system to fundamentally change how project evaluation was conducted.
By combining structured evaluation criteria with AI-assisted review workflows, the AWS team completed high-quality judging of over 200 project submissions within a single day, a process that traditionally takes multiple weeks and significant coordination.
AI Judging enabled the team to:
Automatically pre-screen and cluster submissions based on technical depth and relevanceSurface high-potential projects for deeper human reviewMaintain consistent evaluation standards across a large and diverse submission set
The system amplified the human judging process, allowing AWS reviewers to focus on substance and decision-making, while automation handled scale and structure.
This capability proved essential in making a global flagship hackathon operationally viable, and demonstrated how AI-driven judging can unlock entirely new levels of efficiency for enterprise-grade developer programs.
Hackathon Automation with FAH
As a DoraHacks Premium Partner ( https://dorahacks.io/buidl-ai ), the AWS team also gains access to DoraHacks’ FAH (Fully Automated Hackathon) capabilities.
FAH enables:
Automated design, launch, and management of hackathonsMulti-theme, multi-region events led by different internal teamsA reduction of over 90% in operational and management overhead
This allows AWS to scale global developer GTM efforts without increasing internal headcount or operational complexity.
From Hackathon to Unicorn: Automated Startup Ecosystem Management
The collaboration extends beyond hackathon execution.
Using DevRel AI, AWS can:
Automatically track and manage top-performing teams emerging from hackathonsMonitor product development progress and Amazon Q usage over timeMaintain long-term relationships with high-potential startups
This creates a fully automated startup ecosystem management loop, significantly improving post-hackathon developer retention and long-term value realization.
Conclusion
The AWS × DoraHacks collaboration demonstrates how global hackathons, when combined with AI-driven automation and ecosystem management, can become a scalable, repeatable growth engine.
This partnership is about building infrastructure for continuous developer adoption.
For AWS, it marks the beginning of a long-term, system-level approach to global developer GTM.

Launch a hackathon for free in minutes: https://dorahacks.io/blog/guides/how-to-create-a-hackathon/Learn more about DoraHacks Premium / BUIDL AI: https://dorahacks.io/buidl-ai

About DoraHacks
DoraHacks is the leading global hackathon community and open source developer incentive platform. DoraHacks provides toolkits for anyone to organize hackathons and fund early-stage ecosystem startups.
DoraHacks creates a global hacker movement in Web3, AI, Quantum Computing and Space Tech. So far, more than 30,000 startup teams from the DoraHacks community have received over $92M in funding, and a large number of open source communities, companies and tech ecosystems are actively using DoraHacks together with its BUIDL AI capabilities for organizing hackathons and funding open source initiatives.
Website: https://dorahacks.io/Twitter: https://twitter.com/DoraHacksDiscord: https://discord.gg/gKT5DsWwQ5Telegram: https://t.me/dorahacksofficialBinance Live: https://www.binance.com/en/live/u/24985985Youtube: https://www.youtube.com/c/DoraHacksGlobal

Éric Zhang

Le mouvement des hackers

Le premier hackathon au monde aurait été organisé en 1997 par un groupe de développeurs cryptographiques canadiens, 20 ans après que Donald Knuth ait publié l'un des premiers logiciels open source au monde, TeX.

En 2003, Paul Graham soulignait dans son ouvrage « Hackers and Painters » que les hackers étaient souvent confondus dans un département d'informatique parce qu'on leur apprenait à rédiger des articles de recherche alors qu'ils voulaient vraiment construire de belles choses (des logiciels).

Alors, qu’est-ce qu’un hacker ? Cela peut être mieux caractérisé par la philosophie du hacker d’Eric Raymond dans son article « Comment devenir un hacker » (2003).