Five weeks. Same app. Five different blockchains.
The experiment: build a tip-jar app once, deploy it to a different chain each week, score the developer experience on eight dimensions (tooling, docs, cost, contract authoring, frontend integration...), max 60 points. No changing the app mid-series. No adjusting the rubric. Same build, different neighbourhood each week.
Final scores: Base 56/60, Core DAO 46/60, TON 43/60, Scroll 42/60, Solana 41.5/60.
What the research kept getting wrong
Before each build I ran a research pass and estimated the score. It overestimated every non-EVM chain: 8 points on Scroll, 3 on Core DAO, 8.5 on Solana. TON was the only zero delta.
Every point of that gap came from the same two places: economics that didn't match the docs, and runtime gotchas that only showed up at smoke test on a live endpoint.
Not the VM model. Not the language.
Documentation tells you how to deploy. It doesn't tell you whether the economics work for your use case, or which mental models to discard. The only honest benchmark for that is a working deploy.
What the deploys proved
Base at 56/60 is the ceiling because there's nothing to translate. Same Foundry commands, same OpenZeppelin imports, same wagmi chain config as Ethereum mainnet. The faucet situation was frustrating (five of six I tried were blocked by ENS requirements, mainnet ETH balance gates, or maintenance), but everything after that was frictionless.
Scroll was the week that proved the thesis hardest. Same contract, same 6.9 KB bytecode, same deployer. Base: $0.05 total. Scroll mainnet that morning: $25 in L1 fees alone, because the Curie hardfork set a commitScalar of 6.2 trillion that amplifies how much every byte of calldata costs. A few hours later I tried again. Same day. Same bytecode. $0.04. Three orders of magnitude within a single calendar day. The fee model responds to Ethereum L1 congestion, which means you can't quote a deploy cost — just a range. None of that is in the getting-started docs.
Solana's decisive miss: getProgramAccounts is disabled on public RPC nodes. HTTP 410, gone. Every tutorial uses it to load program state. I wrote getMessages() the standard way, smoke-tested on devnet: "Could not load messages." The fix is to fetch message_count from the board PDA, derive account addresses by index, batch-fetch with getMultipleAccountsInfo. Workable once you understand the problem. You never hit the 410 on a local validator — only at smoke test on a public endpoint.
Core DAO gets one line: the most interesting consensus model in the series — Bitcoin miners voting with hashrate, BTC holders timelocking on L1. From the Solidity side, I felt none of it.
TON finished at 43/60. I picked it over Monad for the Wildcard slot — not because the estimate was higher (it wasn't), but because the story was richer. Actor model, Telegram's 900M users in the access layer, a language I'd never written. Monad was EVM-compatible; its build log would have looked identical to earlier weeks. The irony: TON had the best deploy experience of the five weeks.
| Chain | Score | Strongest Suite | Biggest Headache |
|---|---|---|---|
| Base | 56/60 | Compatibility | Faucet gates |
| Core DAO | 46/60 | Consensus | "Ghost" feeling |
| TON | 43/60 | DX/Deployment | Non-EVM learning curve |
| Scroll | 42/60 | ZK-Tech | Unpredictable L1 fees |
| Solana | 41.5/60 | Performance | Public RPC limitations |
The honest verdict
If I were starting a greenfield project today: Base. The toolchain is mature, gas costs are negligible for most use cases, and the documentation is good enough that you won't hit a mystery wall on day one. The caveats are real — no live fraud proofs yet, Coinbase trust assumption, the Superchain departure still in progress — but none of them are blockers at most product stages.
If distribution into non-EVM audiences matters for the product, TON has a genuine argument. 900M Telegram users in the access layer is a real distribution channel, not a marketing claim. The development experience is genuinely different (strings are cell chains, the actor model means an entire class of reentrancy attack structurally doesn't exist), but it's learnable in a week.
The other three all have their place. Scroll makes sense if ZK proofs are a hard architectural requirement — but check the fee economics before committing; the range within a single day was $0.04 to $25. Core DAO if Bitcoin miner security is actually relevant to your threat model (and if it is, the Satoshi Plus mechanism is worth understanding). Solana if you need the throughput and you go in knowing you'll need an indexer, not a public RPC.
What's next
The structured experiment is done. Five chains, five retrospectives, one rubric, one app. The live build is still at https://proof-of-support.pages.dev.
If there's a chain you'd like to see added, reach out on Twitter or Farcaster. No timeline, no promises — but I'm reading.
Top comments (0)