Choosing Between L2, Appchain, or Just Web2

Most founders asking “L2 or appchain?” are chasing the wrong decision. They’ve been sold that the game is all about raw throughput: fastest chain, lowest gas, highest TPS. The teams that actually endure optimized for something else entirely: who their users are forced to trust, how fast actions must become final, and which political and economic alliances they’re willing to be locked into for the next 5–10 years.

This piece gives you a cleaner frame for that choice: when a standard L2 is not just sufficient but optimal, when an appchain is genuinely worth the complexity, and when the highest‑leverage, highest‑discipline move is to stay web2 at the core and add crypto only where it creates clear, compounding advantage.

Founders love to compare chains like they’re shopping for a database: TPS, block times, gas costs. Most of that is distraction. Solana, Arbitrum, Base, Optimism, Polygon — they’re all “fast enough” for 99% of consumer and B2B products, as long as the product itself is designed sanely.

What actually breaks products is not performance, it’s a gap between the trust model and the narrative.

If you tell users “self-custody, no middlemen” but route everything through a single multisig or a sequencer you fully control, that discrepancy will surface. On the other side, if your users are enterprises or creators who already implicitly trust you, forcing them into strict self-custody and heavy onchain UX is often just added friction with no narrative upside.

So the first question is not “which chain is fastest?” The real first question is: who needs to be able to verify or contest which parts of the system, without having to trust you?

Before you touch blockspace, you should be able to answer three things on a single slide.

First: what concrete pieces of state actually need to be globally verifiable or censorship-resistant? Not “our whole app” — specific fields like balances, royalties, collateral, governance votes.

Second: what latency can your core loop truly tolerate? A trading venue or in-game marketplace has radically different requirements from a loyalty program or badge system.

Third: who are the political actors that can hurt you — regulators, app stores, payment processors, IP owners — and what leverage do they actually have over your users, your distribution, or your cash flows?

If you can’t clearly name the state, the latency budget, and the political threat model, you’re not ready to pick a chain. You’re just buying infra you don’t know how to use.

An L2 is usually the right call when what you need is cheap, programmable blockspace and you’re fine inheriting an existing chain’s security model, governance, and community norms. That’s why most non-infrastructure DeFi, NFT, and gaming projects sit on Ethereum L2s or Solana: they plug into existing liquidity, wallet support, and dev tooling instead of bootstrapping it themselves.

You start looking at an appchain when either: (a) your business model breaks if you’re competing for shared blockspace — think dYdX moving to a Cosmos appchain to directly shape MEV capture and fee flows, or (b) your trust, latency, or execution guarantees are specific enough that you need to tune consensus, sequencing, and data handling around your app.

But an appchain is not a free upgrade; it’s a company-scale decision. You’re effectively choosing to run a mini-L1, with everything that comes with it: validator recruitment, incentive design, governance process, and contentious upgrades. If you’re not ready to operate like a “country” — with your own institutions and politics — you probably don’t want an appchain yet.

Sticking with web2 is often the most honest and practical call at the idea stage. If your pitch is “better UX for creators” or “smarter pricing for lenders,” you almost certainly don’t need a chain in v1. What you need is user acquisition, good data, and credible guarantees you’re not fudging the numbers.

You can get a long way with simple primitives: signed receipts, periodic Merkle proofs, or using existing stablecoins and qualified custodians behind the scenes. That’s the pattern behind Stripe’s crypto offerings and Reddit’s Community Points: they pushed crypto to the perimeter where it added real leverage, not into every click and state transition.

The advantage of starting web2-first is speed. You can ship, iterate on product, and refine your go-to-market without inheriting a chain’s governance battles, roadmap risk, or upgrade constraints. Then, over time, you selectively decentralize the specific surfaces where trust minimization and composability actually move the needle.

We’ve watched all three paths play out in production.

dYdX began life as a set of Ethereum smart contracts, graduated to StarkEx when they needed more scale, and ultimately moved to a Cosmos appchain once orderbook control and fee capture became existential. That jump only made sense after they had real product‑market fit and sustained volume.

In contrast, a wave of NFT marketplaces that spun up their own chains in 2021 either quietly disappeared or retreated to L2s. They couldn’t credibly bootstrap validators, liquidity, or mindshare, and the overhead of sovereignty crushed them before they got scale.

On the application side, a long tail of “web3 social” projects pushed everything onchain and never escaped a small circle of power users. Meanwhile, products like Friend.tech and Farcaster treated blockspace as a scarce resource: they kept latency‑sensitive UX offchain, and only settled the parts that had to be portable and credibly neutral.

The throughline: the winners consumed the smallest amount of blockspace required to satisfy their trust, latency, and political constraints—and they revisited that decision as those constraints changed.

If you only take one thing away, take this: “L2 vs appchain vs web2” is not a performance choice — it’s a governance choice wearing an infra costume. You’re deciding who your users must trust, how easy it is to unwind your own mistakes, and which political battles you’re signing up for.

In the early stages, over-indexing on decentralization can be just as dangerous as ignoring it — it locks your product in place before you even know what truly needs to be trustless. Start with the smallest credible commitment: the minimum onchain surface area required to make your story honestly true. Then earn the right to put more onchain.

Ask yourself: where in this product would a user willingly pay in latency and UX just to avoid trusting you? That’s the only part that deserves a chain today.