How Are dApps Made? The Parts, the Process and the Tools

On this page
Hi! I think making a DApp could be a pretty good idea. However, I'm not sure where to even begin. Do you have any suggestions?
The short answer
A decentralized application (dApp) is made by writing smart contracts that run on a blockchain and pairing them with a front end, usually a website, that users connect to with their own crypto wallet. The contracts hold the rules and the money; the front end is just a convenient way to read them and to ask the user’s wallet to sign transactions. ethereum.org describes a dapp as an application that combines a smart contract and a front-end user interface, with its back-end code running on a decentralized peer-to-peer network rather than on centralized servers.
This page explains how dApps are put together and the stages a team goes through. If you want to build one yourself, follow our step-by-step guide on how to make a dApp.
What a dApp is made of
| Part | Role | Typical choices |
|---|---|---|
| Smart contracts | The back end: store state, enforce rules, move tokens | Solidity or Vyper on Ethereum and EVM chains; Rust on Solana; Move on Sui and Aptos |
| Blockchain | Runs the contracts and records every transaction | Ethereum, a layer 2 such as Arbitrum or Base, Solana, BNB Chain |
| Wallet | Holds the user’s keys and signs transactions | Browser and mobile crypto wallets |
| Front end | The interface people click on | React or Next.js with libraries such as viem and wagmi |
| Node access (RPC) | Lets the front end read the chain and broadcast transactions | Your own node or a hosted RPC provider |
| Indexing and storage | Fast queries over past events; files too big for the chain | Indexers or subgraphs; IPFS or similar for files |
The big difference from a normal app is that there is no user database or login. A user’s identity is their wallet address, and every action that changes state is a transaction they sign. The contract itself checks permissions. For more on the split between the two pieces, see dApp vs smart contract.
How dApps are made, stage by stage
- Design the mechanism. Decide what must live on-chain (balances, rules, anything users must be able to verify) and what can stay off-chain (images, search, analytics). On-chain storage and computation cost gas, so teams keep contracts lean.
- Choose a chain. This decides the language and tooling. Ethereum and its layer 2s share the Ethereum Virtual Machine, so the same Solidity code can run on many of them. Our Q&A on alternatives to Ethereum for building dApps compares options.
- Write the smart contracts. Developers usually build on audited libraries, such as OpenZeppelin Contracts for tokens and access control, rather than writing everything from scratch. See how to create a smart contract.
- Test locally. Toolkits such as Foundry and Hardhat 3 compile contracts, run them on a local test chain and support unit tests, fuzz tests and simulations against a copy of mainnet. On Solana, the Anchor framework plays a similar role.
- Deploy to a testnet. On Ethereum, ethereum.org names Sepolia as the recommended default testnet for application development. Test tokens are free, so the team can try the full flow with real wallets.
- Build the front end. The interface connects to the user’s wallet, reads contract data through an RPC endpoint and prepares transactions for the user to approve. Many teams now also support smart-contract wallets (ERC-4337 accounts, or ordinary accounts upgraded through EIP-7702 since Ethereum’s May 2025 Pectra upgrade), which allow batched transactions and sponsored gas.
- Audit. Anything that will hold user funds is typically reviewed by one or more independent smart contract audit firms, and many teams add a bug bounty.
- Deploy to mainnet and verify the code. Publishing verified source code on a block explorer lets anyone check that the deployed bytecode matches it.
- Host and maintain. The front end goes on a normal web host or on decentralized storage such as IPFS. The team monitors contracts, responds to incidents and, if the design allows, ships upgrades through an admin key, a multisig or a governance vote.
Upgrades: the part that differs most from web development
Deployed contract code cannot be edited. Teams handle that in one of two ways:
- Immutable contracts. Bugs are fixed by deploying a new version and asking users to move. This maximizes trust but makes mistakes permanent.
- Upgradeable proxies. Users interact with a proxy contract that forwards calls to a separate logic contract, which an admin can replace. OpenZeppelin documents this pattern. It is flexible, but whoever controls the upgrade key can change the rules, so users should check whether it sits with a multisig wallet, a timelock or token-holder governance.
How “decentralized” are dApps really?
Only the contracts are guaranteed to run on the blockchain. The website, the domain name, the RPC endpoint and the indexer are often run by one company and can be taken down, geoblocked or hijacked. Well-built dApps reduce this by publishing contract addresses, open-sourcing the front end, allowing alternative interfaces and hosting copies on decentralized storage. Many popular dApps can be reached through more than one interface, and power users can always call the contracts directly. See how to interact with dApps for the user side.
What it takes: skills, cost and time
- Skills: JavaScript or TypeScript for the front end, plus Solidity, Rust or Move for contracts, and a solid grasp of security patterns. Anyone can learn this; see can anyone build a dApp?.
- Cost: Testnets are free and deploying a small contract on a layer 2 is usually cheap. The large costs are developer time, audits, infrastructure and ongoing maintenance. Our breakdown of how much a dApp costs to build goes further.
- Time: A tutorial project takes hours. A production DeFi protocol usually takes months, with audits alone often adding weeks.
Risks and common mistakes
- Shipping without audits or tests. Bugs in code that holds money are the most common cause of losses. Read up on smart contract vulnerabilities before you deploy.
- Leaking deployer keys. Never commit private keys or seed phrases to a repository; use a hardware wallet or encrypted keystore for deployments.
- Over-powerful admin keys. A single key that can upgrade contracts or move funds is a target for attackers and a reason for users to distrust the app.
- Ignoring front-end security. Compromised domains and injected scripts have drained users even when the contracts were sound.
- Using retired tools. Consensys sunset Truffle and Ganache in late 2023, and the Goerli and Holesky testnets have been retired; current tutorials use Foundry or Hardhat and Sepolia (Hoodi is mainly for validator and protocol testing).
Browse the dApp development topic for more guides.
Frequently asked questions
What programming language are dApps written in?
The front end uses normal web languages, usually JavaScript or TypeScript with React. Smart contracts on Ethereum and EVM-compatible chains are mostly written in Solidity (sometimes Vyper); Solana programs are mostly written in Rust, and Sui and Aptos use Move.
Can you make a dApp without coding?
You can launch simple things like tokens or NFT collections with no-code tools, but anything custom needs code. Templates such as Scaffold-ETH 2 make starting easier for people who can program.
Do dApps need a server?
The core logic runs on the blockchain, so no server is strictly required. In practice most dApps use hosted RPC endpoints, indexers and a web host for the front end, which are centralized points of failure.
How long does it take to make a dApp?
A simple tutorial dApp can be built in a day. A production DeFi protocol typically takes months, including one or more independent security audits before launch.
Can a dApp be changed after launch?
The front end can be updated like any website. A deployed smart contract cannot be edited, but developers can deploy a new version or use an upgradeable proxy pattern, which lets an admin key or governance vote swap the logic.
Sources
Educational content, not financial advice. DeFi carries risk, including total loss of funds.