Here's a test I run with every DeFi product I build: can my parents use it?
Not my friends in crypto. Not the developer who joined our Discord. My actual parents — one a retired teacher, one an accountant — who are intelligent, financially literate adults who have never touched MetaMask.
The answer, for almost every product in the space, is no.
That's not a knock on any specific team. It's a systemic problem with how we've approached product design in Web3.
The language problem
Crypto has invented hundreds of new terms in the last decade, and we use them in product interfaces as though they're self-evident.
"Slippage tolerance." "Gas limit." "Nonce." "Health factor." "LTV ratio." "Impermanent loss."
Each of these terms carries real meaning that matters for how users interact with a protocol. But most products drop them in front of users without explanation, in contexts where a wrong input can cost real money.
Compare this to how traditional finance products handle complexity. Your brokerage app doesn't ask you to set a gas limit before placing a trade. It abstracts that complexity into "processing time" and handles the rest. You can go deeper if you want, but you're not forced to.
The interesting thing is that most of these concepts can be explained simply. "Slippage tolerance" is just "how much worse than the shown price are you willing to accept?" That's a familiar concept from stock market orders. The failure is that we haven't bothered to make that connection.
The error message problem
Web3 error messages are arguably worse than any other software category.
"Transaction failed: execution reverted" tells the user nothing actionable. "ERC20: insufficient allowance" requires knowing what allowances are. "Nonce too low" requires knowing what a nonce is.
I've watched users get these errors, not understand them, try the same transaction again, get the same error, and then leave the product entirely.
We built explicit error handling into Raga Finance early — before the first external users saw the product. Not generic "transaction failed" messages, but specific: "Your wallet doesn't have enough ETH to pay the transaction fee. You need about 0.005 ETH to proceed." With a link to buy ETH on the network they're on.
User dropout at the transaction confirmation step went down significantly when we did this. The fix wasn't technical — it was writing better strings.
The trust problem
On-chain protocols are trustless by design. But that doesn't mean users have to figure out why they should trust you.
When someone deposits funds into a vault, they're trusting:
- That the smart contract does what it says it does
- That the protocol hasn't been hacked
- That there's a way to get their money back if something goes wrong
- That the yield shown is real and not fabricated
Most DeFi products just... don't address these concerns. They assume users have read the documentation or will find the audit report in a GitHub repo.
The products that work well make these trust signals explicit: audit badges linked to reports, real-time TVL, withdrawal mechanics explained in plain language, and honest communication about risk.
We spent two weeks on Raga Finance just on the "how this works" page — not the technical docs, but the plain English explanation of what happens to your funds. It pays off in user confidence at the deposit step.
The risk communication problem
DeFi has real risks. Liquidation risk. Smart contract risk. Oracle manipulation risk. Impermanent loss. Counterparty risk on yield sources.
Most products communicate these in a legal disclaimer buried at the bottom of the page. Some don't communicate them at all.
This is a ticking time bomb. Users who deposit funds without understanding the risks become protocol enemies the moment something goes wrong — even if the outcome was within the stated parameters of the protocol.
Honest risk communication, presented clearly and early, builds the kind of users who understand what they're doing. They ask better questions, they set more appropriate position sizes, and they don't blame the protocol for outcomes they would have understood if they'd been told.
For delta-neutral strategies on Hyperliquid, we added a "What can go wrong?" section that described, in plain language, the scenarios under which users would experience losses. Deposits went up after we added it. Turns out people prefer knowing the risks to discovering them.
What good looks like
The best UX in DeFi today, in my view, does the following:
Progressive complexity. Show the simple view first. Let users go deeper when they want to, rather than front-loading everything.
Context-sensitive help. Explain terms inline, at the moment users encounter them, not in a separate documentation page they'll never read.
Honest defaults. Set sensible defaults that protect users. If slippage tolerance should be 0.5%, make that the default and explain why.
Error messages that help. Every error should tell the user what happened, why, and what to do next.
Risk education at decision points. Before a significant deposit or position change, show the relevant risks. Make it brief, make it clear, make it easy to dismiss for experienced users.
Off-ramp clarity. Users need to know how to get their money out, under what conditions, and how long it takes. This should be in the UI, not just the docs.
None of this is rocket science. It's just product design that takes users seriously. The protocols that nail this in the next cycle will capture the users who've been sitting on the sidelines because crypto felt too scary.
The door is wide open. We just have to build for people, not for ourselves.
— Rohit