Trust was the product

Meso was a crypto payments company. The pitch to developers was simple - drop in our SDK and your users can buy crypto without leaving your app. The pitch to users was even simpler - buy crypto fast, cheap, and without the usual sketchy vibes.

I was the founding designer and first employee. My job was to figure out what "good" looked like in a space where the bar was essentially on the floor. Most crypto onramps in 2022 felt like filling out a tax form inside a slot machine. We wanted to build something people actually trusted.

The hard part wasn't the UI. The hard part was that trust was broken at every layer - users didn't trust crypto products, developers didn't trust the infrastructure, and honestly, the industry had given people plenty of reasons not to trust any of it. Every design decision we made came back to the same question: does this build trust or break it?

We had no product, no users, and we were building in an industry where people are pseudonymous by choice. Doing user research here meant figuring out how to find and talk to people who specifically don't want to be found. So instead of writing code, we spent our limited startup money on UXR contractors and Figma prototypes. That felt like a weird bet for a company that didn't have a product yet.

It turned out to be one of the best decisions we made. The contractors handled recruitment and ran moderated sessions, and what came back was clear. People didn't need more features. They needed to feel safe. The results pointed to four things that drove trust:

Those four pillars became the foundation for everything - not just the visual design, but product strategy, messaging, prioritization. When we argued about what to build next, we'd come back to the trust framework. It was the closest thing we had to a compass.

We needed to test our own integration in production conditions. You can't really evaluate a developer SDK by looking at it in Figma. But building an internal testing tool felt like a distraction when we had about a thousand other things to ship.

So we built Meso Cash - a real consumer-facing app where anyone could buy crypto. The logic was straightforward: if we couldn't convince real people to buy crypto through our own frontend, we had no business asking partners to embed us in theirs. It wasn't a test harness. It was a real product with real users spending real money.

Meso Cash ended up becoming our second-biggest integration partner by volume (which was not the plan, but we weren't complaining). More importantly, it surfaced friction in the SDK that internal testing never would've caught - edge cases in the KYC flow, confusing error states, moments where trust broke down that you only find when someone's actually trying to spend $200 on ETH.

The whole point of Meso was that developers could add crypto purchases inside their own apps. But in 2022, every existing solution worked the same way - redirect the user to some third-party site, hope they complete the purchase, redirect them back. It worked, technically. But trust breaks at the exact moment someone's deciding whether to spend money, and bouncing them to an unfamiliar site is a great way to break it.

We built something different. Meso's integration appeared as a native-feeling overlay inside the partner's app. You'd tap "buy crypto" in your wallet and our UI would slide up - styled to match the partner's theming, light or dark mode, the whole thing. From the user's perspective, they never left.

The tricky part was KYC. We were collecting social security numbers, home addresses, bank details - inside someone else's app. The trust implications there are enormous. If the integration felt even slightly off, or looked like a phishing attempt, people would (rightly) bail. We obsessed over the details because at that moment, the details were the product.

This ended up being the growth engine. By the end of 2024 we'd cleared $23M in volume across 145K transfers and 12 partner integrations - in an industry where most onramps lose people at the password screen, that's a number that says the framework worked.

The thing I keep coming back to is that trust wasn't a feature we shipped. It was the product itself. Every screen, every interaction, every API response was either building trust or eroding it, and we didn't always get it right. But having that as the lens made every decision clearer.

New technology always has a trust problem. The interface is unfamiliar, the value prop is abstract, and people have been burned before. The design work - the real work - is figuring out what trust looks like before anyone's built a playbook for it.