DeFi app design: how to design swaps, lending and staking people can trust

Product design

Imran KhanNovember 18, 202617 min read

Dark UI cards: a swap form, a health factor gauge and a staking chart

In a demo, a DeFi app always works. Then a real person types in an amount of their own money, and the screen has to answer three questions that nobody drew: What will I actually get? What could go wrong? Can I take it back?

This guide is about designing those screens. It goes product by product, from the swap form to lending, staking and the dashboard, and it covers what to show, what to hide and what to build for the moments when things fail. It's for founders planning a DeFi product and for designers who've been handed one. We're a design studio, so we'll stay with the screens, not the contracts. Every outside fact is linked to the page it came from, read on 18 November 2026. None of this is financial advice.

The short version

  • DeFi design is risk design. Transactions are usually final and people hold their own keys, so the screen has to show the consequence before the click, not after.
  • Each product type has one number that matters. Swap: what you'll receive. Lending: how close you are to liquidation. Staking: what you hold and what it earns. Design that number first.
  • Show the whole cost once, in the same words every time. Not three times in three wordings.
  • The approval and the action should feel like one step. Don't make people learn the difference between them.
  • Design every state, not just success. Pending, failed, stale quote, wrong network and a price that moved while you read.
  • Test with someone who has never used a wallet. Watch where they stop.

What makes DeFi screens different

A bank can often reverse a mistake, and a DeFi protocol usually can't. So in a DeFi app the screen doesn't only help you do something. It also has to help you not do the wrong thing, because nobody can step in afterwards. Three other things follow from that.

The user is the custodian. They hold the keys, so the app can't quietly fix a problem on their behalf. It can only help them see it early.

The numbers move. Prices, fees and rates change between the moment someone reads a figure and the moment they confirm it. A screen that shows a number as a fact is making a promise it can't keep.

The words are new. Gas, slippage, liquidation threshold and rebase are everyday words to people who've used DeFi for years and noise to everyone else.

If you want the general version of this, wallet connection, signing, approvals and fees, our Web3 UX design guide covers it. This piece goes deeper on the product screens themselves, and our crypto app design guide covers wallets and the home screen.

Start with the product type, not the style

Most ranking guides on this topic give a list of principles that apply to every DeFi product. They're sensible, and we'll use some. But a swap and a loan ask very different things of a screen, so we'd start by naming which of these you're building.

ProductThe question the user is askingThe number to design first
Swap (DEX)What will I get, and what does it cost?Amount received
Lending and borrowingHow safe is my loan?Distance from liquidation
StakingWhat do I hold, and what does it earn?Balance and reward rate
DashboardWhere do I stand, across everything?Net position

Most real products are two or three of these at once. The point is that each one has its own hardest screen, and you should find yours before you pick a colour.

Swaps and trading

A swap screen is the most copied screen in DeFi, which means there's good evidence about what works. ethereum.org's DEX design guide is the best short source we've found, and the rest of this section leans on it.

The three parts

It splits a swap screen into a main form, a button and a details panel. The form is where you pick the token and type an amount. Around each field there's room for four small pieces of information, one in each corner: the balance in the wallet, a Max button, the fiat equivalent and the price impact.

Two of those matter more than they look. The guide says plainly that if you're building any sort of Web3 project, a fiat equivalent is essential, because people still think in their local currency. And price impact, the gap between what you put in and what you'll get, is a useful thing to show next to the number it affects. Uniswap's documentation explains why it varies: the more liquidity there is at a price, the lower the price impact for a given swap size, and the less there is, the higher it gets. It also says its interface shows an approximate price impact in real time, and shows warnings when the impact will be unusually high.

What goes in the details panel

ethereum.org's list of extra details is token price, slippage, minimum received, expected output, price impact, gas estimate, other fees and order routing. Its advice is the part we'd steal: most of that is for pro users, so keep it minimal or tuck it into an accordion. Some of it repeats itself, since minimum received and slippage are two sides of one coin. And if slippage does appear in the panel, make it editable right there. The guide calls that an accelerator, a small trick that speeds up experienced people without changing the screen for everyone else.

Our view on top of that: pick one wording for each figure and use it everywhere. If the form says "You receive", the preview shouldn't say "Estimated output" and the confirmation shouldn't say "Minimum". A user who has to check whether three labels mean the same thing has stopped trusting the screen.

The button does the explaining

