Project2025

A raw blockchain explorer turned into a decision layer with 40k monthly visitors and a paid developer API: dense, high-stakes data made scannable, comparable, and safe to act on.

RoleProduct designer → lead designer

TeamFounder · 3–5 engineers · 2 designers

Timeline≈2 years · iterative engagements

ScopeScreener · wallets & proxies · swap / stake / LP · developer API & docs

Traction40k monthly visitors (Jul 2026) · paid developer API

Over two years working directly with the founder, a raw protocol explorer became a coherent decision layer: research, trading, wallets, staking, delegated permissions, and a developer API sharing one visual grammar, learned once and trusted everywhere. The product reached 40k monthly visitors (team analytics, July 2026) and the API became a paid subscription. Every irreversible action sits behind one hard trust boundary, so reading the chain and moving real money never blur.

The challenge was never to display more data. Users were already drowning in it. 100+ sub-networks, each with its own token; two unit systems sharing the same rows; prices and block numbers ticking live; terminology that punishes newcomers. What users actually needed were answers: what's worth a look, what changed, what's risky, what to do next. And because the same screens that read the chain also move real money on an irreversible network, clarity couldn't come at the cost of depth.

A typical trading product serves one user: the trader. This one had to serve five: traders, researchers, infrastructure operators, developers evaluating the API, and newcomers needing a trustworthy entry point. I led design through iterative cycles with the founder and a 3–5 person engineering team. The main table became the core decision surface (a screener, not a list), new lenses re-cut the same data instead of spawning new pages, every surface opens simple and discloses depth on demand, and analysis sits next to action so evaluating never loses context.

From a data listing to the core decision surface: a global vitals strip anchors the market, filters, columns and bookmarks re-cut the same set, and price, supply and 7-day movement read inline per row.

Before

After

From a flat stats card to a validator workspace: APY charted across every subnet, the root/alpha stake split made explicit, and per-subnet stake expandable down to individual hotkeys.

Before

After

Price, market cap, volume, supply, staking yield and the live block number ride the top of every market view: one clock for every reading, trust anchored up front.

One amount input, HALF/MAX presets, one primary action, with advanced order types layered a click away. The simple case stays simple, and the fee math is never left to the user.

Every actionable path sits behind a single connect-wallet moment, so authorizing spending is always consistent and obvious. Reading and transacting share a screen but never blur.

Validator metrics sit side by side so users can run their own too-good-to-be-true checks, and the docs back every calculated metric with a formula.

Where analysis becomes action: the money-moving flows, the account machinery, and the developer layer, with the decisions behind each.

The wallet is a slide-over, not a separate app: it opens over whatever you're reading. One net-worth figure leads; under it, three verbs (Swap, Send, Stake) and a single ledger folding liquid, staked, and per-network holdings into one readable list.

One headline number in dollars, the on-chain value one glance below.

Holdings collapse into three honest buckets instead of a flat coin list.

Staked rows carry live yield inline, so “where is my return coming from” is answered at a glance.

On this chain one account can sign on behalf of another with scoped powers (a Substrate proxy). Powerful, and easy to get catastrophically wrong. The creation flow names every role in plain language and discloses costs before the button, so delegating authority never feels like a leap of faith.

Each actor labelled by what it does (“signs transactions on behalf of”), not by chain jargon.

Authority scoped by a permission picker: grant staking rights without handing over the account.

Deposits and balance rules stated before the action, not after it fails.

Swapping uses the same grammar as Send and Stake: a Sell field with HALF/MAX presets and a live balance, a Buy field, and a single direction-flip between them. The primary button starts as “Enter the amount” and only becomes actionable once there is something to act on.

HALF/MAX presets, so the fee math is never left to the user.

One ⇅ control flips direction in place; no second screen.

Confirmation returns a plain receipt with a one-tap link to the on-chain transaction.

Supplying liquidity Uniswap-v3 style is one of the most error-prone flows in DeFi. Here the sidebar walks one vertical path (set the range on the chart, deposit, provide, watch the position) with value, fees and yield always on screen and an alert the moment your capital stops earning.

Ranges are drawn directly on the price chart with draggable handles.

One vertical path replaces scattered controls: Set Range → Deposit → Provide → Positions.

“Notify when not In Range” turns the biggest failure mode into an alert.

More than an API: a developer portal with plans and pricing, a full API reference, and chain documentation. I rebranded all three into one TMC lockup system, so the paid layer reads as one product rather than three detached sites. This layer is the foundation of the paid subscription.

TMC DEV sells the “why” with Free, Pro and Business plans before anyone integrates.

TMC API keeps endpoints, examples and response shapes together.

TMC Subtensor Docs translates chain concepts into usable integration context.