Three Paths for dApp Development: Appchains, Value Return, and Self-Ordering
TechFlow Selected TechFlow Selected
Three Paths for dApp Development: Appchains, Value Return, and Self-Ordering
MEV is being extracted in large quantities, which isn't always bad, but it deprives dApps of the value they create.
Navigating Web3 tides with focused insightsAuthor: Pavel Paramonov
Translation: TechFlow
Is everything really moving toward AppChains?
Yes, but actually, no.
The main reason dApps are turning to sovereign chains is that they feel unfairly treated.
And for good reason—most dApps operate at a loss.
Consider recent examples like zkxprotocol shutting down, and many past applications such as utopialabs_, yield, FujiFinance, among others.
But is this due to fundamentally flawed business models, or are the protocols themselves broken?
The primary (and often only) revenue source for dApps is fees. Users pay these fees because they directly benefit from the service.
However, users aren't the only beneficiaries of dApp usage.
In the transaction supply chain, multiple participants profit—primarily block proposers, despite being the last to see transactions. In the case of L2s, these participants are known as sequencers.
MEV is heavily extracted, which isn't always bad, but the value created by dApps is stripped away, meaning they cannot capture the full value they provide.
Currently, there are three ways to address this issue:
-
Become an appchain.
-
Choose an L1/L2 that shares value back.
-
Implement application-specific ordering.
As with everything in crypto, each solution comes with trade-offs.
1. Becoming an AppChain: High Cost + High Value
You gain many benefits: maximizing value extraction, controlling your own network (if you're an L2), easier scalability, avoiding block space competition, etc.
Downsides: It's very expensive and more challenging to implement, since you must build both the application and the chain.
Even if you want to build an L2 using solutions like alt_layer, it’s still complex.
The argument that "every app will eventually become an appchain" is usually wrong for three reasons:
-
Not every decentralized app (dapp) is large enough to justify migrating to its own chain.
-
Some dapps directly benefit from the architecture of the base layer chain.
-
Dapps function well on other chains.
2. L1/L2 That Shares Value Back: Low Cost + Medium Value
Deploying an app on a rollup or L1 is significantly cheaper, as you don’t need to define new rules for validation, inclusion, consensus, transaction flow, etc.
In the case of rollups, moving your app from Ethereum to a rollup is often straightforward—either EVM-compatible (e.g., arbitrum) or EVM-equivalent (e.g., taikoxyz).
You still need to consider the base layer’s architecture, but you’re not building from scratch.
Perhaps in the future we’ll achieve true chain abstraction, where developers only focus on their dapp—but that’s another topic.
Developers receive medium value capture: not high (you don’t own the chain’s economics), but not low either (you gain additional rewards beyond fees).
Currently, there are few real-world implementations because sharing MEV with dapps remains complex—we need more research and development.
3. Application-Specific Ordering: Medium Cost + Uncertain Value
The concept of application-specific ordering is relatively new, and people often confuse it with appchains. The distinction is simple:
Appchains control both sequencing and execution.
A self-sequencing dApp only controls sequencing, "outsourcing" execution to the L1/L2.
This is medium cost—you must manage transaction ordering, not just build the dapp. The value is uncertain because the concept is new and involves various trade-offs.
First, you still depend on proposers due to inclusion games: you can send any bundle you want, but whether your bundle gets included in a block depends on the proposer.
If you capture all the MEV (maximal extractable value), proposers have no clear incentive to include your bundle.
Thus, this creates another incentive market: proposers and dApps must cooperate, otherwise both lose value and power.
Moreover, the value is uncertain because we can't yet determine whether shared value from the L1/L2 will exceed the value the dApp creates for itself through transaction ordering.
Every chain is a dark forest (not just Ethereum!). So returning to the original question:
Is everything really moving toward AppChains?
-
Yes (some dApps benefit more from owning their own chain than staying on existing ones).
-
No (there are other viable solutions that meet dApp needs).
The forest is vast—worth exploring all options.
There's diversity across every landscape in crypto, so choose the option that 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