The guide has two rules we'd treat as non-negotiable. First, don't give approval its own button or its own click: the user wants to swap, so the button says Swap and the approval starts as the first step, with a stepper or a "transaction 1 of 2" message. Second, let the button double as the alert. If the swap isn't possible, the button itself says why, such as "Insufficient balance" or "Enter an amount", instead of an error message somewhere else on the screen. The guide notes that this is unusual outside Web3 but has become standard inside it.

That's also where one of Dino's screens earns its place here. Dino isn't a DeFi app. It's a group payments app we redesigned, and its deposit screen, as the picture shows, puts the amount in large type at the top, with quick-pick amounts, the bank account it comes from and the button beneath. The same order works on a swap form.

Do you need a preview step?

ethereum.org's answer is that a preview screen creates friction, which can be useful because it makes people slow down, as long as it doesn't just repeat the same figures. Our rule of thumb: if the main screen shows few details, add a preview. If the main screen already shows the price impact and the minimum, a preview that says it all again is a speed bump that tells them nothing new. For a large trade, or one with a high price impact, we'd always slow people down, and only then.

Lending and borrowing

A swap is over in a minute, but a loan stays open. Aave's own page says the health factor moves with the market (more on that below), so the borrower has to come back and check. In our view that makes the lending screens mostly about one question: how close am I to the edge?

One number for the edge

Aave's help page calls that number the health factor, and it's a good model for any lending product. It's calculated as total collateral value times the weighted average liquidation threshold, divided by total borrow value. A health factor below 1 signals the risk of liquidation. Its example: supply $10,000 of ETH with an 80% liquidation threshold, borrow $6,000, and the health factor is 1.333.

Aave also says two things worth designing around. The health factor moves with the market, because it falls when the collateral loses value and rises when it gains. And there's no universally safe health factor, because it depends on how volatile and correlated the assets are. That second point is a design problem. You can't print "safe" next to a number and be right for everyone.

Our view: a number alone isn't enough, because most people have no feel for whether 1.33 is fine or terrible. So give it three things.

  • A scale. Show where 1 is, where the user is and what the colour bands mean.
  • A what-if. Before the user borrows, show the health factor they'd end up with. Aave's page links to a third-party simulator for this, so the need is already recognised.
  • A fix. When the number is low, say what lowers the risk. Aave names two ways: supply more collateral or repay part of the loan. Put those two buttons next to the warning.

The borrow screen

The borrow form is where you can prevent the most damage cheaply. Show the amount, then immediately show the health factor before and after. If the new value is close to 1, say so in words, in the same place, not in a modal after the click. And never let the maximum button default to the maximum the protocol allows without telling the user what that does to their margin.

Here's what we'd put on it, top to bottom. This is our own layout view, not a standard.

  • Collateral. What the user is putting up, with its value in their currency.
  • Borrow amount. The field, with a clear maximum and what the maximum means.
  • Health factor, before and after. Two figures and the scale between them.
  • Cost. The rate and what it'll cost per month at that amount, labelled as current.
  • The button. It says Borrow when the numbers are safe. If the new health factor is close to 1, the button says what's wrong and the user has to take one more deliberate step.

The same screen in repay mode swaps the amount for what's owed and shows the health factor improving as the user types.

What a lender sees

Someone supplying money, not borrowing it, has a calmer question: what am I earning, and can I get my money out? Show the balance, the rate, what has been earned so far and a withdraw action. This is our view, and we'd keep the loan language for borrowers.

Staking and yield

A staking screen looks simple until you try to draw the balance.

The balance that changes by itself

Lido's help page describes stETH as a rebasing token: every day at noon UTC the amount of stETH in your address increases with the current rate. So the user's balance is a different number tomorrow, with no transaction on their part. If you don't design for that, someone opens the app, sees a number that doesn't match what they remember, and assumes something's wrong.

Our view: when a balance can change on its own, say so where the balance is. A small line such as "Grows daily" or "Updates at 12:00 UTC" costs one line of space and prevents a support ticket. And show the earnings as their own figure, separate from the deposit, so people can see what they put in and what the product has added.

Rates are claims, not facts

A reward rate is a snapshot of something that changes. Label it with what it is, where it comes from and when it was last updated, and don't show a single big percentage with nothing around it. We'd also avoid anything that reads like a promise. "Current rate" is honest. "Earn 5%" is a claim you may not be able to keep.

Locking and exiting

