Team1 India Speedrun: Build Anything on Avalanche

What is Speedrun?

Speedrun is a focused build sprint where developers ship a working prototype. Each cycle drops a challenge, a clear goal, and a set of starting ideas. You pick a direction, build fast, and demo live. The mission is simple: build, ship, show.

Every cycle so far has come with a theme. This one doesn't.

This Cycle: Build Anything on Avalanche

Build anything on Avalanche. That's the brief.

You get 30 days and no assigned category. There's no primitive you're required to use and no problem space you have to fit into. If it runs on Avalanche and it works, it counts.

We've handed out themes for the last few cycles and they do a good job of getting people started, but they also filter out a lot of good ideas. Most of the best things people build come from wanting to solve something for themselves, and a theme usually gets in the way of that. So this time you bring the idea and we'll bring the chain, the tooling, the mentors and the deadline.

Vibe coding is fine here

Use whatever gets you from an idea to running code. Claude Code, Cursor, Windsurf, v0, Bolt, Replit, Lovable, all of it is fair game. Prompt your way to a prototype if that's how you work.

We aren't judging how the code was written. We're judging whether it works and whether it's interesting.

Three things we do care about:

The prototype has to be deployed and demoable. Code that was generated but never run doesn't count as a submission.

You need to be able to explain what you built. During the demo we'll ask how something works or why you made a particular call, and "the AI wrote it" won't get you very far.

Don't submit a copy of something that already exists with a new name. Building on top of existing work is fine and we've covered how to do that below.

30 days is a lot longer than usual

Our last two cycles ran for about two weeks. This one runs for a month, so there's room to build something with a few moving parts, test it properly, and spend the last stretch on the demo instead of fixing things at 3am. You can also ship in week one and keep iterating. Up to you.

Goal

Ship a working prototype deployed on Avalanche Mainnet or Fuji with a live demo showing it do something real on-chain.

That's the whole bar. Nothing else is required.

By the end you should have something you can send someone a link to. A deployed app, a contract on Snowtrace, a CLI you can run on a call. Something that runs.

What You Can Build With

None of this is required except the chain itself. It's here so you know what's available.

Avalanche C-Chain and Fuji. Standard EVM. Everything you know about Solidity, Hardhat, Foundry, viem, wagmi and ethers works without changes. This is the fastest path if you just want to ship a contract and a frontend.

Avalanche L1s. Your own sovereign chain, where you pick the validator set, the gas token and the rules. Since the Etna upgrade an L1 validator costs a flat ~1.33 AVAX per month and doesn't need to validate the Primary Network, so spinning one up is cheap. Tooling is avalanche-cli, the L1 Toolbox and Subnet-EVM.

EVM precompiles. Stateful precompiles for transaction allowlists, fee configuration, native minting and KYC enforcement. These let you set rules at the chain level instead of writing them into every contract.

eERC (Encrypted ERC). AvaCloud's confidential token standard. Balances and transfer amounts are encrypted on-chain using zk-SNARKs (Groth16) and ElGamal, proofs are generated client-side, and rotatable auditor keys let a regulator decrypt when compliance needs it. Standalone mode gives you a new private token, converter mode wraps an existing ERC-20. Ships with a TypeScript SDK.

Interchain Messaging (ICM) and Interchain Token Transfer (ICTT). Send messages and move tokens between Avalanche L1s and the C-Chain without a third-party bridge.

AvaCloud. Managed L1 infrastructure, APIs, indexing and a Data API if you'd rather not run nodes yourself.

Anything else in the ecosystem is also in scope. Account abstraction, x402 payment rails, agent tooling, oracles, whatever fits what you're building.

Ideas

These are starting points, not requirements. If you already know what you want to build, skip this section.

Consumer and social

Something you'd use yourself. A tip jar for your group chat, a split-the-bill app, a shared savings pot with friends, a habit tracker with money on the line.

On-chain identity or reputation. Portable profiles, verifiable credentials, a follow graph, proof of attendance for local events. Anything that makes an address mean something.

Gaming and collectibles. A playable on-chain game loop, NFTs that change with state, a leaderboard with real stakes. A dedicated L1 gives you cheap transactions and your own gas token, which suits games well.

DeFi and payments

A payments primitive. Subscriptions, streaming payments, escrow, invoicing, payroll, remittances. Stablecoin rails are unglamorous and huge, so pick one piece and make it good.

A trading or yield tool. A vault strategy, a limit order layer, a portfolio dashboard, a liquidation bot, an aggregator. It doesn't need to be novel as long as it works.

Prediction and markets. Sports, elections, weather, ship dates. Something people would actually place a bet on.

AI and agents

Agents that transact. An autonomous agent with a wallet that pays for services, buys data or runs strategies on Avalanche. Give it a budget and let it go.

Agent-to-agent commerce. Machine-payable APIs, per-request payment rails, discovery and reputation between agents. This has been productive ground in recent cycles.

