Flair BuchiMiracle Okonkwo

WritingAugust 2025

Making Crypto Feel Like Money Instead of Crypto

People don't necessarily want to use crypto. They want to use money. The product problem is deciding where the chain still matters.


One of the things that has become clearer to me while building Xpend is that people don't necessarily want to use crypto. They want to use money.

That sounds like an obvious distinction, but a lot of crypto products are still designed around the infrastructure rather than the job the user is trying to accomplish. Wallet addresses, networks, tokens, confirmations and transaction hashes are all important when you're building the system. They aren't necessarily important when someone is trying to send ₦20,000 to a friend.

This creates an interesting product problem. If crypto is going to sit underneath an everyday financial product, how much of the underlying system should the user actually have to understand?

At Xpend, we haven't solved that completely. We have, however, learned that the answer isn't to pretend the blockchain doesn't exist. It's to decide where it matters.

The wallet underneath the money

One of the stranger things about Xpend, from an engineering perspective, is that the spendable balance underneath the product is a USDT ledger.

The user doesn't interact with a screen that says “your USDT ledger balance” every time they open the app. The home experience can present the balance in dollars and show a naira equivalent. When a user sends money to a bank, the experience is built around the naira amount and the recipient's bank details.

Underneath that interaction, the ledger still moves in USDT.

That means the ₦ balance isn't a second pool of naira sitting somewhere beside the crypto balance. It's a representation of the spendable balance at the current rate.

The interface and the accounting model are solving different problems. The interface needs to speak in the currency that makes sense for the action. The ledger needs a consistent unit in which value can actually be tracked.

We ended up keeping those concerns separate.

“Add Money” shouldn't require a blockchain lesson

The clearest example is the difference between adding naira and depositing crypto.

If someone chooses the Naira option in Add Money, they can go through a familiar checkout or bank-account funding flow. There is no network selector and no wallet address they need to copy.

The system handles the conversion and eventually credits the underlying ledger.

If they choose the Crypto option, the experience changes completely. They choose an asset and network, receive a deposit address and QR code, and get a warning that they need to send the right asset on the right network.

That's not an accident or an inconsistency in the product. Those are two different jobs.

Someone adding ₦100,000 through a local payment rail shouldn't need to know whether the underlying accounting eventually represents that value as USDT. Someone sending USDT from an external wallet does need to know which network they're using, because getting that wrong has real consequences.

The abstraction should stop where hiding information would make the operation less safe.

The chain is still there

This is where I think crypto products can get abstraction wrong.

It is tempting to make the blockchain disappear completely from the interface and declare the problem solved. But if the user is actually sending crypto from an external wallet, the network is part of the transaction.

You can't remove it just because it makes the interface cleaner.

Our crypto deposit flow exposes the token, network, address and QR code. Invoice payments that use crypto do the same thing. The chat agent also has to ask which network a user wants for a crypto deposit rather than guessing.

Those details are unavoidable because they describe the actual rail being used.

What we can hide is everything that happens after that decision. The user doesn't need to understand deposit watchers, confirmation handling or how the resulting funds eventually become part of the spendable balance.

That is where abstraction becomes useful: not by deleting the underlying system, but by containing it.

The same balance can support ordinary money actions

Once the value is represented in the ledger, the user can do things that don't feel particularly crypto-native.

A bank transfer is expressed in naira. A user provides bank details and an amount. The system handles the relationship between that amount, the exchange rate and the underlying ledger.

Gifts work similarly. XPacket is effectively a community-linked red packet. A user creates a gift, chooses an amount and distribution, shares a claim link or code, and another person claims it into their wallet. Neither person needs to provide a blockchain address or choose a network to make that happen.

Underneath, the wallet ledger is still doing the accounting in USDT.

Crypto hasn't disappeared. A blockchain-based financial system can still support interactions that don't require blockchain concepts to be part of the interaction.

This is also where the abstraction breaks

There are still plenty of places where crypto leaks through.

The home screen can show dollars because the underlying balance is USDT. Some confirmations explicitly mention USDT. Some errors expose the underlying amount. Sending or gifting in USDT obviously introduces the asset directly.

And the moment someone chooses a crypto deposit, they are back in the world of networks and addresses.

I think those limitations are useful rather than embarrassing. They show that abstraction isn't the same thing as hiding everything.

A good financial interface should hide complexity that isn't useful for the decision the user is making. It should expose complexity when the user needs that information to make the transaction correctly.

The difficult part is knowing which is which.

XPUSD made this especially interesting

We also have a product concept called XPUSD that makes the distinction even more important.

Despite the name, XPUSD isn't a separate on-chain token that users hold alongside USDT. In the local-money deposit flow, it represents the XP Local Wallet / local currency balance experience. A user can fund it through a naira payment rail, while the resulting value is credited to the underlying USDT ledger.

That means the product name and the settlement representation are doing different jobs.

This is exactly the sort of thing that can become confusing if the product is designed from the infrastructure outward. Engineers naturally think about the asset, network and settlement mechanism first. Users generally think about what they are trying to do.

Those perspectives have to meet somewhere in the product.

Making the abstraction work is an engineering problem

It would be easy to look at this as a UI exercise.

Change “deposit crypto” to “add money,” hide the wallet address, show a nice balance, and call it abstraction.

The hard part is everything underneath that screen.

If the user sees a naira balance but the spendable ledger is USDT, every debit and credit has to account for the conversion correctly. If a crypto deposit is made, the system needs to track the address, watch the transaction, wait for the appropriate confirmation and credit the ledger.

If a user sends money to a bank, the product has to turn a familiar naira action into the correct ledger movement and payment-rail operation.

If someone creates an XPacket in naira, the display amount and the underlying ledger movement still have to remain consistent.

The UI can make all of this look simple. The implementation cannot.

The goal isn't to hide crypto everywhere

The more we've built, the less I think the right goal is “make users forget they're using crypto.”

There are situations where knowing you're using crypto is useful. If I'm depositing USDT from another wallet, I need to know the network. If I'm paying a crypto invoice, I need enough information to make sure the transaction goes to the right place.

What I don't need is for every ordinary money action to inherit all of those concepts.

That distinction is what I find interesting about building financial products on crypto rails.

The underlying infrastructure can be complicated while the action built on top of it is familiar.

A bank transfer doesn't need to become a blockchain transaction in the user's head just because a blockchain-based ledger sits underneath it. A gift doesn't need a wallet address to feel like a gift.

The product can carry some of that complexity for the user.

The boundary is the product

I think this is ultimately less about making crypto invisible and more about choosing the right boundary.

At one end, there are operations where the chain is the operation: depositing USDT, selecting a network, providing an address. Hiding those details would remove information the user actually needs.

At the other end, there are operations where the user is thinking about a person, a bank account, a gift, a bill or an amount of naira. Making that person reason about networks and tokens would add infrastructure complexity without helping them accomplish the task.

The product sits between those two worlds.

That's the part I find most interesting about Xpend. We're not trying to pretend the underlying financial infrastructure isn't there. We're trying to make it possible for someone to use the things built on top of it without having to become an expert in the machinery underneath.

Crypto is still there.

The goal is to make sure the user only has to think about it when it actually matters.