The definition, precisely
Ethereum.org defines a dapp as an application built on a decentralized network that combines a smart contract with a frontend user interface. It lists the properties that follow: decentralized, deterministic, Turing complete and isolated in the EVM, and it notes that once the contract is deployed the network as a whole keeps serving it.[1]
The contract side is the part that matters. On Ethereum a contract is a collection of code and data at a specific address, and it runs as programmed for every caller.[2]
The frontend is not automatically decentralized. Ethereum.org lists centralization as a drawback: many services serve their frontend from a centralized server or keep business logic there, while the contracts beneath stay callable by anyone.[1]
The term is used loosely, so the test is simple: if the company switched off its servers tomorrow, could you still reach your funds by calling the contracts from a block explorer or another interface? If yes, it is a dapp in the full sense.
See also: What is a smart contract?
How a dapp request travels
A dapp has two kinds of calls. Reads, such as a token balance, go to a node over JSON-RPC with methods like eth_call and cost nothing. Writes change state, so they must be signed transactions sent with eth_sendRawTransaction or through the wallet.[3]
The wallet sits in the middle. Through the EIP-1193 provider, the page asks the wallet to connect and to send a transaction; the wallet shows the details, signs with your key and returns a transaction hash.[4]
Many dapps do not run their own nodes. They use an RPC endpoint from an infrastructure provider and index historical events with a separate service, because querying raw chain history through RPC alone is slow.
Events are the third piece. Contracts emit logs when something happens, such as a transfer or a swap, and apps read those logs with eth_getLogs to rebuild history. Scanning a long history this way is slow, which is why dapps with long histories rely on indexers.[3]
See also: Web3 development stack · Ethereum RPC endpoints
Worked example: a swap on Uniswap
Uniswap's docs describe it as a set of open-source, non-upgradeable smart contracts that let anyone swap tokens, provide liquidity or create markets, with no ability to restrict who uses it. The official app is one of many ways to call it.[5]
A first-time swap of an ERC-20 token usually takes two transactions. The first is a token approval that lets the swap contract move your token; the second is the swap itself. EIP-7702 cites exactly this approve-then-spend flow as a common DEX workflow that needs two transactions, each with its own gas fee.[9]
On Ethereum mainnet a plain ETH transfer uses 21,000 gas; a swap needs more because it runs contract code. At a 10 gwei base fee and 2 gwei tip, the 21,000 gas transfer costs 0.000252 ETH, a useful floor for estimating what a swap will cost.[6]
Because the pool contracts are open to any caller, other interfaces and aggregators can route orders through them, which is the dapp model working as designed.[5]
The approval step can be skipped on later swaps of the same token, because under ERC-20 an allowance lets the spender withdraw multiple times up to the approved amount. That convenience is also the reason to set a specific amount rather than an unlimited one when the wallet offers the choice.[10]
Dapp versus a normal web app
The differences show up in who holds state and who can change the rules.
| Aspect | Traditional web app | Dapp |
|---|---|---|
| Backend logic | Company servers | Smart contracts on a blockchain |
| User login | Email and password | Wallet signature |
| Data | Private database | Public chain state anyone can read |
| Changing the rules | Company deploys new code | Only if the contract has upgrade or admin functions |
| Cost per action | Paid by the company | Gas paid by the user or a sponsor |
Where dapps are less decentralized than they look
Contracts can include an owner role, a pause switch or an upgradeable proxy. Those features can help fix bugs, but they mean a key holder can change behavior. Uniswap's docs state the opposite for its core contracts: no party can pause them or change protocol behavior retroactively. Reading the contract, or the project's own docs on admin keys, tells you which applies.[5]
Data outside the chain is another dependency. Files often sit on IPFS or a cloud bucket, and the interface itself depends on a domain name. Ethereum.org's storage docs point out that every node must store all on-chain data, so putting large data on chain would be prohibitively expensive.[7]
Front ends can also be hosted on decentralized storage such as IPFS, which ethereum.org mentions as an option for dapps and which removes the single hosting account as a point of failure.[1]
Common dapp categories
Common dapp categories include decentralized exchanges (Uniswap, Curve, Jupiter on Solana), lending markets, NFT marketplaces (OpenSea, Magic Eden), name services (ENS) and prediction markets (Polymarket).
Each still follows the same pattern: a set of contracts, a web interface, a wallet connection, and an indexer for history. Once you recognize the pattern, a new dapp is easier to evaluate.
Games and social apps follow the pattern less strictly. Many keep most data off chain for speed and use the blockchain only for ownership of items or identities, a sensible trade-off that also means less of the app survives if the operator leaves.
See also: ENS · OpenSea · Polymarket · Jupiter
How to check a dapp before connecting
Find the contract addresses in the project's docs, not from a search ad. Uniswap, for example, publishes its deployment addresses per network and warns integrators not to assume the same address across chains; a lookalike site will point to different ones.[8]
Open each address on a block explorer. Verified source code means the explorer compiled the published source and matched it to the deployed bytecode. Unverified code is not proof of fraud, but it removes your ability to see what a function does before you call it.
Read the wallet prompt on the first interaction. A connection request only reveals your address. An approval request names a spender and an amount, and under ERC-20 that spender can withdraw up to the amount for as long as the approval stands.[10]
Check what the app does with reads. Because reads are free JSON-RPC calls, a dapp can show balances and quotes without any signature. If a site asks you to sign before showing anything, ask why.[3]
Last, revisit approvals after you finish. Revoking an old approval is a cheap transaction and removes a standing permission that a future bug in that contract could otherwise exploit.
See also: Revoke.cash · Etherscan · Glossary: token approval
The bottom line
Judge a dapp by its contracts, not its website. If the contracts are verified, audited and free of an unchecked admin key, the app keeps its promises even when the interface changes; if a single key can upgrade them, you are trusting that key holder as you would a normal company.
Educational content, not financial advice. Crypto assets are volatile; do your own research.