AI-assisted developer tooling. Contract explainers, transaction simulators, natural language chain queries, an MCP server for Avalanche. Tools that make the next Speedrun faster.

Infrastructure and developer tooling

Make something easier. A better local dev setup, a deploy pipeline, a testing harness, an indexer, a debugging tool. Build the thing you wished existed while you were building.

Launch an L1 with a purpose. Not an L1 as the project itself, but an L1 underneath an app that needs its own chain, gas token or rules.

Cross-chain builds. Use ICM and ICTT to build something that spans multiple L1s and only makes sense because it does.

Real-world and local

India-specific builds. UPI-adjacent flows, local commerce, remittance corridors, small business tooling, campus and community apps. You know problems the rest of the ecosystem doesn't.

Tokenized real-world assets. Invoices, receivables, event tickets, memberships, warranties.

Public goods. Grants, donations, transparency dashboards, community treasuries.

Just for fun

Stupid ideas executed well are welcome. An on-chain rock-paper-scissors league, a contract that only accepts transactions on Tuesdays, a leaderboard for gas wasted. If it works and it's funny, submit it.

Start Where You Are

None of this needs to be a heavy build. A small prototype that does one thing properly will do better than a large half-finished platform.

If you've never deployed on Avalanche, write a contract, put it on Fuji, add a frontend. That's a real submission and a real milestone.

If you've shipped before, use the month for the thing that's been sitting in your notes app.

Pick something you enjoy. The point is to build on Avalanche and have fun, not to ship something massive.

What to Submit

A working prototype deployed on Avalanche with a live demo.

Build and demo on Fuji, the Avalanche C-Chain testnet, using free test AVAX from the faucet. You don't need real funds. If you launch a custom L1, run it on testnet. Deploying to Avalanche mainnet is optional and earns bonus points.

Your submission should include:

Project name and a one-line description.
Full description. What it does, who it's for, what problem it solves.
Tech stack. What you used and how it fits together. Call out anything Avalanche-specific.
A live link. Deployed app, contract addresses on Snowtrace, or a repo with clear setup instructions.
Source code, public repo preferred.
A demo video, 3 minutes or less, showing it work. A screen recording is fine.
Which AI tools you used and roughly what for. This is informational and doesn't count against you, we're just tracking how people are building now.

Building on an existing project is welcome. You can submit an older project as long as you clearly define what existed before this Speedrun and what you added during it. We judge what you ship here, so make the delta obvious.

Judging

Does it work (30%). Deployed, demoable, and doing what you say it does.

Idea and originality (25%). Is it interesting, is it yours, would anyone use it.

Technical depth (20%). How much is genuinely built versus scaffolded, and what hard problems you solved.

Avalanche fit (15%). Whether you're using Avalanche for a reason.

Demo and communication (10%). Whether you can show it and explain it clearly in a few minutes.

Bonus points for a mainnet deployment, launching your own L1, using eERC or ICM/ICTT in a way that matters to the build, and open-sourcing something other builders can reuse.

Resources

Start here

Avalanche Builder Hub. Courses, guides and end-to-end walkthroughs. Best place to start.

Builder Console. Deploy contracts, create an L1 or launch an eERC token from the browser, no local setup.

Avalanche Starter Kit. Hardhat plus a ready Codespace so teams can start in minutes.

Core development

Avalanche docs. The full reference.

Fuji C-Chain. RPC https://api.avax-test.network/ext/bc/C/rpc, Chain ID 43113, explorer testnet.snowtrace.io.

Fuji faucet. Free test AVAX.

Core wallet. The Avalanche-native wallet, useful for L1 and cross-chain flows.

Avalanche L1s

Avalanche L1s overview (docs). Sovereign chains, custom gas tokens, validator sets, precompiles.

avalanche-cli. The CLI for creating and deploying L1s.

L1 Toolbox. Browser-based L1 management.

Subnet-EVM. Avalanche's EVM fork with stateful precompiles for allowlists, fee config, native minting and KYC.

Permissioned L1s course. Proof of Authority and the Validator Manager contract.

Interchain

Interchain Messaging (ICM). Native message passing between Avalanche L1s.

Interchain Token Transfer (ICTT). Moving tokens across L1s without a third-party bridge.

Privacy

eERC course (Builder Hub). End-to-end walkthrough of the encrypted token standard.

ava-labs/EncryptedERC. Contracts and circuits in Solidity and Circom, standalone and converter modes.

eERC SDK. TypeScript SDK, on npm as @avalabs/ac-eerc-sdk.

Infrastructure

AvaCloud. Managed L1s, APIs and the Data API.

Timeline

21 September, registration opens and the build window starts. Sign up, lock your team, start building.

21 September to 21 October, build and submit. 30 days. Office hours and mentor support run throughout.

[TBD], mid-sprint checkpoint. Optional progress share and feedback session.

21 October, submissions close.

[TBD], demo day.

[TBD], winners announced.

Exact times and the demo day date to be confirmed.

Connect

About