Will all applications evolve toward Appchains?
TechFlow Selected TechFlow Selected
Will all applications evolve toward Appchains?
The answer is "thus."
Navigating Web3 tides with focused insightsAuthor: Pavel Paramonov
Translation: Alex Liu, Foresight News
Is Everything Really Moving Toward AppChains?
Yes and no.
The main reason dApps are moving toward building their own sovereign chains is that they feel exploited. And this isn't far from the truth—most dApps indeed aren't making money.
Consider recent examples like @zkxprotocol shutting down, along with many others in the past such as @utopialabs_, @yield, @FujiFinance, and more.
But is this because of poor business models, or are protocols genuinely being exploited?
The primary (and often only) revenue source for dApps is fees. Users pay fees because they directly benefit from them.
However, users aren't the only beneficiaries when dApp usage increases.
Within the transaction supply chain, several roles profit—most notably block proposers, even though they see transactions last. In the case of L2s, these are sequencers.
MEV (Maximal Extractable Value) is heavily extracted, which isn't always bad, but the value created by dApps is taken away, so they don't capture the full value they generate.
Currently, there are three ways to address this:
-
Become an appchain.
-
Choose an L1/L2 that returns value.
-
Implement app-specific sequencing.
As with everything in crypto, each solution comes with trade-offs.
1. Becoming an Appchain: High Cost + High Value
There are countless advantages: you can extract the value you want, control your network (if you're an L2), scale more easily, avoid competing for blockspace, etc.
The downside: it's really expensive. Extremely expensive. And much harder to pull off, because you have to build both the chain and the application simultaneously.
Even if you opt to build an L2 using a solution like AltLayer, the cost and complexity remain significant.
The belief that every app will eventually become an appchain is fundamentally incorrect, for three reasons:
-
Not every dApp is large enough to require migration to an appchain.
-
Some dApps directly benefit from the underlying chain’s architecture.
-
Many dApps are thriving comfortably on other chains.
2. Value-Returning L1/L2: Low Cost + Medium Value
Deploying an app on a Rollup or L1 is significantly cheaper because you don’t need to implement new rules for validation, inclusion, consensus, transaction flow, etc.
In the case of Rollups: migrating your application from Ethereum to a Rollup is usually straightforward, since most Rollups are either EVM-compatible (e.g., Arbitrum) or EVM-equivalent (e.g., Taiko).
You still need to consider the base layer’s architecture, but you don’t have to build it from scratch.
Perhaps in the future we’ll achieve true chain abstraction, where developers only need to focus on their dApp—but that’s another story…
Developers receive medium returns—not extremely high (since you don’t own the chain’s economics), but not low either (you get some value beyond just fees).
Currently, there are few real-world implementations because sharing MEV with dApps remains a complex challenge—we need more R&D in this area.
3. App-Specific Sequencing: Medium Cost + Uncertain Value
The concept of app-specific sequencing is relatively new, and people often confuse it with appchains. The difference is simple:
-
Appchains handle both sequencing and execution.
-
Self-sequencing dApps handle only sequencing, outsourcing execution to an L1/L2.
Costs are medium because, in addition to building the dApp, you must also manage transaction ordering. The value, however, is uncertain due to the novelty of the concept and various open questions.
First, you still depend on proposers due to the inclusion game: you can send whatever bundle you want, but whether it gets included depends entirely on the proposer.
If you capture all the MEV, proposers have no clear incentive to include your bundle in a block.
This actually opens up a new incentive market for proposers. They (dApp + proposer) must cooperate—otherwise, neither holds value or power.
The value is also uncertain because we don’t yet know whether the shared value from the L1/L2 will exceed the value the dApp creates for itself through sequencing.
Every chain is a dark forest (not just Ethereum!). So circling back to the original question:
Is everything really moving toward AppChains?
-
Well, yes (some dApps benefit more from owning their own chain than staying on existing ones).
-
Well, no (there are other solutions better suited to dApp needs).
The forest is vast—plenty of options to explore.
Diversity exists across every domain in the world, and crypto is no exception. So choose what best fits your needs—or build your own solution!
Join TechFlow official community to stay tuned
Telegram:https://t.me/TechFlowDaily
X (Twitter):https://x.com/TechFlowPost
X (Twitter) EN:https://x.com/BlockFlow_News
@paramonoww
