
Crypto app design: how to design a wallet, exchange or trading app
Imran KhanNovember 17, 202617 min read

table of contents
Most crypto apps get designed twice. The first time is for the demo, where everything is clean and the balance only goes up. The second time is after real users arrive and start asking what a network fee is, where their money went, and whether the app is safe. This guide is about designing for that second moment from the start.
It covers wallets, exchanges and trading apps, portfolio trackers and swap screens. It's written for founders and product people who are about to brief a designer, and for designers who've been handed their first crypto brief. We're a design studio, so we're not neutral, and we'll say what we have and haven't done. Every outside fact is linked to the page it came from, read on 17 November 2026.
The short version
- Decide which kind of app it is. A wallet, an exchange and a portfolio tracker answer different questions, so they need different home screens.
- Answer three questions on the home screen. What do I have, what just happened, and what can I do next?
- Show every amount twice. The token amount and what it's worth in the user's own currency, side by side.
- Never let colour carry the message alone. Red and green for price moves need a sign, an arrow or a word beside them.
- Make irreversible actions feel irreversible. A send screen should slow people down in the right places, and only there.
- Design for beginners and experts in the same app. Hide the pro detail one tap away rather than building two apps.
- Test with people who've never used crypto. Your team can't see the jargon anymore.
What crypto app design covers
"Crypto app" is a loose label. Gapsy Studio describes crypto app design as the experience of checking balances, buying and selling, tracking prices and performing other crypto transactions on a mobile or web app. That's right, but it hides four quite different products:
| App type | The question it answers | Where the design effort goes |
|---|---|---|
| Wallet | What do I hold, and can I move it safely? | Balance, send, receive, recovery |
| Exchange or trading app | Can I act on the market right now? | Charts, order forms, speed, detail |
| Portfolio tracker | How am I doing across everything? | Aggregation, history, clarity |
| Swap or DeFi app | Can I trade one token for another without getting hurt? | The swap form, fees, risk |
Plenty of real products mix two or three of these. A wallet with a swap button is a wallet and a swap app. The job at the start is to pick the main one, because it decides what the first screen is for.
Lazarev.agency, in its crypto app design guide, groups the work into four pillars: security-first flows, data readability, scalability and what it calls emotional trust, meaning visuals that reduce anxiety in volatile markets. We'd add one that sits under all four, which is plain language. Most of the other advice in this guide is a version of it.
If you're comparing studios rather than learning how it's done, our list of Web3 design agencies is the better place to start.
Start with who it's for
Every ranking guide tells you to analyse your audience, and then stops. Here's what that analysis should produce.
Lazarev ran UX research with 1,600 participants for the wallet app Dollet, as it describes in its wallet design guide, split across crypto newcomers, beginners and experienced traders, and reports that the assumptions most teams hold turned out wrong. In its write-up, newcomers didn't need fewer features, they needed clearer explanations of the features that were there. Beginners didn't mainly want education, they wanted confidence that their transaction wouldn't fail. Experienced users didn't need more tools, they needed the existing ones better organised. Those are Lazarev's own findings from its own project, so treat them as one agency's evidence, not a law. But they point at something we've seen too: a simple app and a powerful app aren't opposites.
Surf, a development studio, goes further on trading apps. It says buyers aren't just "pros" and "newbies" and lists scalpers, day traders, swing traders, position traders and fundamental traders, each with a different time horizon. Its example of how that changes the product: when it built the trading app Twim, it studied ten leading exchanges and interviewed potential customers, and found that beginners wanted to buy and sell, watch their portfolio and track open positions, while experienced traders wanted a full terminal and preferred tablets for the extra room. Surf built phone and tablet versions in response.
Turn all this into a short list before any screen is drawn:
- The two or three kinds of person who'll use the app, in their own words.
- What each one is trying to do in their first session.
- What each one is afraid of. For a wallet it's usually sending to the wrong place. For an exchange it's usually a bad fill or a frozen screen at the wrong moment.
That third list does the most to decide the interface.
The home screen: three questions
Lazarev's wallet write-up gives a useful test. After the Dollet redesign, the home screen answered three questions straight away: how much do I have (a large, clear balance), what happened recently (transaction widgets), and what should I do next (contextual quick actions). In the same write-up, Lazarev says that typical wallets bury the balance three taps deep and hide send and receive in menus.
We use the same three questions for any money app, crypto or not. They fit on one screen, and they're a quick way to catch a home screen that's really a marketing page.
The detail we'd add from our own work is about whose money is on the screen. When Dino came to us, it already had a working group payments app, and people could use it, but they couldn't always tell what it was showing them. A group's balance, "your balance" for that group, a personal balance and a list of groups each carrying two more figures all sat on the home screen, with no hint about what to do first. Our rule for the redesign was that every number says whose money it is, and every screen has one obvious next step. Home now opens on your own balance, with three actions under it, and group money appears as a card you pay from.
Dino is a payments app, not a crypto app, and we won't pretend otherwise. But a crypto home screen has the same trap in a worse form: a wallet might show a total balance, an amount per chain, a staked amount, and a pending amount, all in different units. Label each one, say what it belongs to, and let one of them lead.
Wallet screens
A wallet comes down to four jobs: show what you hold, let you send, let you receive, and let you get back in if something goes wrong.
Balance and assets. Lazarev's wallet guide calls out a common failing: assets shown like spreadsheet rows, with name, balance and percentage change and nothing else. Its fix is to treat each asset page as a place to decide something, with price trend, performance over several timeframes and relevant news. We'd keep that and add one rule of our own: always show the amount in the user's local currency next to the token amount.
That one isn't only our view. The ethereum.org design guide for decentralised exchanges says that if you're building any sort of Web3 project, it's essential to show a fiat equivalent, because users still think in their local currency. It notes that early DeFi apps often left it out.
Send. A wrong address can mean permanent loss. Lazarev's wallet guide describes the fixes it used in Dollet: validating the address before confirmation (catching a wrong network or an invalid format), a clear fee breakdown in the user's preferred currency, a live status that moves from "pending" to "confirming" to "completed" without leaving the main screen, and plain language for every state. We'd treat those four as the minimum.
Two of those details are worth a closer look because they're easy to get wrong visually. For the second, the lifecycle comes from ethereum.org's transactions page.
- The confirm screen should repeat, not summarise. Show the amount, the recipient, the network and the fee once more, in the same words and the same order as the form. A summary that rewords things makes people read it again to check it's the same.
- The status needs a visible end. ethereum.org describes the lifecycle of a transaction: it's broadcast to a pool, a validator includes it in a block, and the block is later marked "justified" and then "finalized". Users don't need those words, but they do need to see that "sent" and "done" are different moments, with a clear final state.
Fees, signing screens, approvals and failed transactions each deserve more room than we can give them here, so we've covered them in our Web3 UX design guide.
Receive. Keep it plain. A large code, a copyable address, and the network named in words next to it. The common mistake is to show an address without saying which networks it works on.
Recovery. Lazarev reports that in Dollet it replaced "seed phrase" with "recovery code", "gas fees" with "network fees" and "slippage tolerance" with "price flexibility", after finding that jargon hurt retention. Whether you rename these terms is a product decision, because the wallet's users will meet the original words in other apps. We'd test it. The principle that holds either way is to explain the term at the moment it matters, not on a separate education screen nobody reads.
There's also a structural change worth knowing about. ethereum.org explains that accounts secured by a seed phrase are an awkward fit for ordinary people: if the keys are lost the assets are permanently inaccessible, and seed phrase phishing is one of the most common scams. Smart contract wallets, which account abstraction makes easier to build, can allow recovery if you lose your keys, batch steps together, and let someone else pay fees. If your product can use them, the recovery screen you design is a very different one.
Exchange and trading screens
A trading screen has the opposite problem to a wallet. The user is already engaged, and the job is to put a lot of information in front of them without burying the one thing they need.
The swap form. ethereum.org's guide to DEX design is the best short source we've found, and it's open about how a pattern forms: it says design decisions across decentralised exchanges have been standardising as things that worked stayed and things that didn't were dropped. It breaks a swap screen into three parts: a main form, a button and a details panel. In the form, four pieces of information have a natural home, one in each corner: the balance in the wallet, a max button, the fiat equivalent and the price impact.
Its advice on the details panel is the part we'd steal. The extra information (slippage, minimum received, gas cost estimate, other fees, order routing) is mostly for pro users, so keep it minimal or hide it in an accordion. Some of it restates the same thing in different ways, since "minimum received" and "slippage" are two sides of one coin. And if you show slippage in the panel, make it editable right there, which ethereum.org calls an accelerator: a trick that speeds up experienced users without changing the experience for everyone else.
Two more choices from that guide are worth copying into your own thinking. Percentage buttons such as 25%, 50% and 75% can help, but they take space, add calls to action and add mental load. And a preview screen creates friction that forces people to slow down and consider the trade, which is useful, as long as it doesn't repeat every detail they just saw.
Charts and market data. Surf and Gapsy both name data visualisation as a main design job, because prices change constantly and several metrics can't overlap on one chart. Gapsy's advice is to add labels, titles and annotations so the data means something, and to test chart types with real users. Surf used the TradingView library for the charts in Twim, which is built for interactive financial charts. You often don't need to design a chart engine from scratch, and a design team's time is better spent on what sits around the chart: the time ranges, the labels, the way a price change is shown and the way the chart behaves on a phone.
Order forms. Keep the form to what the user has to decide. For a simple buy, that's the asset, the amount and the total with fees. For a pro order ticket, it's the order type, price, size and the risk controls. The failing we see most is putting the pro form in front of everybody. Offer a simple mode and an advanced mode, and let people change their own.
Speed. Our view: a trading screen is judged by how fast and stable it feels, so the design needs states other than "ready": loading, stale prices, a lost connection, and orders that didn't fill. Design them on purpose, or the first time users see them will be in the middle of a trade.
Numbers, colour and contrast
This is the part none of the three top-ranking guides cover, and it's where we'd expect a design studio to earn its fee.
Show the sign as well as the colour. Red for down and green for up is the convention, and it's a trap. The W3C's guidance on use of colour says colour shouldn't be the only visual way to convey information, because some users can't perceive the difference. In a crypto app that means a price change should carry a plus or minus sign, or an arrow, or a word, as well as a colour. It's cheap to do and it also reads better at a glance.
Check the contrast on dark screens. The W3C's Contrast (Minimum) criterion sets a minimum contrast ratio of 4.5 to 1 for normal text, and 3 to 1 for large text. Dark interfaces with dim grey secondary text are common in crypto apps, and they often fail it. Test the grey you use for labels, timestamps and fees, because those are the details users need when something has gone wrong.
Format numbers on purpose. This one is our view, not a standard. Align amounts on the decimal point in lists so the eye can compare them. Decide how many decimals each asset gets, and keep it the same everywhere. Don't round away the last digits on a send screen, where the exact amount matters, but do round on a portfolio overview, where a long decimal tail is noise. Use thousand separators. And use the same wording every time for the same thing: if it's "network fee" on the form, it isn't "gas" on the receipt.
Design the empty and the zero state. A new wallet has no balance, no history and no assets. Say what to do first, on the screen itself.
Reputable, a Usarion project, is our nearest example of a data-heavy Web3 screen. It's a reputation platform for Web3 developers, and it has a compare screen that puts two developers side by side, with skills on one chart and score, commits and value enabled head to head. It's not a wallet or an exchange. It's a Web3 product built on public data, so the same problems show up in a smaller form: a score is only believable if you can see what's under it, so every figure sits one click from its evidence, and a profile can be compared with another on one screen. Reputable ships in both dark and light. The screens in this guide are from Dino, our money app, not a crypto product.
Dark theme, light theme or both
Surf reports that in its Twim research customers favoured a dark theme, because it suited late-night use and was easier on the eyes. That matches what many trading products ship. Our view: design both. People use phones in daylight, and a second theme isn't much extra work if the colours are set up as tokens from the start. Pick the default from your audience, and make sure the other theme is no afterthought, since a user will find it.
Security cues that people can read
Gapsy and Surf both treat security as a design priority. Gapsy's list is two-factor authentication, secure storage, user education on security habits and regular audits. Two-factor prompts and the education are interface work. Storage and audits are engineering, and you should have them, but a user can't see them.
What a user can see is how the app explains what they're about to do. Shakuro, a development studio, makes a distinction we find useful for designers: application login, local unlock and blockchain authorisation are separate controls. A biometric prompt may unlock a secret stored on the phone, but it doesn't prove the recipient or the contract is trustworthy. So the screen that asks for a fingerprint shouldn't look like it's vouching for the transaction.
Some practical cues. The last two come from Lazarev's Dollet notes and from Turnkey's guide to embedded wallets, which are in the same list because they're about the same moment.
- Say what's being approved, in words. "Send 0.5 ETH to this address on this network" beats a hash.
- Make a different action look different. Sending, swapping and approving shouldn't share the same button colour and wording.
- Put help where the fear is. Lazarev's Dollet notes give contextual tips at the exact moments users stall, for example when choosing a network or checking an address format, not up front.
- Show where the app's control ends. Turnkey's guide on embedded wallets points out that when the wallet lives inside the product, the team can match wallet actions to the app's own branding, error states and visual hierarchy. That's a design opportunity and a responsibility, since a user won't know which part of the screen belongs to which system unless you tell them.
Phone, tablet and desktop
Lazarev's wallet guide argues for designing for mobile first because that's where crypto happens, with people commuting, waiting in line and multitasking. We agree for wallets. For trading, Surf's Twim finding is a reminder that a phone and a tablet are different jobs, and that experienced traders may want the larger screen for depth of market.
Two practical notes. First, design from one system for iOS and Android, with each platform keeping its own conventions, which is how we approach it on our mobile app design work. Second, design the tablet and web layouts at the start of the project if the product will need them, since a phone layout stretched to a tablet is usually where a trading terminal goes wrong.
The design system
A crypto app has more states than most. A single transaction row might be pending, confirmed, failed, replaced or cancelled, in a dozen asset types, with two themes. Components, tokens and status styles written down once keep screen ten looking like screen one. It's also what lets the next designer, or a developer, extend the app without quietly starting again. Reputable's three-month project, from sketch to launch, ended with a design system ready for the client's developers.
How the process works, and how long it takes
Lazarev lays out five steps: discovery and research, UX strategy and wireframing, visual language and prototyping, testing and iteration, and launch and optimisation. It's a sensible shape and it's close to how most studios work.
Ours, on the mobile app design page, runs like this: understand the job (usually two to three days), map every flow and state, design a clickable prototype, test on real devices, and ship and iterate. For timing, our page says most apps take four to eight weeks to design, with flows and a prototype taking another two weeks after the first two to three days, and real screens visible in the first week. A crypto product with several app types, a pro mode and two themes will sit at the longer end, and that's an estimate from us, not a quote. The design plans on our pricing page show how we charge, and our crypto app cost guide compares what other companies publish for building one.
Mistakes we'd avoid
- The chart comes first. It's the exciting part and the smallest part of the job. Start with a new user's first session.
- A home screen for the team. If your team can't answer "what do I do first?" from the home screen, a new user can't either.
- Unlabelled balances. Total, available, staked and pending are four different numbers.
- No user testing. Lazarev's wallet guide makes the point that your own team knows the product too well to see its flaws.
What we've done and what we haven't
Usarion designs mobile apps, web products and the sites around them. We haven't designed a crypto wallet or an exchange. What we have done is Reputable, a Web3 product in dark and light with dense data, and Dino, a money app where the work was making every balance mean one thing. We've applied the same habits here. If you need someone who has shipped a licensed exchange, ask for that specifically from any studio you're talking to, ours included.
FAQ
A balance that's easy to read, send and receive or trade actions within reach, recent activity with a clear status, the value of every amount in the user's currency, a way to get back in if something goes wrong, and plain help at the moments people get stuck.
Keep one app and layer it. Show the simple version first, and put pro detail such as slippage, routing and fee settings one tap away. Lazarev's research suggests beginners need confidence that a transaction won't fail, and experienced users need existing tools better organised.
The actions are often irreversible, the vocabulary is unfamiliar, and the numbers change by the second. So there's more weight on confirmation screens, plain language and live status than in most apps.
Separate the controls and explain each one. Login, unlocking the phone and authorising a transaction are different things, as Shakuro points out. Slow people down on the irreversible step, and only there.
Our mobile app design page says four to eight weeks for most apps. A product with trading, a pro mode and two themes will likely be at the longer end. That's our estimate, not a fixed quote.
Many do, and Surf found customers favoured it for a trading app. Design both and choose the default from your audience.
Unlabelled balances, jargon with no explanation, status screens that don't show a final state, and confirm screens that reword what the user just entered.
We can design the screens and prototype them. We haven't designed a licensed exchange, so for that we'd want you to ask for a studio's exact experience.
If you're planning a crypto app and want the first sessions, the home screen and the send flow designed before the expensive part starts, book a call. Our mobile app design work takes an app from first flow to store listing.
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.





