Most Web3 maps begin with infrastructure. They start at Layer 1 blockchains, move through Layer 2s and protocols, and eventually arrive at applications.
That is useful if you are trying to understand how a blockchain works. It is less useful if you are trying to understand where businesses come from.
A more practical map starts with economic activity.
People want to trade. They want to borrow money, earn yield, send payments, speculate on events, issue assets, raise capital and own things. Blockchains provide a new way to coordinate some of those activities.
Once an activity attracts enough money and users, businesses start appearing around it.
An exchange creates demand for trading terminals. Trading creates demand for market data. Permissionless token issuance creates demand for discovery tools and scam detection. Lending creates demand for risk management and liquidation infrastructure. Stablecoins create demand for payments, treasury software and accounting.
That process repeats throughout crypto.
The result is a fairly large economic stack:
flowchart TB
A["1. Destination Applications<br/>Trading, lending, payments, prediction markets"]
B["2. Issuance & Capital Formation<br/>Creating assets and starting markets"]
C["3. Execution & Capital Management<br/>Routing trades and managing positions"]
D["4. Discovery, Intelligence & Distribution<br/>Finding and understanding opportunities"]
E["5. Access, Accounts & Money Movement<br/>Wallets, identity and fiat access"]
F["6. Data, Connectivity & Middleware<br/>RPC, indexing, oracles and bridges"]
G["7. Security, Risk, Compliance & Operations<br/>Keeping the system usable and safe"]
H["8. Developer & Protocol Infrastructure<br/>Tools used to build Web3 products"]
I["9. Blockchain & Settlement Infrastructure<br/>L1s, L2s, validators, sequencers and DA"]
A --> B --> C --> D --> E --> F --> G --> H --> ICapital, liquidity, governance and increasingly autonomous software cut across all of these layers.
The boundaries are fuzzy. A company can occupy several layers at once. That is often the point.
1. Start With What People Are Actually Doing
At the top of the stack are destination applications. These are the places where the underlying economic activity happens.
Uniswap lets people exchange assets. Aave and Morpho let people lend and borrow. Polymarket creates markets around future events. Stablecoin systems provide blockchain-native money. NFT marketplaces handle unique digital assets. Other protocols cover derivatives, insurance, staking, gaming, payments, tokenized securities, compute and storage.
These products answer a simple question:
Why did the user come here in the first place?
A trader wants exposure to an asset. A borrower wants capital. Someone using a prediction market wants to express a view on an event. A business receiving USDC wants to get paid.
This layer matters because everything else in the stack depends on real activity occurring somewhere.
You can build excellent infrastructure for a market nobody uses. It will still be infrastructure for a market nobody uses.
The opposite is more interesting. When an application or financial primitive succeeds, it starts creating problems for other companies to solve.
2. Asset Creation Becomes an Industry of Its Own
Before an asset can trade, somebody has to create and distribute it.
That sounds simple when the asset is an ERC-20 or SPL token. Deploying a token contract has become trivial. Creating a functioning market around that token has not.
A project has to decide:
- how supply is allocated
- how investors vest
- how the initial price is established
- where liquidity comes from
- how tokens reach users
Launchpads such as Pump.fun package much of this process for a particular class of token. Other systems handle auctions, token sales, liquidity bootstrapping, vesting, airdrops and investor allocations.
The same problem exists in more regulated forms for tokenized equities, funds, credit and other real-world assets. Issuing the token is one part of the job. The legal claim, custody arrangement, redemption mechanism and distribution system matter just as much.
This creates an entire issuance layer around successful asset markets.
flowchart LR
A["Asset Creation"] --> B["Distribution"]
B --> C["Price Discovery"]
C --> D["Initial Liquidity"]
D --> E["Secondary Market"]Each step can support separate companies.
3. Markets Create an Execution Industry
Once assets and liquidity exist, users immediately start looking for better ways to trade them.
A decentralized exchange may have liquidity, but a trader still has to decide which exchange, pool, route, and sometimes blockchain gives the best result.
Aggregators emerged to solve that problem.
Products such as 1inch and Jupiter can search across liquidity sources and route an order without making the user manually inspect every venue.
Intent-based systems push the abstraction further. A user states the result they want, and competing solvers figure out how to produce it.
The same pattern produced trading terminals.
A terminal may own none of the underlying liquidity. Its value comes from giving the trader a better interface for:
- discovery
- charts
- execution
- automation
- position management
Telegram trading bots took this even further. Instead of convincing users to adopt a completely new workflow, they inserted execution into an interface traders were already using.
Capital management developed along similar lines.
Concentrated liquidity made AMMs more capital-efficient, but it also made liquidity positions harder to manage. That created demand for range managers, LP vaults, rebalancing tools and market-making software.
Lending protocols created opportunities for yield optimizers, risk curators, liquidators, leverage managers and collateral-management tools.
A useful financial primitive often creates management complexity. Someone can build a business around removing that complexity.
4. Permissionless Markets Create an Attention Problem
Crypto is unusually good at creating things to trade.
That eventually produces a different problem: there is too much to look at.
Thousands of tokens can launch. Hundreds of yield opportunities can exist at the same time. Prediction markets can cover everything from interest rates to elections to sports. Wallets make millions of public transactions.
The raw information is available. Making sense of it is harder.
This is where products such as Dexscreener, Dune, Nansen and DefiLlama fit, although they solve different parts of the problem.
A token scanner tells you what is moving.
An analytics platform helps you understand what happened.
Wallet intelligence can tell you who was involved.
A discovery product decides what deserves your attention.
A reputation system tries to tell you whose actions are worth paying attention to.
Those distinctions matter because the value of blockchain data changes as it gets processed.
flowchart LR
A["Raw Transactions"] --> B["Structured Data"]
B --> C["Analytics"]
C --> D["Intelligence"]
D --> E["Discovery"]
E --> F["Decision"]
F --> G["Transaction"]A company can fit into almost every step.
The products closest to the final transaction have an obvious way to make money. If a discovery app causes somebody to make a trade, it can participate in the economics of that trade.
This is one reason social trading products are interesting.
A service such as Dexscreener might tell a user that a token is moving. A social trading product can add another piece of information: who is buying it.
That turns public blockchain activity into something closer to a social signal.
The valuable asset can eventually become the relationship between attention and transaction intent.
5. Wallets Are Becoming the Account Layer
Early crypto wallets exposed users directly to much of the underlying infrastructure.
A user needed a seed phrase, a browser extension, the correct network and enough of the chain's native token to pay gas. Moving between networks often involved bridges and more signing.
A mainstream financial application cannot assume that its users want to understand any of this.
Embedded wallets and smart accounts are gradually changing the model.
Instead of:
Seed phrase
→ browser extension
→ network selection
→ gas
→ bridge
→ sign transaction
the experience can become:
Email / Apple / Google
→ account
→ deposit money
→ transact
Account abstraction adds another set of capabilities:
- sponsored transaction fees
- transaction batching
- recovery
- spending limits
- multisig
- programmable permissions
- session keys
The likely endpoint is straightforward.
Users know how much money they have and what they want to do with it. The application handles the blockchain-specific details.
That idea extends to chain abstraction.
A user with USDC shouldn't have to care whether the money sits on Base while the product they want lives on Solana. Software can choose the bridge, route, gas mechanism and settlement path.
Wallets therefore occupy a powerful position in the stack. They can become the place where identity, assets, signing and application discovery meet.
They can also move upward.
A wallet can add swaps, staking, trading, payments, token discovery and financial applications without creating the underlying protocols itself.
Once a product owns the user's account relationship, distribution becomes valuable.
6. Under Every Interface Is a Data and Connectivity Layer
Blockchain applications need infrastructure to communicate with chains and convert raw state into useful information.
RPC and node providers give applications reliable access to networks.
Indexers transform blockchain events into queryable data.
Market-data companies normalize prices, volume, token metadata and liquidity.
Oracles bring information from outside the blockchain into smart contracts.
Bridges and cross-chain messaging systems connect networks that otherwise maintain separate state.
Then there is orderflow.
A transaction does not simply appear inside a block. It moves through an execution supply chain involving wallets, RPC providers, validators, sequencers, builders, searchers and sometimes private orderflow systems.
Where a transaction is routed and where it lands can have economic value. That has produced businesses around:
- MEV protection
- block building
- solver networks
- orderflow auctions
- private transaction routing
Infrastructure gets deeper from there.
Rollups need data availability. ZK systems need proving infrastructure. Applications with large media files need storage systems.
Most end users will never know these companies exist.
That does not make the companies unimportant. It can make them more durable. Infrastructure tends to become deeply embedded once developers depend on it.
7. Money Attracts Security, Risk and Compliance Products
The more valuable an onchain system becomes, the more people will spend to keep it from failing.
Smart contracts need:
- audits
- fuzzing
- formal verification
- monitoring
- bug bounties
Wallets need:
- transaction simulation
- phishing detection
- wallet-drainer detection
- malicious-contract warnings
- token scam detection
Lending markets need models for:
- collateral risk
- oracle risk
- liquidation risk
- liquidity risk
- counterparty risk
Institutions need:
- address screening
- transaction tracing
- sanctions screening
- compliance systems
- audit trails
Companies also need an unglamorous set of back-office products:
- accounting
- tax
- reconciliation
- treasury reporting
- payroll
- proof of reserves
- financial controls
These categories are easy to overlook when crypto markets are focused on whatever asset is appreciating fastest.
They are also where some of the stickiest businesses can be built.
A retail trader can replace a charting product tomorrow. A finance team that has built its monthly reconciliation process around a piece of software is much harder to move.
8. Builders Need Their Own Stack
The products above would be painfully expensive to build if every team had to create everything from scratch.
Developer infrastructure turns recurring engineering problems into reusable products.
Contract libraries provide standard implementations for:
- tokens
- permissions
- governance
- multisig
- upgrades
Frameworks handle development and testing. Deployment systems manage contracts across networks. APIs expose common actions without forcing developers to integrate each protocol separately.
Over time, more blockchain functionality becomes an API call:
Create wallet
Fetch portfolio
Execute swap
Screen transaction
Bridge funds
Issue asset
Simulate transaction
This is normal software-market behavior.
Once developers repeat the same integration enough times, somebody packages it.
The same thing is happening with blockchains themselves. Rollup frameworks and managed infrastructure have made launching a specialized chain closer to a software deployment decision than it was a few years ago.
It is still a difficult decision. It simply no longer requires inventing every component from scratch.
9. At the Bottom Is Blockspace
Eventually something has to maintain the state.
Layer 1 networks provide consensus and settlement.
Layer 2 systems execute transactions while relying on another network for parts of their security or settlement model.
Appchains give particular applications or ecosystems their own execution environments.
Around them sit:
- validators
- staking providers
- sequencers
- block builders
- provers
- data-availability networks
This is the part of Web3 that most traditional stack diagrams emphasize.
It deserves to be there. It just does not tell the whole economic story.
A fast blockchain with cheap blockspace does not automatically produce a successful ecosystem.
Developers need tools. Applications need users. Markets need liquidity. Users need interfaces. Companies need security and operations.
Blockspace is the foundation.
Businesses still have to be built on top of it.
Horizontal Layers
Some forces cut across the entire stack rather than fitting neatly into a single layer.
Capital and Liquidity
Liquidity providers, lenders, market makers, arbitrageurs, validators, funds and protocol treasuries move capital throughout the system.
They can be customers, infrastructure providers or businesses in their own right.
Take a token launch:
flowchart LR
A["Issuer"] --> B["Launchpad"]
B --> C["Liquidity Provider"]
C --> D["Market Maker"]
D --> E["Liquidity Manager"]
E --> F["Exchange"]
F --> G["Aggregator"]
G --> H["Analytics"]
H --> I["Trading Terminal"]One asset can create revenue opportunities for several companies.
Governance and Organizations
Onchain organizations also need operational software:
- multisigs
- governance systems
- delegation
- proposal tooling
- treasury management
- contributor payments
- grants
- vesting
- permissions
In many cases, this is enterprise software for organizations whose assets and operations happen to live onchain.
AI and Autonomous Agents
AI agents that can hold money and transact create a new type of blockchain user.
An agent may need:
flowchart LR
A["Identity"] --> B["Wallet"]
B --> C["Funds"]
C --> D["Permissions"]
D --> E["Data"]
E --> F["Discovery"]
F --> G["Execution"]
G --> H["Payments"]That creates potential businesses around:
- agent wallets
- spending controls
- programmable permissions
- agent identity
- reputation
- machine-to-machine payments
- security
- data access
- autonomous trading
- autonomous treasury management
This can become a substantial new market without requiring a fundamentally new blockchain primitive.
Distribution Can Matter More Than the Underlying Protocol
One useful consequence of this map is that value does not always accumulate where the original financial primitive was created.
Consider a trade:
flowchart LR
A["Liquidity Venue"] --> B["Aggregator"]
B --> C["Trading Terminal"]
C --> D["Wallet"]
D --> E["Discovery / Social Product"]
E --> F["User"]The liquidity venue controls the pool.
The aggregator controls routing.
The terminal controls part of the workflow.
The wallet controls the account relationship.
The discovery product may control the user's attention before the transaction occurs.
These are different kinds of leverage.
A company does not necessarily need to own the exchange to make money from trading. It might be more valuable to own the interface where somebody decides what to trade.
This helps explain why wallets keep adding financial products and why trading products keep adding discovery.
Companies move through the stack when owning an adjacent layer gives them more control over distribution or economics.
Successful Primitives Create New Businesses Around Themselves
This is the part of the map I find most useful when thinking about startups.
Take decentralized exchanges.
Once DEXs had meaningful liquidity, room opened up for aggregators.
More trading created demand for terminals and bots.
Concentrated liquidity created demand for LP managers.
Permissionless markets created demand for token scanners and analytics.
Public wallets created the raw material for social trading.
The DEX did not have to invent those businesses. Its success made them possible.
The same process is happening elsewhere.
Stablecoins
Stablecoins create demand for:
- payments
- remittances
- cards
- payroll
- FX
- treasury management
- accounting
- compliance
- yield products
Prediction Markets
Prediction markets create demand for:
- market discovery
- trader reputation
- research
- portfolio tools
- social products
- market-making tools
- execution infrastructure
Tokenized Real-World Assets
RWAs create demand for:
- issuance
- custody
- compliance
- market data
- NAV feeds
- asset comparison
- routing
- lending
- portfolio management
- accounting
Lending
Lending markets create demand for:
- risk managers
- liquidators
- yield optimizers
- collateral managers
- leverage tools
- credit analytics
This leads to a useful way of looking for Web3 ideas:
Find something that already works, then look at the new problems its success has created.
Many good businesses start there.
Where the Money Is Made
The stack looks complicated, but the business models are familiar.
| Business model | Typical applications |
|---|---|
| Transaction fee | Exchanges, launchpads, prediction markets |
| Spread | Market makers, onramps |
| Interest margin | Lending, stablecoins |
| AUM fee | Asset management |
| Performance fee | Strategy management |
| LP fee | Liquidity provision |
| Issuance fee | Tokenization |
| Subscription | Analytics, terminals |
| API usage | Data, RPC, security |
| Per-wallet fee | Wallet infrastructure |
| Routing fee | Aggregators |
| Orderflow economics | Solvers, market makers |
| Validator commission | Staking |
| Referral revenue | Wallets, discovery products |
| SaaS | Enterprise infrastructure |
| Blockspace fees | L1s and L2s |
The important distinction is between usage and value capture.
A protocol can process billions of dollars and have weak economics. A small piece of enterprise software can process no transactions itself and still have excellent margins.
When evaluating a Web3 business, three questions matter:
- Who pays?
- What triggers payment?
- Why does that customer keep paying?
Token incentives can hide weak answers to those questions for a surprisingly long time.
When Does a Blockchain Actually Help?
There is also a tendency to put ordinary software on a blockchain simply because it can be done.
The strongest applications usually have a concrete reason for being onchain.
Blockchain can make sense when a product benefits materially from:
- global permissionless settlement
- shared liquidity
- composability
- verifiable state
- digital ownership
- programmable money
- continuous markets
- coordination across multiple organizations
- machine-to-machine commerce
- resistance to centralized gatekeeping
If removing the blockchain makes a product cheaper, faster and equally useful, that is worth paying attention to.
Web3 should solve a problem the application actually has.
A Better Way to Map the Industry
The common picture of Web3 looks something like this:
flowchart TB
A["Blockchain"] --> B["Protocol"]
B --> C["Application"]That view is technically tidy and economically incomplete.
A more useful picture looks like this:
flowchart TB
A["Users"]
B["Discovery / Social / Intelligence"]
C["Wallets / Terminals"]
D["Routing / Automation / Management"]
E["Issuance / Market Operations"]
F["Destination Markets"]
G["Data / Oracles / Connectivity"]
H["Security / Risk / Operations"]
I["Developer Infrastructure"]
J["Blockchains / Settlement / Nodes"]
A --> B --> C --> D --> E --> F --> G --> H --> I --> JThe most interesting company doesn't have to sit at the top or bottom.
Sometimes the protocol is the business.
Sometimes the better business appears two years later, after the protocol has attracted enough users to create an entirely new set of problems.
That is the part of Web3 that is easiest to miss.
New economic activity creates complexity. Complexity creates demand for software, data, security, capital and better interfaces.
So when looking for the next thing to build, I would spend less time asking what blockchain primitive nobody has invented yet.
I would look closely at what people are already doing onchain, where money is already moving, and what still feels unnecessarily difficult.
Another business is usually hiding there.
AI Assistance Disclosure
This article was written with the help of ChatGPT as a summary of a broader research process I conducted on the Web3 economy and its business opportunities. I directed the research and selected the ideas and conclusions, while ChatGPT helped synthesize, structure, and edit the material.
Top comments (0)