Whatever the product does about exits, the screen has to say how long it takes before the user commits. If withdrawing isn't instant, how long it takes belongs next to the Stake button, not in a FAQ. Our view: "where's my money?" is the question a staking product should expect, and a status screen that answers it is cheaper than a support queue.

The dashboard

A DeFi dashboard has the opposite problem to a swap form. There's too much to show. Positions across protocols, rewards, health factors and history all want the top of the screen.

We'd answer three questions in order. What's my total? Is anything at risk? What needs me today? Then let people go deeper.

The Finsaro dashboard is a finance product we designed as a template for a Webflow studio, so its numbers are stand-ins. In the picture, the net worth figure comes first, with an earnings chart and a transaction history on the same screen. The case study says the dashboard centres on the week ahead. The habit we'd carry over is putting the headline figure first and the detail after it. Finsaro's features page also lists tools a finance team expects, such as roles, approval rules and an audit trail. In our view that's a useful checklist for any DeFi dashboard that more than one person will use.

Two things we'd add that are DeFi-specific. Every position should show its risk figure on the same row as its value, so a user scanning down the list sees the health factor next to the balance, not three clicks away. And every number should be one click from where it came from. Reputable, the Web3 product we designed, is built on that idea: its case study says every figure there leads somewhere, to the commits, the protocols and the peers behind it. In our view the DeFi equivalent is a link from a balance to the transaction on a block explorer.

Dino's version of this was a lesson in labels, and the picture above shows one of its bill screens. Its case study says the old home screen opened on a stack of amounts with nothing saying what to do first, and separately that a coffee bought abroad showed in two currencies at once on the bill. So the redesign had one rule: every number says whose money it is. A DeFi dashboard needs the same rule with different words. Wallet balance, supplied, borrowed, staked and pending are five different numbers, and they must never share a label.

Approvals and signing, in one paragraph each

We'd rather not repeat the whole subject here, so these are the rules we'd hold to on any DeFi screen. The full version is in the Web3 UX design guide.

Approvals. ethereum.org's rule is to fold the approval into the main action. MetaMask's support page shows the other half: when an app asks for an approval, the screen is called a spending cap request and the user can click the pencil icon to edit the amount. It's honest about the trade-off too. It says virtually unlimited approvals aren't a problem in themselves and often save gas, but that an unlimited allowance can put you at risk if the app is later exploited. So the design choice isn't "always limited". It's "tell people what they're granting and let them change it".

Signing. The best screen before a signature says what will change in the user's own units. Rabby's support page describes a simulation that shows how many tokens will leave your wallet and how many you should receive, with the example that if a site says "Claim" but the simulation shows "Transfer", you can spot it before you sign. It also describes yellow and red exclamation marks that open specific details, and says that when a risk is detected the Sign button is disabled until the user clicks "Ignore All" and accepts the risk. That's a strong pattern: the warning blocks the action, and overriding it is a deliberate second step. If your own app can't simulate, it can still do the second half: say in words what this signature does.

Batching. EIP-7702 describes a way for ordinary accounts to batch actions and have someone else pay for a transaction. Its own example of batching is an approval followed by spending it, which it calls a common workflow in DEXes that takes two transactions today. We'd design the two-step version well now and keep the structure ready for one step later, since whether a given user's wallet supports it will vary.

The states most teams forget

The demo shows success. Real users hit everything else. This is the list we'd put in front of a developer at the start, as a table of screens that have to exist.

StateWhat the user needs to seeOften missing
Quote is staleThe old figure struck out, the new one shown, a clear refreshThe refresh
WaitingWhat step it's at and roughly how longAny step name
FailedWhat happened and what to do nextBoth
Wrong networkWhich one is needed and a switch buttonThe button
Not enough for feesWhat's missing, in the user's termsA plain sentence
Price movedThat nothing was spent, and the choice to retryThe reassurance
Sped up or replacedThat the first attempt is gone and this is the live oneAny mention
Waiting on a second chainWhich step, and a way to leave and come backA progress line

The last two rows come from bridges and from wallets that let people speed up a stuck transaction. We include them because a user who sees two attempts for one action will assume they've paid twice. Our view on the error text: "Execution reverted" tells a user nothing. Something like "The price moved more than your limit, so nothing was spent. Try again or raise the limit" tells them what happened and what to do. Every error should say whether the money moved.

This table is also the best thing to hand to engineering. Usarion's UI/UX page describes the handover as named layers, real components, documented tokens and a walkthrough, and a list of states is the part that stops raw error strings from reaching users.

Phone, tablet and desktop

