How do you make signing a transaction feel as safe as it actually is?

01 — Problem

Norion is ICEO's asset tokenization platform, built so companies can run entire token ecosystems in one place: issuance, NFT management, secondary market trading, smart contract interaction and a web crypto wallet. For the first seven months I was the only frontend engineer on it. Every screen a user touched before authorising a real, irreversible financial transaction was a screen I had designed, built and was answerable for, with no second frontend developer to catch my blind spots in review. The backend team existed, but the boundary was porous: when the work demanded it I wrote backend code too, and I wrote smart contracts myself. Meanwhile the trading layer was pushing over 1000 market events per second, and the early polling based price feed visibly lagged behind the market it claimed to show, which in a trading product is a trust problem, not a performance metric.

02 — Constraints

• One frontend engineer for the first seven months — full ownership of everything a user could see or sign
• Every cryptographic operation had to read as a plain, irreversible decision — not blockchain jargon
• Real-time trading data via gRPC streams: 1000+ events/sec with a <100ms latency requirement

03 — Architecture

A gRPC streaming client with typed Protocol Buffer bindings handles all real-time market data — token prices, order books, portfolio values. REST endpoints serve CRUD operations for portfolio management; a GraphQL (Apollo) layer aggregates multi-source data for the trading dashboard. The token issuance and transaction flows use progressive disclosure: Wallet → Token / NFT → Transaction → Smart Contract → Confirmation. At every step the user sees exactly what they are authorising in plain language, with gas shown in both ETH and fiat before signing. WebSockets carry the secondary market live feed in parallel; both channels share a connection manager so reconnects are invisible.

04 — Solution

I built the entire Norion frontend from scratch. I replaced the polling feeds with gRPC streams over typed Protocol Buffer bindings, which took the visible lag out of prices and order books and got end to end latency under 100ms. The part I am proudest of is the signing flow. I designed it as five steps of progressive disclosure, from wallet connection to confirmation, where every step states in plain language what is about to happen and what it costs, with gas shown in both ETH and fiat. Nothing can be confirmed by muscle memory. I worked directly with ICEO's backend engineers on stream contracts and with the business side on how token issuance should read to a company treasurer rather than a crypto native. Then I dockerised the dev environment and wired the AWS deployments, because when you are the whole frontend team, shipping reliably is also your job. Along the way I crossed the boundary whenever the product needed it: backend endpoints, smart contract code, whatever stood between the feature and production.

• Sole frontend engineer for the first seven months, then the frontend lead as the product grew
• Real-time data architecture via gRPC and WebSockets
• UX design for wallet, token issuance, NFT and trading flows
• Contributions to the backend and to the smart contracts themselves

05 — Outcome