
Web3 UX design: a practical guide to wallets, fees and trust
Imran KhanNovember 16, 202612 min read

table of contents
Picture the first visit to a Web3 product. The screen asks for a wallet, then a network switch, then a signature written in hex, and the visitor closes the tab.
That's the job of Web3 UX design: making a product that moves real money, can't be undone and runs on someone else's network feel safe and ordinary to use. This guide covers the parts every dapp has to get right (connecting, fees, signing, waiting, failing, recovering), what changes for DeFi, DAOs, games and wallets, and how to test it without a big budget.
A quick note on where we stand. We're a UI/UX design agency, and we've designed one Web3 product, Reputable. It signs developers in with GitHub, not a wallet, so we won't pretend it taught us everything below. We'll say which advice comes from that project and which comes from the sources we checked. If you want to see how a wider field does this work, we also compared Web3 design agencies.
The short version
- Don't ask for a wallet before the person knows why. Show the product first, ask to connect when an action needs it.
- Show the real cost of every action before the click: the fee, the amount and what happens if it fails.
- Make every signature readable. If a person can't tell what they're signing, they shouldn't be asked to sign it.
- Give every waiting state a name. Sent, pending, confirmed and failed are four different screens.
- Plan for the lost phone before launch. Recovery is part of the design, not a support ticket.
- Test with a few people who've used crypto and a few who haven't. They'll get stuck in different places.
What is Web3 UX design?
Web3 UX design is the design of products built on a blockchain: wallets, exchanges, lending apps, DAOs, games and the dapps (decentralised apps) around them. It covers the same craft as any product design, plus a layer that Web2 products don't have: a wallet you connect, a fee you pay per action, a signature you can't take back and a network that can be busy.
ethereum.org describes the shift in one line: Web1 was read-only, Web2 is read-write and Web3 will be read-write-own (Introduction to Web3). Ownership is the good part. It's also the hard part to design, because ownership means the person holds keys, and nobody can reset a password for them.
How Web3 UX differs from Web2
| What | Web2 product | Web3 product |
|---|---|---|
| Sign-in | Email and password, reset by support | A wallet; lose the keys and nobody can reset them |
| Paying | A card, one clear price | A fee per action that changes with network demand |
| Mistakes | Often reversible | Often final |
| Waiting | A spinner, usually seconds | Pending on a network you don't control |
Two things in that table drive almost everything else in this guide. Actions cost money every time, and mistakes are hard to take back. Both mean the interface has to say more than a normal one, and say it in plainer words.
The rest of the field agrees on the big picture. Coinbound's guide lists wallet connection, network switching, gas fees and on-chain waits as the standard trouble spots (Coinbound), Avark's guide covers patterns for wallets, DeFi and games (Avark), and Cheesecake Labs puts technical complexity and security first (Cheesecake Labs). We've organised this guide by moment in the journey instead of by principle, because that's where the design decisions actually get made.
Onboarding and wallet connection
The first screen is the one to get right first. A few rules we'd hold to:
- Let people look first. Show prices, positions, proposals or profiles before anyone connects. A "Connect wallet" button on an empty page asks for trust you haven't earned.
- Ask for the wallet at the moment of need. "Connect to vote" beats "Connect to continue".
- Cover the person with no wallet. Say in one sentence what a wallet is and name two ways to get one. That's our own rule: we didn't find it spelled out as one in the guides we read.
- Offer more than one way in on mobile. Hackernoon's guide suggests detecting the wallets a person already has installed and offering QR code scanning as an alternative connection method, especially on mobile (Hackernoon).
- Explain network switches. Coinbound notes that moving from Ethereum to another chain is jarring and that many users don't understand why it's needed (Coinbound). A prompt that says "this app runs on a different network, we'll switch it for you" does more than a raw wallet popup.
- Say what connecting does and doesn't do. A connection lets the app see an address. It shouldn't move anything. Put that in plain words next to the button.
Mobile deserves its own line. On a phone, people have to bounce between your site and a wallet app. Test that round trip first, on a real phone, with a real wallet, because in our experience it's an easy place for a flow to break.
### Use a different front door when the product allows
Not every Web3 product needs a wallet on day one. On Reputable, the product is a reputation platform for Web3 developers, and people sign in with GitHub. Nobody has to connect a wallet to see their own work. The profile is built from public work before its owner arrives, so signing in is claiming something that already exists, not filling in a form. We called that "claim, don't sign up" and it's the single idea from the project we'd carry into any Web3 onboarding: start people with something that's already theirs.
Fees, signing and approvals
This is where Web3 is most unlike everything else, and where the cost of bad design is highest.
### Fees: show the number before the click
On Ethereum, the gas fee has two parts: a base fee set by the protocol and an optional priority fee, a tip that makes validators more likely to include your transaction (ethereum.org, Gas and fees). The same page says a transaction that fails validation is rejected and uses no gas, but one that runs out of gas halfway reverts its changes and still consumes all the gas provided.
That last point is a design problem. A failed transaction can still cost money, so your interface has to say that before it happens, not after. What we'd show on the confirm screen:
- The amount, the fee and the total, in the currency the person thinks in.
- A range or a "could be higher when the network is busy" note, not a single number that's wrong ten seconds later.
- A plain line about what happens if it fails.
- Speed as a choice only if you can explain it in one sentence.
### Signing: make it readable
When a wallet asks someone to sign a message, they often see an opaque hex string. EIP-712, the standard for typed structured data signing, was written because "signed messages are an opaque hex string displayed to the user with little context" (EIP-712). Its fix is to encode the data with its structure so it can be shown to the user for verification when signing.
If you control the signing request, use that. (This section and the recovery one are our advice, built on the sources named, not lessons from Reputable.) Show who is asking, what they're asking for and what it will let them do, in sentences. If you can't make a signature readable, ask whether you should be asking for it at all.
### Approvals: the quiet permission
Many apps ask for permission to spend a token, and some ask for unlimited permission so the person only pays the fee once. ethereum.org explains the reason and the risk: projects do it to minimise requests, which is convenient, but it can be dangerous when people approve carelessly on sites that aren't proven or audited. It also says some wallets let people restrict the amount, and that you can revoke access with tools (ethereum.org, How to revoke smart contract access).
For design, that means:
- Ask for the amount the action needs by default, not unlimited.
- If you offer unlimited, make it a labelled choice with the downside written out.
- Give people a place in your own app to see and revoke what they've approved.
Slippage belongs here too. Uniswap's docs define it as price changes that can occur while a submitted transaction is pending (Uniswap docs). On any swap screen, show the expected price, the minimum the person will accept and what "slippage" means in one line.
Waiting, failing and recovering
### Waiting
After someone signs, the transaction goes into a pool of pending transactions and a validator has to include it in a block before it counts as successful (ethereum.org, Transactions). The person doesn't know any of that. Give them a status that moves:
- Sent: we've handed it to your wallet.
- Pending: it's on the network, not confirmed. Say how long this usually takes, honestly.
- Confirmed: done, with what changed.
- Failed: what happened, whether it cost anything, and what to do next.
Don't lock the whole screen while it waits. Let the person leave and come back and find the status where they left it.
### Failing
Every Web3 product has a failed-transaction screen whether the team designed it or not. The default is a red toast with a code. Design it: what went wrong in words, whether money moved, one next step. Hackernoon's guide asks for clear, conversational language in error messages instead of technical codes (Hackernoon).
### Recovering
Most wallets give you a seed phrase to write down, and ethereum.org says it's the only way to recover the wallet (ethereum.org, Wallets). That works until the paper is lost. Account abstraction is the newer route: ethereum.org lists social recovery if you lose your keys, paying or having someone else pay gas, and batching steps like approve and swap into one (ethereum.org, Account abstraction). If you're building a new product, ask whether you can use it, because each of those removes a screen where people get stuck.
If you can't, then design the seed phrase step like it matters: one instruction per screen, a check that they wrote it down, and a clear line about what happens if it's lost.
Build trust into the interface
Web3 users have good reasons to be suspicious. Coinbound's trust patterns include transaction previews, visible state and error handling, secure defaults and recovery flows (Coinbound). In practice, trust is mostly small, boring things done consistently:
- The same words for the same thing on every screen.
- No fake urgency, no countdowns that restart.
- A way to check every number. This is the big one.
On Reputable, every figure had to lead somewhere. Developers' scores come with the commits behind them, the protocols they touched and the peers who vouch for them. Reputable's founders could already score developers; what they needed was a product that made the score believable, so we made each number lead to its evidence. Our view, not a measured finding: a number that's one click from its proof earns more trust than a badge. The same idea works for a DeFi balance (show the transactions behind it), a DAO vote (show who voted) and a yield figure (show how it's calculated).
Plain language and progressive disclosure
Coinbound's guide lists avoiding jargon and progressive disclosure (showing advanced detail only when it's needed) among its core principles (Coinbound). We agree and would add a rule: name the thing, then show the word once. Write "the fee for this action (gas)" the first time and "fee" after. People learn the term without being quizzed on it.
Text contrast belongs in this section as well. WCAG asks for a contrast ratio of at least 4.5:1 for normal text (W3C). Grey captions on a black background are easy to get wrong in a dark interface, and fees and numbers are what people most need to read.
On Reputable we also kept the data dense on purpose, with one type scale, one set of score chips and generous rows, and drew every screen in dark and light. Our view: people who read tables all day want density, as long as it's calm. Peers matter too: endorsements and written reviews sit on every profile beside the numbers, not under them.
How the product type changes the design
### Wallets
Wallets own the riskiest moments: key creation, signing and recovery. Keep one decision per screen, put the recovery step where people can't skip it, and make the sign screen the most careful one in the product.
### DeFi apps
People move funds and want to check numbers fast. Show the amount, the fee, the minimum received and the risk before the button. Keep advanced controls (slippage, routes) one tap away, not on the front. Our fintech agency guide covers how regulated finance products handle the same trust problems.
### DAO governance
A DAO is an organisation run by proposals and voting, with a treasury nobody can touch without the group's approval (ethereum.org, What is a DAO?). The design questions: what is this proposal in two sentences, what changes if it passes, who's voting and how much voting power they hold, and when it closes. Snapshot, a voting platform for DAOs and DeFi protocols, lets people vote without gas fees (Snapshot docs). A vote with no fee changes the design: you can ask people to vote often without making each vote a cost decision.
### Games (GameFi)
Games sit between a product and a toy. The wallet and fee prompts have to stay out of the way of play, so batch actions where you can and keep signatures for moments that matter. We haven't designed a Web3 game, so treat this as our reasoning, not a case study: if a prompt interrupts play, ask whether it needs to exist yet.
Dapp UI design best practices (the checklist)
- A useful first screen before any wallet is connected.
- "Connect" appears at the moment of need and says what it does.
- Network switches are explained and automatic where possible.
- Fee, amount and total are shown before each action, with the failure case in a line.
- Every signature is readable.
- Approvals ask for what's needed, with a visible revoke.
- Four status states: sent, pending, confirmed, failed.
- Failure screens say whether money moved.
- Recovery is designed before launch.
- Text passes 4.5:1 contrast on every dark surface.
- The whole flow is tested on a phone with a real wallet.
- Every number can be traced to its evidence.
How to test Web3 UX
Jakob Nielsen's finding is that the best results come from testing no more than five users and running as many small tests as you can afford. For two groups of users he recommends three to four from each (NN/g). For Web3, our two groups are people who've used a wallet and people who haven't: test three or four of each. Give each a real task ("swap this for that", "vote on this proposal") with a small real balance, and watch where they stop. Don't explain anything while they try. Wherever you'd want to explain, redesign.
What Web3 UX design costs
Coinbound says a basic wallet integration with a clean UI might cost $3,000 to $7,000, while complex platforms, such as DeFi dashboards or staking interfaces, can cost $20,000 or more (its list also includes NFT marketplaces, which we don't cover) (Coinbound, read 16 Nov 2026). Their range is theirs, not a quote. Ours are on our pricing page: fixed-scope projects start from $5,000, and monthly plans start from $2,000. Each plan covers design and build in the same hours.
What pushes the cost up in Web3 is the number of chains, custom contract interactions and the number of states you have to draw: pending, failed and recovery screens multiply the count fast. Reputable took three months from zero to launch and ended with 22 screens, in both themes.
FAQ
The design of the experience of products built on a blockchain: wallets, DeFi apps, DAOs and games. It covers wallet connection, fees, signing, waiting, failure and recovery, on top of normal product design.
Sign-in is a wallet with keys nobody can reset, every action can cost a fee, and mistakes are often final. The interface has to explain more, in plainer words.
Let people look before connecting, show real costs before the click, make signatures readable, name every waiting state, design recovery and test with newcomers. The checklist above has all twelve.
Because the product runs on a network you don't control, so fees, delays and failures leak into the screen, and keys put the responsibility on the user.
Show the fee before the action, in plain terms, with a note that it can change. ethereum.org says a transaction that runs out of gas halfway still uses the gas provided, so say what happens on failure.
Ask at the moment of need, say what connecting does, cover people without a wallet and explain network switches.
Usually, to act. Many dapps let you look first. Some products use another sign-in: Reputable uses GitHub.
It lets accounts have programmable security: social recovery, sponsored gas and batched steps, per ethereum.org. Each removes a point where people get stuck.
Coinbound gives $3,000 to $7,000 for a basic wallet integration and $20,000 or more for complex platforms. Our projects start from $5,000 and plans from $2,000 a month.
Three or four newcomers and three or four people who've used crypto, real tasks, a small real balance, no explaining.
If you're designing a Web3 product and want a senior team to look at the screens you're least sure about, book a call and bring them. Our UI/UX design services cover the whole flow, from the first sketch to the design system.
About the author
Imran Khan, Founder & Creative Head
15 years of industry experienceFormer Head of Design at Day TranslationsFormer Creative Lead at SupersideWork at Superside for brands including Meta, Red Bull and Ray-Ban

related articles
Book a call
Pick a time that suits you
Get in touch
Let’s build something amazing together
Let’s build somethingamazing together
For product, interface and web-system work that needs clear direction and careful execution.





