Building faster than design cycles: 1-tap trade

This started as a simple question. What would trading look like if it took 1 tap instead of 4?

Within days, I built a working prototype. I went from idea to test in under a week and time to first user signal dropped from weeks to days.

Instead of handing off a long spec, I shared a working build. My designer and I iterated quickly, rebuilding the prototype against refined designs.

The result: a production-ready 1-tap trading prototype currently in internal testing. Tap a preset ($5, $25, $50, 100% sell) to execute a buy or sell instantly.

Early demos showed a clear preference for the 1-tap flow, especially among high-frequency traders, validating demand for faster trade execution. It also exposed the need to reduce visual clutter and simplify the UI.

Executing a trade today requires navigating multiple screens. The system relied on friction for safety, instead of designing for correctness.

Most users dropped off at the preview screen. Not due to low intent, but friction in the flow. In fast-moving markets (memecoins, leverage), latency directly impacts trade outcomes. Speed is the product.

Over time, the flow accumulated complexity as upsells and new products layered onto an outdated system.

The challenge wasn't just removing friction. It was designing a system that executes instantly while remaining correct, predictable, and recoverable under failure.

In a 1-tap flow, there's no buffer. Every interaction becomes a high-stakes system decision.

Tap → loading → success toast communicates execution without reintroducing friction. Users see progress without needing a confirmation screen.

Instant trading is opt-in only. This removes the need for repeated confirmations while letting users choose the risk level they're comfortable with.

The sell chip is dynamic. It only appears when a user has a balance. Disabled states create noise, so during and post-trade updates had to be airtight for the flow to feel seamless.

Removing the preview screen makes execution deterministic. The system must either execute correctly or fail transparently, introducing new failure modes: stale balances, failed execution, or unintended trades.

The question is whether removing friction changes user behavior.

Faster execution should tighten the loop. The goal wasn't just speed—it was increasing user confidence per interaction.

Key signals:

If trade frequency and volume compound per user, it indicates the system is increasing user confidence—not just speed.

Speed also introduces risk. Guardrails I'd monitor include:

These indicate whether the system is behaving correctly under real market conditions.

Prototyping compressed decision cycles from weeks to days and surfaced system behavior before we committed to building it.

My initial concept went from prototype to stakeholder alignment to a greenlit direction in under a week. This happened before any engineering investment.

It surfaced edge cases early and turned weeks of design iteration into days. Work that would have sat in the backlog moved forward.

This changed how I build:

The fastest path to AI adoption is reducing time to value.

At Coinbase, AI only became useful once it was integrated into my workflows and could access and act on real context across tools like Figma, Slack, and internal systems. Without that, even strong models delivered little value.

AI collapses multi-step workflows into intent-driven actions, but shifts complexity into system behavior. The challenge is no longer navigation. It is ensuring outputs are correct, predictable, and trustworthy across dynamic states.

This introduces new tradeoffs between speed, control, and reliability. Optimizing for one often degrades the others.

The product challenge shifts from designing flows to designing system behavior under uncertainty. 1-tap trading applies this directly. Collapsing a multi-step flow into a single action shifts the problem from guiding users through steps to ensuring the system executes correctly, predictably, and safely.

Prototyping becomes critical in this context. In AI systems, correctness is not fully designed upfront. It is discovered and refined through interaction.