Swaps and staking are often done on a phone, while lending positions and portfolios get checked on a larger screen. So design the phone for deciding and the desktop for monitoring. On a phone, the amount, the main figure and the one button must fit without scrolling. On desktop, the risk figures and the history can sit alongside.

We'd also design both a dark and a light theme from the start. Reputable shipped in both, and the case study says so. Dark is the common default in this space, but money screens are read for a long time and in many places, so the choice shouldn't be forced by the style.

Plain words, with the jargon one tap away

Aufait UX, in its DeFi UX guide, recommends borrowing patterns from traditional finance, since the currency exchange workflow is similar in banking and DeFi apps, and avoiding heavy financial jargon. We agree with the direction. A practical version has three parts.

  • Use the plain word as the label and the technical word as the explanation. "Price limit" with a tap for "slippage", or the other way round if your users are traders.
  • Explain a term where it appears, not on a separate learn page.
  • Test the words, not just the layout. People who know the jargon can't see it any more.

How to test a DeFi design before it's built

A prototype is the cheapest place to find out your screen doesn't work. Our UI/UX page says the point of prototyping is that you can test with five users before anything is coded. For DeFi we'd set the tasks like this, using testnet or a prototype with fake balances, never real money.

  • Swap a token and then say, before confirming, what you expect to receive.
  • Find out how close the loan is to liquidation, and say what you'd do.
  • Work out what happened after a failed transaction.
  • Find your earnings and your original deposit.

Anyone who can't answer out loud has told you which number to redesign. And include at least one person who has never used a self-custody wallet, since your team stopped seeing the jargon long ago.

Mistakes we'd avoid

925Studios makes a point in its DeFi UX guide that we'd repeat: a beautiful swap screen that hides the price impact is worse than a plain one that shows it. Here's our short list.

  1. The gradient comes before the confirmation screen. Most DeFi UX problems aren't visual.
  2. One label for several numbers. Balance, supplied, borrowed and staked need different names.
  3. A risk number with no scale. A health factor of 1.4 means nothing to most people.
  4. Exit time nobody can find. Put the withdrawal time beside the Stake button.
  5. Warnings seen as friction. Make them clear and rare, not smaller.
  6. States left to engineering. If nobody designs the failed state, the developer ships the raw error.

What we've done and what we haven't

The pictures in this article are from our Dino and Finsaro case studies. None is a DeFi screen, because we haven't designed one, and we'd rather show real work than draw fake DeFi screens.

Usarion designs web and mobile products and the sites around them. We haven't designed a DeFi protocol, a lending market or a staking product, and we don't want to imply it. What we have done is Reputable, a Web3 product in dark and light where every number leads to its evidence, Dino, a money app where every balance had to say whose it was, and Finsaro, a finance dashboard and website template. Those are the habits we'd bring: one number per screen first, evidence one click away, and every state designed. If you need a studio that has shipped a live lending market, ask any studio for that exact work, ours included. Our list of Web3 design agencies compares who else does this, and our pricing page shows how we work with product teams.

FAQ

It's the design of apps for decentralised finance: swaps, lending, staking and dashboards. The job is to explain the cost and risk of each action before the user commits, since transactions are usually final.

Use a form, a button and a details panel. Put the balance, a Max button, the fiat equivalent and the price impact around the fields, keep extra details minimal or in an accordion, and fold the approval into the Swap button.

The health factor with a scale, the health factor the user would have after the action, and a clear next step when it's low: add collateral or repay.

Show the deposit and the earnings as separate figures, label the rate as current and say when it updates. If the balance changes by itself, as with a rebasing token, say so beside it.

Plain words first and jargon on demand. Our test tasks above are the quickest way to find where a beginner gets stuck.

Many do. Design both and choose the default from your audience, not the style.

We can design the screens and prototype them. We haven't designed a live protocol, so ask any studio for the exact work you need.


If you're planning a DeFi product and want the hardest screen designed and tested before anything is built, book a call. Our UI/UX design services cover the flows, the states and the design system your developers build from.

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

Find him on-

Imran Khan, founder of Usarion

Book a call

Pick a time that suits you

Get in touch

Let’s build something amazing together

Project details

or write directly to hello@usarion.com

We use your details only to reply to you. Privacy policy

For product, interface and web-system work that needs clear direction and careful execution.

// CookiesWe use Google Analytics and Microsoft Clarity to see which pages help people. They only run if you say yes. Privacy policy