# Ivan Kalkaev > Ivan Kalkaev is a lead product designer and design engineer. Product design partner for Web3, fintech, and SaaS teams. Apple Design Award winner, art director, product designer, and design engineer with 15+ years of experience. I lead design direction, build scalable systems, and ship interfaces across fintech, crypto, web3, and SaaS products. ## Contacts - Email: [ivanhorvud@gmail.com](mailto:ivanhorvud@gmail.com) - X: [@kalkaev](https://x.com/kalkaev) - LinkedIn: [@ivankalkaev](https://linkedin.com/in/ivankalkaev) - Telegram: [@ivankalkaev](https://t.me/ivankalkaev) - Dribbble: [@horwood](https://dribbble.com/horwood) - CV (PDF): [Ivan-Kalkaev-Lead-Product-Designer-CV-2026-11b.pdf](https://kalkaev.com/assets/Ivan-Kalkaev-Lead-Product-Designer-CV-2026-11b.pdf) ## Pages - [Home](https://kalkaev.com/index.md): Product design partner for Web3, fintech, and SaaS teams. - [About](https://kalkaev.com/about.md): 15 years in design, including 9 in product design and 6 in team leadership. - [Writings](https://kalkaev.com/writings.md): Notes on product design, interface systems, AI, and Web3. ## Works - [ProMobile](https://kalkaev.com/works/promobile.md): A soft operating layer for app promotion. - [PokerDAO](https://kalkaev.com/works/pokerdao.md): Poker first, crypto second. - [CYBRO](https://kalkaev.com/works/cybro.md): The brand had to molt. - [BlastUP](https://kalkaev.com/works/blastup.md): The funnel is the product. - [ApeBro](https://kalkaev.com/works/apebro.md): DeFi with a face. - [Arkada App](https://kalkaev.com/works/arkada-app.md): A quest platform with a second loop. - [Open Wallet](https://kalkaev.com/works/open-wallet.md): The retainer became the team. - [Roketo App](https://kalkaev.com/works/roketo-app.md): AI was the production pipeline. - [PayVDA App](https://kalkaev.com/works/payvda.md): Crypto without the chaos. - [Vibe Skills](https://kalkaev.com/works/vibe-skills.md): A landing page in one take. - [EZ Wallet](https://kalkaev.com/works/ez-wallet.md): A wallet grew into a payment system ## Writings - [AI-agents are the new type of users](https://kalkaev.com/writings/ai-agents-are-the-new-type-of-users.md): AI agents now read pages, click controls and fill forms on people's behalf. What product design has to add beyond the pixels so both humans and agents can use it. - [The button was too easy](https://kalkaev.com/writings/the-button-was-too-easy.md): A crypto trading product had healthy engagement, but users stopped when serious money entered the flow. - [Fast image feeds are a scheduling problem](https://kalkaev.com/writings/fast-image-feeds.md): Image-heavy feeds feel fast when the browser does the right work in the right order. A practical guide to image sizing, loading, caching, and scroll UX. - [Designing a crypto onboarding flow](https://kalkaev.com/writings/blastup-crypto-onboarding-dropoff-40.md): Behind the UX architecture of BlastUP's IDO flow: onboarding, wallet connection, staking, and the structural decisions that reduced drop-off by 40%. - [About cognitive load](https://kalkaev.com/writings/about-cognitive-load.md): Bright interfaces aren't necessarily confusing. The real cognitive load starts when people have to guess what happens next. ## Optional - [Full site as one file](https://kalkaev.com/llms-full.txt): every page above, concatenated as Markdown - [Text view for humans](https://kalkaev.com/agents/): the same content as a monospace text page - [Privacy](https://kalkaev.com/privacy.md): How this portfolio handles visitor information, messages and conversations with Blue. Every HTML page has a Markdown twin: append `.md` to its path (`/` is `/index.md`), or request the page with `Accept: text/markdown`. --- title: "Ivan Kalkaev | Product Design Partner" description: "Product design partner for Web3, fintech, and SaaS teams." url: https://kalkaev.com/ --- # I’m Ivan Kalkaev I design digital products Apple Design Award winner, art director, product designer, and design engineer with 15+ years of experience. I lead design direction, build scalable systems, and ship interfaces across fintech, crypto, web3, and SaaS products. - [Get in touch](mailto:ivanhorvud@gmail.com) - [Works](https://kalkaev.com/#works) Worked with companies like: - Resend - Münzen - Lovable - CYBRO - BlockPot - Railway - Cardano - Arkada - BlastUP - Neon - Suzuki - Yandex - OpenWallet - Wargaming - HubSpot - [ProMobile](https://kalkaev.com/works/promobile) — 2024. A soft operating layer for app promotion. - [PokerDAO](https://kalkaev.com/works/pokerdao) — 2023. Poker first, crypto second. - [CYBRO](https://kalkaev.com/works/cybro) — 2024–2026. The brand had to molt. - [BlastUP](https://kalkaev.com/works/blastup) — 2024. The funnel is the product. - [ApeBro](https://kalkaev.com/works/apebro) — 2025. DeFi with a face. - [Arkada App](https://kalkaev.com/works/arkada-app) — 2025. A quest platform with a second loop. - [Open Wallet](https://kalkaev.com/works/open-wallet) — 2025–2026. The retainer became the team. - [Roketo App](https://kalkaev.com/works/roketo-app) — 2024. AI was the production pipeline. - [PayVDA App](https://kalkaev.com/works/payvda) — 2026. Crypto without the chaos. - [Vibe Skills](https://kalkaev.com/works/vibe-skills) — 2025. A landing page in one take. - [EZ Wallet](https://kalkaev.com/works/ez-wallet) — 2026. A wallet grew into a payment system ## Testimonials > Ivan consistently delivers on both quality and deadlines. He goes beyond the brief, finds the real problem, and brings solid solutions. > — Crouton, Founder of Cybro.pro > Ivan, this is just fucking awesome. > — Alex S., CMO of BlastUP > Ivan goes deeper into the product, challenges the brief when needed, and brings back thinking we didn’t know we needed. > — Mitul Manish, Co-founder, Open Wallet > Ivan does more than design. He creates products with real character, visual language, and a clarity that makes people fall in love with what they use. > — Alexander Isaev, Founder at CSgomoney > Ivan built us an incredible collection and a whole platform. A strong result with zero micromanagement. I’ll definitely come back to him for my next project. > — Denis A., Founder of Arkada --- More: [llms.txt](https://kalkaev.com/llms.txt) · [HTML page](https://kalkaev.com/) · [Text view](https://kalkaev.com/agents/) --- title: "About | Ivan Kalkaev" description: "15 years in design, including 9 in product design and 6 in team leadership." url: https://kalkaev.com/about --- ![Portrait of the designer](https://kalkaev.com/assets/1oq8UIt4C8bJUFMjmQ4EygAeGW0.png) # About I design digital products and lead visual direction with a focus on quality, clarity, and systems thinking. My work sits at the intersection of art direction, product design, and implementation, where aesthetics, structure, and behaviour are treated as one continuous system. Over the years, I’ve developed my own AI-augmented design pipelines that extend my practice rather than define it. They allow me to explore more deeply, iterate with higher fidelity, and maintain a strong level of craft across every stage of the process. ivanhorvud@gmail.com · My toolkit · Experience · 2024 — Now · Design Engineering AI-native product design and engineering for complex interfaces, systems, prototypes, and production UI. At Unipaws and Kalkaev®, work with Web3 and crypto infrastructure teams on investing and trading interfaces, dashboards, DEX and CEX using React/Next.js, Swift, Codex, LLM APIs and AI chat UIs. Apple Design Award 2024 · Contra Top 1% Creative 2025 · 2020 — 2024 · Product Design End-to-end product design for fintech, crypto, iGaming, Web3, and SaaS. At Lunapark, Pixpowder, and Unipaws, designed trading dashboards, onboarding, account systems, internal tools, component libraries, design systems, and complex flows from discovery to release. 2016 — 2020 · Design Leadership Creative direction and multidisciplinary team leadership at Lunapark. Led web, product, identity, and campaign work for Yandex, VK, Wargaming, Severgazbank, EKSMO, and others, owning concepts, reviews, client communication, and design quality. 2011 — 2016 · Graphic Design & Web Graphic design, identities, campaigns, and web with focus on typography, grids, composition, and art direction. Created websites and digital experiences for Suzuki, VK, Haval, Efes, and Sony, progressing from designer to art director. Readings · Writings - [AI-agents are the new type of users](https://kalkaev.com/writings/ai-agents-are-the-new-type-of-users) — AI agents now read pages, click controls and fill forms on people's behalf. What product design has to add beyond the pixels so both humans and agents can use it. - [The button was too easy](https://kalkaev.com/writings/the-button-was-too-easy) — A crypto trading product had healthy engagement, but users stopped when serious money entered the flow. - [Fast image feeds are a scheduling problem](https://kalkaev.com/writings/fast-image-feeds) — Image-heavy feeds feel fast when the browser does the right work in the right order. A practical guide to image sizing, loading, caching, and scroll UX. - [Designing a crypto onboarding flow](https://kalkaev.com/writings/blastup-crypto-onboarding-dropoff-40) — Behind the UX architecture of BlastUP's IDO flow: onboarding, wallet connection, staking, and the structural decisions that reduced drop-off by 40%. - [About cognitive load](https://kalkaev.com/writings/about-cognitive-load) — Bright interfaces aren't necessarily confusing. The real cognitive load starts when people have to guess what happens next. --- More: [llms.txt](https://kalkaev.com/llms.txt) · [HTML page](https://kalkaev.com/about) · [Text view](https://kalkaev.com/agents/about/) --- title: "Writings | Ivan Kalkaev" description: "Notes on product design, interface systems, AI, and Web3." url: https://kalkaev.com/writings --- # Writings - [AI-agents are the new type of users](https://kalkaev.com/writings/ai-agents-are-the-new-type-of-users) — Agents use your product too. AI agents now read pages, click controls and fill forms on people's behalf. What product design has to add beyond the pixels so both humans and agents can use it. - [The button was too easy](https://kalkaev.com/writings/the-button-was-too-easy) — Clear screen, still no deposit. A crypto trading product had healthy engagement, but users stopped when serious money entered the flow. - [Image feeds are a scheduling problem](https://kalkaev.com/writings/fast-image-feeds) — Speed is about loading order. Image-heavy feeds feel fast when the browser does the right work in the right order. A practical guide to image sizing, loading, caching, and scroll UX. - [Designing a crypto onboarding flow](https://kalkaev.com/writings/blastup-crypto-onboarding-dropoff-40) — How we cut IDO drop-off by 40%. Behind the UX architecture of BlastUP's IDO flow: onboarding, wallet connection, staking, and the structural decisions that reduced drop-off by 40%. - [About cognitive load](https://kalkaev.com/writings/about-cognitive-load) — Busy isn't the same as confusing. Bright interfaces aren't necessarily confusing. The real cognitive load starts when people have to guess what happens next. --- More: [llms.txt](https://kalkaev.com/llms.txt) · [HTML page](https://kalkaev.com/writings) · [Text view](https://kalkaev.com/agents/writings/) --- title: "ProMobile | Ivan Kalkaev" description: "A soft operating layer for app promotion." url: https://kalkaev.com/works/promobile --- ProMobile # A soft operating layer for app promotion. ![ProMobile — hero visual](https://kalkaev.com/assets/7JX8WWSJvucLrfHRv7hzvBYFw4-w768.avif) Service · Web Design · Graphic Design · Tools used · Figma · Framer · Year · 2024 Product scope ## A promotion platform hiding in a brief ProMobile was a large product pretending to be a simple brief: a web platform for mobile app promotion where users could add apps, fund balance, create advertising orders, track rankings, buy reviews or search terms, follow campaign progress, manage payments, export data, work with profile settings, and move through the operational mess of a serious B2B tool. The real project became a larger design system problem. The product had to support Balance, Order Payments, Export, Add Funds, Profile Settings, Add First App, My Apps, App Overview, Ranking Optimization, Ratings, Reviews, User Profile, Settings, Help, empty states, 404, dark mode, landing materials, and connective tissue between all those areas. The central principle was designing from the corners inward. Balance gave the system trust. The sidebar gave it control. The 404 page gave it personality. Those surfaces were not the whole product, but they created a design language that could expand into the full ProMobile map without becoming disconnected screens. Three real ProMobile screens: Overview, Balance and My orders. Switch between them and the sidebar and header stay put while only the content changes. Money first ## Balance set the trust standard ### A simple brief became a platform system ProMobile had the scale of a real operating platform, with dozens of flows, different data densities, different user states, different levels of product maturity, and a frontend team building while design was still moving. Every visual decision had to survive repetition. A soft card style could not only work on one balance screen; it had to work across order timelines, app cards, rankings, ratings, reviews, settings, payment tables, help screens, and dark mode. Even a 404 page had to belong to the same universe as payment history and ranking optimization. ### Balance became the first trust test Balance was the first major area because money was the most sensitive part of the platform. The product had card payments through Stripe, crypto payments through NOWPayments, invoice requests, payment history, order payments, payment IDs, exports, app names, bonuses, bank transfers, and legal text. The interface had to make financial actions feel calm, explicit, and reliable without becoming a boring finance admin panel. The “Request sent” state had to work almost like a receipt, with amount, email, bank name, account holder, account number, and routing number placed clearly enough for the user to feel that the system had understood the action. The Total spending card in its three real tiers: Starter, Medium and Expert. Switch tiers to see the amount and the bar change while the card keeps its structure. Control surface ## The sidebar held the whole product ### The sidebar became the product control surface In ProMobile, the sidebar was closer to a control surface than a simple navigation menu. It had to hold the main sections, keep “New order” visible, introduce future Basic and Advanced modes, leave space for profile and support logic, and make the product feel like a coherent environment. An idea to place active orders closer to the sidebar was tested and then put away. It sounded useful, but real behavior made it heavy: many orders, search logic, filters, collapsed sidebar states, and result rendering all added more complexity than value. The sidebar loads as a skeleton, then expands and collapses. Pick any item and the active state moves to it. Character in the corners ### The 404 page revealed the product character The 404 page became one of the first places where the product’s character fully appeared. Instead of treating it as a leftover screen, the design used large soft 3D-like typography, cold white space, blue actions, abstract floating objects, subtle technical depth, helpful links, and a composition that made the broken state feel designed rather than abandoned. The 404 page mattered because it showed that even the forgotten corners of ProMobile could carry the same care as the main flows. ![ProMobile — visual direction, image 2](https://kalkaev.com/assets/zniAuftiOV1tmIDqMToBilagxY0.avif) ![ProMobile — visual direction, image 3](https://kalkaev.com/assets/HKWUKmOBVTmy9jt3Hbpd0jh4I.avif) ![ProMobile — visual direction, image 4](https://kalkaev.com/assets/Zi32gJHESUdZHRlQHUf5Acwbf0.avif) ![ProMobile — visual direction, image 5](https://kalkaev.com/assets/KUAnyfOAQ16e6dYh0jtA67U4ALA.avif) Under scale ## Every surface had to repeat well ### Developer collaboration kept the system honest The system was shaped through ongoing conversations about implementation: whether charts should follow a library like Nivo, whether components would be custom or based on something like Ant Design, whether shadows and glows could survive implementation, how 404 illustrations should be exported, whether effects should be static or dynamic, how overlays would behave, and how dark mode should be handled. The shadows became an important implementation discussion because ProMobile relied on soft glows, layered white surfaces, and subtle lighting to avoid a dead SaaS feeling. The useful tension was between preserving the details that carried the product’s tone and removing details that created unnecessary implementation cost. The expenses card from Statistics. Hover or tap an arc to bring that category forward; the legend and tooltip follow, and the three amounts add up to the total. The full operating map ### The product language had to survive the full map Ranking Optimization and Ratings needed dense flows, charts, status changes, keyword data, progress, and campaign logic. Reviews needed a similar but not identical structure. My Apps and App Overview had to make individual apps manageable without overloading the user. Profile and Settings had to feel quiet and utilitarian. Help had to explain features without becoming detached documentation. Export and payment sections had to remain readable and businesslike. Dark mode was another scale test. It could not be a simple inversion of the light mode, because the light version was cold, airy, and trust-focused, while the dark version had to preserve the same structure and hierarchy while becoming more technical and operational. ![ProMobile — research, image 1](https://kalkaev.com/assets/HKWUKmOBVTmy9jt3Hbpd0jh4I.avif) ![ProMobile — research, image 2](https://kalkaev.com/assets/J1AamkL2Xxm40Vue5L8qkTTN2g.avif) ![ProMobile — research, image 3](https://kalkaev.com/assets/0oPt7mBvn6SSCbtY01vWLePY.avif) Product character ## Character had to survive the full map Money flows, dense data, secondary states, dark mode, and forgotten corners all had to feel like the same product. Repetition under pressure defined the system more than any single showcase screen. Soft type, serious money The 404 page used large soft 3D-like typography, cold white space, blue actions, and abstract floating objects. Type carried the product character from the start and gave the empty state the same care as the financial flows. ![ProMobile — design solution, image 1](https://kalkaev.com/assets/7JX8WWSJvucLrfHRv7hzvBYFw4.avif) ![ProMobile — design solution, image 2](https://kalkaev.com/assets/0SgU1bSbXaeuJQ13ebTScNEfvu8.avif) ![ProMobile — design solution, image 3](https://kalkaev.com/assets/7JX8WWSJvucLrfHRv7hzvBYFw4.avif) ![ProMobile — design solution, image 4](https://kalkaev.com/assets/8q4LppALk4DtetWp2zt8Y78MwSM.avif) ![ProMobile — design solution, image 5](https://kalkaev.com/assets/HKWUKmOBVTmy9jt3Hbpd0jh4I.avif) ![ProMobile — design solution, image 6](https://kalkaev.com/assets/eUFbeIReAJO8wtOgrkIYiexoivE.avif) ![ProMobile — design solution, image 7](https://kalkaev.com/assets/fQwQUugadrh1NRYBoaPKdjveg.avif) ![ProMobile — design solution, image 8](https://kalkaev.com/assets/5lNHU7sHMdk6V6ixjJAoO7ddg.avif) Across the product ## A product language that survived scale By the time the language spread through the rest of the platform, ProMobile felt less like a standard dashboard and more like a soft operating layer for app promotion. More than $2M in ad spend was already moving through the system while users added apps, funded their balance, created orders, tracked progress, analyzed rankings, worked with reviews, checked payments, and exported data. Rebuilding that journey made the order flow 38% faster, and 91% of campaigns completed successfully. Those numbers showed that the product language could survive real operating pressure. Balance gave the system trust, the sidebar gave it control, and the forgotten corners kept its character visible while the platform handled money, dense data, dark mode, and dozens of connected flows. ![ProMobile — outcome, image 1](https://kalkaev.com/assets/EJVgaQ8GWqoYOpJy5zBdi0dTUbQ.avif) ![ProMobile — outcome, image 2](https://kalkaev.com/assets/moxwWYwiPeIdKFwYXxWIGxBn50.avif) ![ProMobile — outcome, image 3](https://kalkaev.com/assets/MczskSY0CDaogX7fSJSuAaTfpV8.avif) ![ProMobile — outcome, image 4](https://kalkaev.com/assets/CjTz6oISeKkWwO64bvccjGLx7n4.avif) An order chip in its five real states. Open the status menu to change it: only the transitions the product allows are available, and Done and Canceled are final. - [Next case](https://kalkaev.com/works/pokerdao) — PokerDAO. Poker first, crypto second. --- More: [llms.txt](https://kalkaev.com/llms.txt) · [HTML page](https://kalkaev.com/works/promobile) · [Text view](https://kalkaev.com/agents/works/promobile/) --- title: "PokerDAO | Ivan Kalkaev" description: "Poker first, crypto second." url: https://kalkaev.com/works/pokerdao --- PokerDAO # Poker first, crypto second. ![PokerDAO multiplayer poker table with players, cards, and a turn timer](https://kalkaev.com/assets/2ogtxOHUQVh7yoxrTnSM8dEqxuM.avif) Service · Web Design · Art Direction · Tools used · Figma · Year · 2023 At the table ## A poker room that feels familiar Welcome to Poker DAO, where we’ve shuffled the deck on traditional poker design. Our aim? To create an experience that feels as comfortable as your favorite hoodie, yet as thrilling as a royal flush. ### A room for beginners and regulars When Poker DAO approached us, they had a vision: to craft a poker platform that broke free from the intimidating, casino-esque mold. They wanted a space that would welcome rookies and seasoned players alike, a place where the excitement of the game took center stage. The PokerDAO lobby as a working screen: sort the tables, open a card’s menu, switch to the list view or try Quick Play. It shows how the lobby behaves, not only how it looks. The opening move ## The game had to outrun the jargon ### Cryptic yet cuddly We knew we had to balance the edge of poker with the warmth of a welcoming community. Our mantra became “cryptic yet cuddly” – an approach that would create an atmosphere of friendly competition, where poker faces are replaced by smiling emojis. The Business Benefit: By fostering a welcoming, inclusive environment, we aimed to attract a wider audience to the platform. A design that feels approachable and friendly is more likely to convert curious visitors into engaged players, ultimately driving growth and retention for Poker DAO. Visual language ## Warmth without losing the edge ### Minimalism Our secret weapon? Minimalism. But for us, minimalism isn’t about having less; it’s about making room for what matters most – the game. By stripping away unnecessary distractions, we allow players to focus fully on their strategy and the thrill of the competition. The Business Benefit: A minimalist design approach not only enhances the user experience but also improves the platform’s performance. With fewer elements to load and render, the interface becomes faster and more responsive, leading to shorter load times and smoother gameplay. This performance boost can significantly impact user satisfaction and retention, as players are less likely to abandon a game due to technical frustrations. ### Immersion through subtraction In the world of Poker DAO, less is truly more. By dialing down the distractions and keeping the focus squarely on the game, we’ve created an environment where players can easily slip into a state of flow. The design doesn’t compete for attention; instead, it fades into the background, allowing the strategy and the excitement to take center stage. The Business Benefit: An immersive gaming experience is key to player loyalty and long-term engagement. When players are fully absorbed in the game, they’re more likely to play for longer sessions, return more frequently, and even recommend the platform to others. By designing for immersion, we’re not just enhancing the user experience; we’re driving key business metrics like session duration, retention, and referral rates. Soft table, classic cards ### The dark theme But we didn’t stop there. When our client requested a dark theme variant, we saw an opportunity to elevate the Poker DAO experience even further. We traded the bright neon for a sophisticated charcoal backdrop, creating an ambiance that’s both upscale and inviting – think jazz club, not casino floor. The Business Benefit: Offering a dark theme variant doesn’t just provide visual variety; it caters to a wider range of user preferences. Some players may find the dark theme easier on the eyes, especially during longer gaming sessions. Others may simply prefer the more sophisticated, premium feel. By providing this choice, Poker DAO demonstrates a commitment to user satisfaction and inclusivity, fostering a deeper sense of loyalty and community. The neon concept and the final charcoal table on the same hand. Drag the divider to compare them and see what changed in the visual direction and what stayed. ![Dark PokerDAO visual direction with floating card details](https://kalkaev.com/assets/VqGetE1etjeEF6Hn65ZKjYSvgcw.avif) ![PokerDAO dark game entry screen with a quick game action](https://kalkaev.com/assets/Ril9ti1oQFluPBWRsaFMfJWObuQ.avif) ![PokerDAO game not found state with a return action](https://kalkaev.com/assets/nM7qH6xMByaeemvibXrYmaK7e4.avif) ![PokerDAO wallet empty state with no transactions](https://kalkaev.com/assets/sx4W0YfOG2wWK9KEfxv22rEM7w.avif) ![PokerDAO in-game fold guidance modal](https://kalkaev.com/assets/vsDUUdxdlDkqNsEfl5yKG5JmGQ.avif) ![PokerDAO mobile leaderboard close-up in the dark theme](https://kalkaev.com/assets/fnzUc4d7SMENSaDIPlsBdypjsY.avif) Rules of play ## Every card and amount must read fast ### The technical tango Of course, a great design isn’t just about aesthetics; it’s about performance and accessibility, too. Throughout the design process, we worked closely with the development team to ensure that every element – from the buttons to the cards to the backgrounds – was optimized for speed, readability, and accessibility. The Business Benefit: A technically sound design is essential for any digital product, but it’s especially crucial for an online gaming platform. By ensuring that the design is performant and accessible, we minimize the risk of user frustration and churn due to technical issues. This attention to technical detail not only enhances the user experience but also protects Poker DAO’s reputation and bottom line. Six real fragments of the table. Open any of them to read a short note on why that part of the interface works the way it does. ![PokerDAO design board showing grouped desktop and mobile interface screens](https://kalkaev.com/assets/rN1q5ZvHQeZ7biYCbNWp0yLQqpo.avif) ![PokerDAO connecting wallet step before joining a game](https://kalkaev.com/assets/9uMCs8L2yIcQkn6lo2jmonw7Z6Q.avif) ![PokerDAO wallet import and network confirmation flow](https://kalkaev.com/assets/6UXiOE3y0RQaiCYiYLum8tCTy8.avif) ![PokerDAO in-game conversation controls during a hand](https://kalkaev.com/assets/OqkJjaxvfuNoNH06teVIkfgrrA.avif) Focus ## Remove the noise around the hand ### The magic of modularity In our design, every element is like a chip in the stack – distinct, purposeful, and perfectly spaced. This modular approach allows the user’s eyes to dance across the screen without tripping over unnecessary frills. By keeping the clutter under the table, we’ve created an interface that’s as easy to read as a well-played hand. The Business Benefit: A modular design system makes the platform more scalable and easier to update over time. As Poker DAO grows and evolves, new features and elements can be added seamlessly, without disrupting the overall user experience. This flexibility ensures that the platform can adapt to changing user needs and market trends, giving Poker DAO a competitive edge. One table in four stages: idle, deal, board and your turn. Step through them to see what the interface brings forward at each moment of a hand. Poppins at the table For the typeface, we chose Poppins – a font that’s straightforward yet never dull. With its clean lines and trustworthy demeanor, Poppins makes every word count, just like every chip in the pot. It’s the perfect typographic voice for a platform that values clarity and authenticity. The Business Benefit: Clear, readable typography is crucial for any digital product. By using Poppins, we ensure that players can easily read and understand all the information they need, from game rules to betting amounts. This clarity reduces frustration and enhances the overall user experience, leading to longer session times and higher satisfaction rates. ![PokerDAO leaderboard typography and ranking hierarchy](https://kalkaev.com/assets/x4MnxW076kJe79iqlAviXRktud4.avif) ![PokerDAO poker table layout with players, cards, and pot](https://kalkaev.com/assets/fDMzuQiMkpGScFw5nExZHQ0sdYA.avif) ![PokerDAO waiting state with player status and timer](https://kalkaev.com/assets/B8q47Ylw2HbQzvx7BDhcAxpGtYY.avif) ![PokerDAO table gameplay with community cards and player actions](https://kalkaev.com/assets/0yoE43AzyO5VvPeLbyhnbjmtFo.avif) ![PokerDAO leaderboard displayed in a desktop device mockup](https://kalkaev.com/assets/gdChZAWizfAix6ExmfBVT0sgOU.avif) ![PokerDAO player profile card with rank and game statistics](https://kalkaev.com/assets/xJB3Z0xkgfDJlURhbliSQZo11U.avif) ![PokerDAO leaderboard with player cards and ranking data](https://kalkaev.com/assets/ov7zekU2pQOBaz1dWBG40rlPgzA.avif) ![PokerDAO buy-in amount control for joining a table](https://kalkaev.com/assets/vUz5CD43fwKCKk6lJD8G7Csmiw.avif) ![PokerDAO hand-ranking guide shown on a mobile screen](https://kalkaev.com/assets/jshGDua7DK2Ad1QaSVmzWXniKmA.avif) ![PokerDAO quick play and create table actions](https://kalkaev.com/assets/x8bTlhjOoLEHZ1hYy0MvIaiM.avif) The finished room ## A warmer room for serious play By the time the MVP reached 64 screens and nine core flows, the modular system had become part of how the product worked. Room creation dropped from 11 steps to three because the interface kept poker conventions familiar, removed decisions that did not belong in the flow, and gave every action a predictable place. The same clarity carried into the business story. A coherent product narrative helped the team support a $750K private round because the platform read as one finished room rather than a loose set of poker screens. Soft colors lowered the threshold for new players, classic card cues kept the game legible, and the dark theme changed the atmosphere without changing how the room behaved. ![PokerDAO mobile poker game with a live hand and action bar](https://kalkaev.com/assets/9Qd6IgnDqmhvbTvOovTPrvLeUNY.avif) ![PokerDAO mobile welcome and entry screen](https://kalkaev.com/assets/p2GpYrXNAHJGTB2PJnhebKBmt4.avif) ![PokerDAO mobile leaderboard and player profile](https://kalkaev.com/assets/edKqIElstwLKALQ9GZjti3IrI.avif) ![PokerDAO mobile table with player status and game controls](https://kalkaev.com/assets/K2bqK3a5wLtv1GL9CTjr3qGY81o.avif) - [Previous case](https://kalkaev.com/works/promobile) — ProMobile. A soft operating layer for app promotion. - [Next case](https://kalkaev.com/works/cybro) — CYBRO. The brand had to molt. --- More: [llms.txt](https://kalkaev.com/llms.txt) · [HTML page](https://kalkaev.com/works/pokerdao) · [Text view](https://kalkaev.com/agents/works/pokerdao/) --- title: "CYBRO | Ivan Kalkaev" description: "The brand had to molt." url: https://kalkaev.com/works/cybro --- CYBRO # The brand had to molt. ![CYBRO — hero visual](https://kalkaev.com/assets/NTD3YZF1UWfoRFUeSV0ynFIdpK8-w768.avif) Service · Visual Identity · Web Design · Art Direction · Tools used · Figma · Year · 2024–2026 Before the pivot ## A loud brand that did its job 2024–2026. We designed the original product. Beavers, latex robots, neon yellow on black, $7M presale. Then they outgrew it, and we killed everything we’d built — logo, UI kit, brand, layout system — and replaced it with something their new audience would trust with real money. One user on Trustpilot literally asked for “less cyberpunk, more seriousness.” We were already halfway done. ### The first skin CYBRO started as a yield aggregator on Blast — AI-powered vaults, a token presale, CYBRO Points, the whole crypto-native playbook. The founding team came with a logo and a landing page, both cyberpunk, both loud. We picked it up from there and turned it into a brand: built the full dApp in two weeks, designed the landing that helped sell $7M in tokens on presale, added the beavers (their mascot, which I’m pretty sure I came up with, though honestly the timeline blurs), drew the 3D robot women in latex suits for the swap page because it was cyberpunk and it was fun and it fit. Expanded the visual language across dashboards, vaults, deposit flows, an AI Broker chat interface, error states with glowing samurai silhouettes — the whole thing. Over roughly a year we shipped the Cybro Vaults dApp, a Telegram Mini App called Cybro Yield, the complete platform with all its transaction flows, and kept adding to the landing page as the product grew. The visual identity was yellow and black, high-contrast, aggressive typography in all caps, neon accents, particle effects. It looked like nothing else in the DeFi space at the time, which was the point — crypto products default to either sterile dashboards or cheap gradients, and CYBRO was neither. It had personality. It also had a beaver mascot that the community loved. By mid-2025, CYBRO was one of the most recognized products on Blast. The design had done its job. Audience change ## Six-figure liquidity needed another signal ### The problem with fitting clothes Then they pivoted. The product would shift from a retail-facing yield aggregator to a professional liquidity management platform — concentrated LP positions on Uniswap V3 and PancakeSwap V3, automation tools for rebalancing and compounding, analytics for serious DeFi users managing real portfolios. The audience changed from “crypto-curious person buying tokens during a presale hype cycle” to “someone with $100K in LP positions who needs tools they can trust.” The CEO called us in, walked through the new direction, and sent a Notion doc. Short, clear, well-structured — same format as the original brief a year earlier, same clarity. They said they wanted to remove the beavers. Remove the neon. Tone it down. And I understood the instinct, but I also immediately saw the trap: you can’t subtract personality from a brand that was built on personality and expect what remains to still work. We don’t stuff products with decorative elements. Every visual decision in the original CYBRO — the yellow, the caps typography, the robot characters, the aggressive geometry — was load-bearing. Remove the beavers and the latex robots and the neon glow, and what’s left isn’t a more serious version of CYBRO. It’s a brand with holes in it, like a jacket with the patches torn off where you can see the bare fabric underneath. So the decision was to redo everything. Not a reskin — a rebuild. New logo, new UI kit, new design system, new layout architecture, new typography, new color relationships, new component library. Every element, every text style, every button, every border radius, every token name in the design system. The old CYBRO was a product we’d designed and were proud of. The new CYBRO needed to be a different product that we’d also designed and would also be proud of, and the only way to get there was to start from zero. ### Killing your own work I want to be honest about what this feels like, because I think it’s underreported. Designers talk a lot about iteration, about not being precious, about killing your darlings. But there’s a difference between iterating on a component and looking at an entire visual identity you built — one that shipped, that users recognized, that contributed to a $7M presale — and saying: this needs to die now, and I’m the one who should kill it. It’s not painful exactly. It’s more like — you know when you move apartments and you have to throw out furniture that was perfect for the old place but doesn’t fit through the door of the new one? The furniture isn’t broken. It’s just wrong now. The yellow-and-black neon palette wasn’t bad design. It was exactly right for a product trying to stand out in a market of beige dashboards and attract retail crypto users. It’s exactly wrong for a product trying to convince a DeFi professional that this is where they should park six figures of liquidity. One of the Trustpilot reviews from that period said it plainly: the app was useful, but would be better with “a more professional design — less cyberpunk, more seriousness.” CYBRO’s own response was “a small redesign is scheduled for April.” They were talking about us. The real Range Heatmap in one compact row. Hover, tap or use the arrow keys to read a single cell without losing the whole picture. Starting from zero ## A rebuild for a different audience ### The grey rectangles experiment This project was where we first tried using AI to build interactive prototypes at the wireframe stage — what we internally called the grey rectangles phase. I’d dump my raw thinking into Claude in a kind of stream-of-consciousness format — here’s what the dashboard needs to show, here’s the hierarchy, here’s what matters most — and it would assemble layouts and rough prototypes that I’d then correct, adjust, and load into Figma. The team from CYBRO saw these and liked them. Specifically, they liked them too much — the product manager later said the wireframe stage “looked cleaner” than what came after, which led to a whole situation I’ll get to. But the method itself worked well enough that it became our standard practice. Every project after CYBRO uses it. ### The wireframe dispute Two weeks into the UI phase, the product manager wrote a message saying the team had discussed the current design and felt the minimalistic wireframe format was more understandable and lighter — both in terms of UI and UX. He wanted to move closer to the prototype look. I recorded a voice message. It started, approximately, with “what you wrote is absolutely incomprehensible bullshit,” which is how my clients have learned to expect creative direction from me. The actual argument was this: you’re confusing the absence of visual design with minimalism. The wireframe looked clean because it had no design — no colors, no depth, no brand presence, no visual hierarchy beyond grey rectangles and placeholder text. It looked approachable because there was nothing there to approach. That’s not minimalism, that’s emptiness, and if we ship a product that looks like that, people will assume you couldn’t afford a designer, and I can’t let our work look like that. I also tried to identify what specifically resonated with them — my read was that the wireframe had fewer UI elements, fewer buttons, less information density, and that’s what created the impression of clarity. That’s a valid observation about information architecture, not about visual style, and you can absolutely have a richly designed interface that’s also sparse with information. The two things aren’t connected. We got on a call. They listened. We found a middle ground — pulled back on some of the color intensity, simplified certain decorative elements, kept the professional finish. The product manager’s response after the revision: “now it looks divine.” And that’s the version that went to production. I think this moment matters because it shows what design direction actually is. My job isn’t to be right — it’s to understand why the client is reacting the way they’re reacting, translate their gut feeling into something actionable, and then fight for the version that actually solves the problem they described rather than the solution they proposed. Sometimes those are the same thing. This time they weren’t. LP Positions in an iPhone: real screens with tabs, position details, the backtest sheet and the wallet menu. Modular C, quieter light ### The logo, quickly The old logo was a stylized “C” — dynamic, diagonal, geometric, kinetic. It looked like it was moving even in a static render. That energy was the point when the brand was cyberpunk. Now the brand wasn’t cyberpunk, and the logo felt like it was trying too hard. I drew the new one in about a day. A modular “C” built from geometric blocks — it reads as a letter, but also as a system, an ecosystem, something you could extend into patterns and sub-brands. I don’t do elaborate logo processes. I’m genuinely not a logo specialist, and I think the industry vastly overcomplicates something that needs to be good enough and appropriate. This one came out better than good enough — I started liking it more after I saw it sitting inside the new UI, and the client said it was excellent on first review. The modular construction turned out to be useful beyond the mark itself. We built patterns from it, used the blocks as a visual motif across the interface, created a 3D-rendered version of the token coin that the SMM team could use in social posts, built team avatars in Midjourney using the new color palette — each team member in a different colored hoodie or jacket, faceless, with the CYBRO logo subtly present. The CEO got a gold blazer. The CTO got the green one. The product manager didn’t know what clothes exist besides hoodies, so he got a hoodie. ![CYBRO — visual direction, image 2](https://kalkaev.com/assets/oH2r2KDf9N9l2z5XH18WMo33Tl8.avif) ![CYBRO — visual direction, image 3](https://kalkaev.com/assets/Dd1UBFP6LDeOJ3tHGoD6Qh3SsU.avif) ![CYBRO — visual direction, image 4](https://kalkaev.com/assets/QmFEme1OSMNkfCBDbZHadcBM.avif) Working in the open ## Wireframes revealed the real problem ### Building while the ground moves Marie — my co-founder, the product designer on this project — was essentially full-time on CYBRO for the better part of the engagement. She owned the design system, the component architecture, every screen that shipped. When I set the art direction and moved to the next decision, she built what actually went into production. The design system was built from zero, simultaneously with the frontend developer implementing it. This sounds like a normal workflow until you’re actually in it — Marie sending him components one by one, the developer building while she’s still drawing the next screen, both of them negotiating token naming conventions in real time. There was a running conversation about whether color tokens should represent opacity values or distinct color shades, whether typography tokens for body and caption styles need separate hierarchies or can share a size scale, how to handle heading tags versus visual text styles. This is the unsexy infrastructure that makes or breaks a product’s consistency across fifty screens and two viewport sizes. The developer was meticulous and opinionated, which is exactly what you want from someone implementing a design system, and exactly what makes the process slower and more argumentative. Marie handled it with the patience of someone who knows that getting the foundation right means never having to fix it later, and with the stubbornness of someone who will not accept a padding change without understanding why. The button matrix from the design file as a picker. Choose a style, size, type and state to see the button exactly as it was specified, hover included. Retail to professional CYBRO first stood out because the original product had a point of view: yellow and black, all-caps typography, neon accents, particles, beavers, and robot characters. The pivot did not make those choices bad; it made the audience and the trust problem different. ![CYBRO — research, image 1](https://kalkaev.com/assets/Lqck5cQRrXESkulfhZGxq6ypXY.avif) ![CYBRO — research, image 2](https://kalkaev.com/assets/Ltd7rEGvyCLmx4XXCCqSnrh1t4.avif) A new identity ## A professional surface with a pulse ### The 3D layer The same 3D artist who built the Arkada NFT collection — found through Behance, now basically part of our team — handled all the three-dimensional elements. The CYBRO token coin, rendered as an actual object with materials and lighting, rotatable, usable from any angle. The referral card — a physical-looking card with the user’s referral information that flips over in 3D, because referral mechanics are inherently utilitarian and boring, and the 3D treatment transforms a UI element into something that feels like a luxury product you’re holding in your hands. Same logic as making an NFT cast a shadow — the dimensionality signals value. The animated CYBRO logo that sits at the bottom of the hub page — a dark, contoured, softly glowing version of the mark rotating in ambient light — was another piece of this. The frontend developer’s reaction to the video-based animations was predictable: he’d never seen anyone ship 3D animations as video files in a web product and wasn’t thrilled about the file sizes. We explored Lottie as an alternative, decided the conversion would cost more time than the weight savings were worth, and optimized with lazy loading instead. The referral card in a browser window. Pick Mauve, Violet or Gold, flip it to the back and try Copy link. Typography lost the shout The original visual identity used yellow and black, high contrast, aggressive all-caps typography, neon accents, and particle effects. The rebuilt system had to earn seriousness without becoming empty. ![CYBRO — design solution, image 1](https://kalkaev.com/assets/ANeYx6gPhfztaD3qiosINwUa4.avif) ![CYBRO — design solution, image 2](https://kalkaev.com/assets/iEA5hli1WeY46SBlS0IiI2KoYzU.avif) ![CYBRO — design solution, image 3](https://kalkaev.com/assets/6y0J8Z8NoIA0ZIkoThp7Nrhoqg.avif) ![CYBRO — design solution, image 4](https://kalkaev.com/assets/Acv9pCTdrW0JfgEZVO6wOhlisg0.avif) ![CYBRO — design solution, image 5](https://kalkaev.com/assets/QTrYKzVg5fnkw67TR1NJh0VTo.avif) ![CYBRO — design solution, image 6](https://kalkaev.com/assets/L8hf1PI0ftFlX0mVssoMH90oGk.avif) After the molt ## A new surface for professional liquidity ### What entered production The new CYBRO is live at cybro.io. Dashboard with LP position management, vault interfaces, create position flows, automated rebalancing and compounding features, a token page, governance, staking, a referral system, and a Pro subscription tier. Desktop and mobile. Every screen designed, every component built, every edge case considered. The brand guidelines, pitch deck (built in a day when the CEO needed it for a meeting), social media templates, team avatars, favicon, token icon for exchanges — all of it sits in the new visual language. When the CEO needed the token icon for CoinGecko and CoinMarketCap and asked whether to use a transparent background version, I told him I genuinely didn’t understand why he’d want a transparent version and to just use the dark one. He agreed. Christmas decorations in December — a glass-morphism header with snowflakes, Santa hats on all the team avatars. Nobody asked for this. We just did it, because when you’re the design function of a product, you think about things like “it’s December and the interface should acknowledge that.” Same reason I proposed the email subscription form for the hub page, same reason Marie flagged a “0/5” label in production that read as “zero out of five used” when it meant “zero remaining.” You watch the product after handoff. That’s what being an internal team means, except we’re not internal. ### The molt A molt is when an animal sheds its outer layer — skin, shell, feathers — because it’s grown too large for the covering it has. The old structure isn’t damaged. It’s outgrown. The animal is the same animal. It just needs a new surface to match the body underneath. CYBRO molted. The product that sold $7M in tokens on presale with beavers and neon needed to become the product that manages six-figure LP positions for DeFi professionals, and the only honest way to do that was to shed the entire visual identity and grow a new one. We happened to be the people who built both skins, which is a strange position — the rare case where the designer’s job is to look at their own shipped work and say “this was right, and now it’s wrong, and I need to be the one to replace it.” The old CYBRO was a good product with a good design for its audience. The new CYBRO is a different product with a different design for a different audience. Both are ours. The thing that carried across isn’t any visual element — it’s the relationship with the team, the daily communication, the willingness to show up with ideas nobody asked for, to argue about typography in a Telegram chat at midnight, to send voice messages that start with profanity and end with a solution. That’s the part that doesn’t molt. The mobile menu moving from Guest to Connected to Pro. The rows stay where they are; only the header and footer change. ![CYBRO — outcome, image 1](https://kalkaev.com/assets/fYMPLTeEn5hcsuTGayjT3tRklKE.avif) ![CYBRO — outcome, image 2](https://kalkaev.com/assets/EVEkPFTA4qCVXlBk9FsMn3ij2CA.avif) ![CYBRO — outcome, image 3](https://kalkaev.com/assets/BaqRnuZF8ScI3MPaPSGyP6y2owo.avif) - [Previous case](https://kalkaev.com/works/pokerdao) — PokerDAO. Poker first, crypto second. - [Next case](https://kalkaev.com/works/blastup) — BlastUP. The funnel is the product. --- More: [llms.txt](https://kalkaev.com/llms.txt) · [HTML page](https://kalkaev.com/works/cybro) · [Text view](https://kalkaev.com/agents/works/cybro/) --- title: "BlastUP | Ivan Kalkaev" description: "The funnel is the product." url: https://kalkaev.com/works/blastup --- BlastUP # The funnel is the product. ![BlastUP tier onboarding flow](https://kalkaev.com/assets/9udwcQx7y3NA00h4rIy2cFG3qA-w768.avif) Service · Web Design · Art Direction · Tools used · Figma · Year · 2024 Road to IDO ## The flow started as two pages of text 2024. A Notion doc with two pages of solid text. A staking flow with more branching logic than anyone expected. 40% less users bailing halfway through. The UI took a day and a half. Everything else took weeks. ### How it got to us BlastUP had designers. Working product, live economy, everything functional. But the co-founder knew us, and specifically knew that the kind of problem he had — structurally complex, full of technical constraints that create UX dead ends — was the thing we’re unreasonably good at. Road to IDO: a flow that takes a user from knowing nothing to having staked tokens and an IDO allocation, through wallet connections, a tier system nobody’s heard of, a choice between fiat and crypto payments, gas fees that technically have to be a separate transaction, and a third-party payment widget that looks like it might be a scam if you don’t frame it right. The brief was a Notion document. Two pages of continuous text explaining how it works under the hood. No states, no edge cases, no UX thinking whatsoever. That was it, that was the whole thing, everything else was our problem. Where people left ## The danger lived between screens ### The part that was actually hard Normally we don’t need three weeks to think about UX on a crypto product. We’ve shipped enough of them that we could spec an NFT marketplace flow at three in the morning if someone shook us awake. The UX on most of these things is, frankly, trivial — the visual layer is where the actual craft lives. BlastUP was the inverse, and that’s what makes it worth telling. The visual layer came together in about a day and a half. The flow logic — the invisible part — took weeks, and it took weeks because every path through the system branched into states we hadn’t anticipated, and every state we missed was a user hitting a wall with money already committed. Marie and I started by building something that looked, and I want to be precise here, like garbage. There were pieces from Kibra in it, pieces from NearWallet, chunks of Untitled UI from a kit we’d bought, elements from the Münzen widget — visually, a complete Frankenstein. But the structure underneath worked. Marie went through every screen sticking in comments — not design annotations, more like dispatches: here’s what this element does, here’s why it’s here, here’s what breaks if you remove it. We showed this beautiful disaster to the client, they approved the logic, and only then did we start making it look like something. The process was: write down every piece of information that could conceivably appear on every screen in every state. Then remove things. Then remove more things. Then take what’s left and find shorter ways to say it. The split between me and Marie: early-stage architecture was maybe 70/30 my direction. Mid-stage prototyping and the entire UI flipped heavily toward Marie. She built most of what shipped. I reviewed, redirected, caught inconsistencies. She’s not an assistant on these projects. She’s a co-author, and this specific project wouldn’t exist without her. Borrowed architecture ## Make learning part of the action ### Stealing from ourselves There’s a curly little arrow — decorative, does a little loop before pointing at something — that was first drawn by Vlad Pochukalin, the founder of a studio I used to work at. I liked it, used it in another project, then another, and it’s been migrating from file to file for four years now. It’s not that I’m copying an arrow. It’s that every project deposits things into a shared library — patterns, components, micro-decisions — and over time that library becomes the reason we work fast, because half the thinking on any new project has already been done somewhere else. For BlastUP, the deposit that mattered was from EZ Wallet. Denchik — one of our guys — had built an onboarding architecture for it that was, and I don’t say this about many things, genuinely brilliant. Left side of the screen: dynamic contextual guidance that changes with every step. Right side: the actual actions. The user is never sat down and taught. They’re doing things and being guided simultaneously, and the seam between learning and doing doesn’t exist. We didn’t copy the screens. We took the idea that onboarding and participation should be the same thing, and rebuilt it from scratch for a completely different product. ![BlastUP dashboard flow](https://kalkaev.com/assets/IVJZ4rgm3Asukxlkr3WhmiBT2b4.avif) ![BlastUP onboarding and event earnings flow](https://kalkaev.com/assets/JlGicFyCzEhFS59vLSD5NxgDjsA.avif) ![BlastUP tier cards](https://kalkaev.com/assets/gCDQj4sg1OBOgMlGb8Xm4lsltI.avif) ![BlastUP extra bonus levels](https://kalkaev.com/assets/w0u479pBBGOBkFjNpfihwy6kvxU.avif) State by state ## Write the invisible flow first The real work was writing down every piece of information that could appear on every screen in every state, then removing what did not help. The flow branched into states we had not anticipated, and every missed state could become a user hitting a wall with money already committed. The staking card starts empty with a single action. Press it to see the pools and rewards unfold from that one step. ![BlastUP dashboard modal state](https://kalkaev.com/assets/ZYIi9HsivdyxHQdd9NyZNeQnNcQ.avif) ![BlastUP airdrop dashboard](https://kalkaev.com/assets/JPtGFMissk68HZOMuxGLfuAeUM.avif) Forward motion ## Keep the next tap in reach ### Five clicks to irreversibility The thing that cut drop-off by 40% is hard to point at, because it’s not a feature — it’s a structural choice about where one thing ends and another begins. Or rather, the choice to not have that boundary at all. Standard flow: onboarding ends, real flow starts, user connects wallet, user begins participation. The problem is that the gap between “onboarding ends” and “real flow starts” is where most people leave. It’s a natural exit point — I’ve learned enough, I’ll come back later, maybe. What we built: five steps. First three are clearly onboarding — here’s how tiers work, here’s what allocation means, here are the UI elements you’ll see later, introduced now with text so they’re already familiar when they show up for real. You click “Let’s go.” Then “Great.” Then “Got it.” Step four looks like onboarding. Same layout, same pacing, same position for the button. It is not onboarding. You are now technically in the IDO participation flow. Step five: “Connect wallet” appears in the exact spot your thumb has been tapping for four screens. Nobody decides to participate. They just never encounter a moment that asks them to decide. Five steps, no seam ### The modal that keeps its mouth shut After you connect your wallet, you choose how to pay — fiat or crypto. This shows up as a modal overlay, not a full page. This was a very deliberate, very small decision that I still think about. A full page communicates weight. It says: here is a significant decision, please pause. A modal communicates utility — quick thing, pick one, move on. At this point the user has already connected their wallet and tapped through four screens of forward motion. The last thing you want is a layout that whispers “maybe stop and think about whether you really want to do this.” The tier upsell operates on the same principle. On every relevant screen: what your current tier gets you, what the next tier would get you, and exactly how much more you’d need — calculated live from your existing staked balance, converted to fiat via API, shown right there in context. Not a popup. Not an interruption. Information that belongs where the user is already looking, arriving at the moment they’re already thinking about it. The gas fee step — technically forced, a constraint we couldn’t remove — became part of the same rhythm. Pre-warning on the screen before. The gas screen itself explains what you’re paying for. Everything presented as context for the step you’re on, never as a pitch for a step you haven’t chosen. The standard flow, where most people leave after the tutorial, next to the shipped one, where onboarding runs straight into the real flow. ![BlastUP staking and IDO paths](https://kalkaev.com/assets/FYtTveudvIuPMklXCZmkE10fY8.avif) ![BlastUP event earnings](https://kalkaev.com/assets/5TEqBIAsT7GrTeHILzTjLsGM.png) ![BlastUP current tier and token CTA](https://kalkaev.com/assets/EW6L4f4pTMoHOc0f3q4MrlTbHjE.avif) ![BlastUP referral IDO program](https://kalkaev.com/assets/04emjIbYB3lvMx3sHhAtQthQ7g.avif) ![BlastUP IDO and referral surfaces](https://kalkaev.com/assets/rz1rEsKRFwYhG5m2d4ssyR7ng.avif) ![BlastUP staking and pool surfaces](https://kalkaev.com/assets/M2OQbGUg16QIeEW7mrchCkD8.avif) ![BlastUP CTA exploration](https://kalkaev.com/assets/J6nk9YhPT40bBgbOSlzJ7j262g.avif) The measure ## 40% less drop-off The cyberpunk glow and volumetric tier cards, the shadows that make them feel like physical objects you’re picking up rather than flat images you’re selecting, the payment operator logo embedded directly in the action button so you know who’s processing your money before you tap — all of this is real craft, and all of it affects conversion. In crypto, visual confidence is spending confidence. But it was a day and a half of work on top of weeks of structural thinking, and I think that ratio — not the screens themselves — is the thing worth remembering about this project. The product that shipped looks clean and professional and glowy. The product that actually works, the one that reduced drop-off by 40%, is invisible. It’s the architecture underneath — which screen comes when, what information lives where, which moment feels like a pause and which feels like momentum, and the precise point at which onboarding stops being onboarding and starts being the thing itself, which is a point that, if we did our job right, nobody can find. The six tier cards from the design file. Hover to tilt them and click to flip. ![BlastUP spacecraft scenes](https://kalkaev.com/assets/xgjEhoLvrqMbsZNDEFFxBt7hW0.avif) ![BlastUP dashboard final surface](https://kalkaev.com/assets/PgNrBTpporAr9x215O54Z29Muf8.avif) ![BlastUP IDO and referral final surface](https://kalkaev.com/assets/rz1rEsKRFwYhG5m2d4ssyR7ng.avif) Related writing - [Previous case](https://kalkaev.com/works/cybro) — CYBRO. The brand had to molt. - [Next case](https://kalkaev.com/works/apebro) — ApeBro. DeFi with a face. --- More: [llms.txt](https://kalkaev.com/llms.txt) · [HTML page](https://kalkaev.com/works/blastup) · [Text view](https://kalkaev.com/agents/works/blastup/) --- title: "ApeBro | Ivan Kalkaev" description: "DeFi with a face." url: https://kalkaev.com/works/apebro --- ApeBro # DeFi with a face. ![ApeBro — hero visual](https://kalkaev.com/assets/YHH1oSDvJOCjx6Na1felnQOX0-w768.avif) Service · Web Design · Art Direction · Branding · Tools used · Figma · Year · 2025 The pilot ## A normal vault with an unusual brief ApeBro started as a tiny thing, at least on paper. A team we already knew from previous DeFi work came back with a request that sounded like almost every fast crypto experiment sounds at first: they needed a simple dApp on ApeChain to test a vault hypothesis, probably in a week or two, with a home page, a few vault cards, a vault detail page, deposit and withdraw, TVL, current balance, transaction history, and enough structure for people to understand what the thing does without pretending it was already a giant financial machine. The brief was almost aggressively normal. Three vaults, basic mechanics, reuse as much as possible from an already proven vault flow, ship fast, don’t build a cathedral where a booth would do. And then, because it was ApeChain and because the people around this project were exactly the kind of people who could say “let’s add apes” and actually mean it, the whole thing immediately started drifting into a better, dumber, much more useful direction. The ape characters were not some deep strategic invention from our side at the beginning. The client came with that wish already baked into the request, and honestly it felt more like a prank than a branding strategy. There was this very natural crypto logic in it: ApeChain, ApeBro, apes, gold chains, hoodies, caps, a little bit of street attitude, the whole thing writes itself if you don’t overthink it to death. But the important part was that we didn’t treat the characters as a decorative layer you just slap on top of a clean crypto dashboard because “the brief says mascots”. That would have been the safest, most boring version of this project: make a normal DeFi UI, put a few funny apes somewhere near the cards, call it a day, and pretend that this is character-driven design. We had more room than usual because it was a small web product, not a massive production system that had to survive fifteen platforms, three mobile apps, admin panels, white labels and a thousand dark enterprise edge cases, so the useful question became very simple: if the illustrations already define the world, why should the interface pretend it lives somewhere else? That was the moment when ApeBro stopped being “a dApp with apes” and became an actual little product world. I started shaping the concept through Midjourney, generating these gangsta ape characters until the style had enough attitude and enough internal logic to become a direction rather than a random moodboard. Masha then took the direction and turned it into proper design work, cleaning, drawing, adapting, building the actual screens and assets, while Alice handled the communication and kept the whole process from turning into pure beautiful chaos. My role was concept, art direction and the overall visual logic: what kind of world this is, how far we can push it, how dirty or polished it should feel, how the product and the deck should speak the same language, where the joke ends and where the actual financial product begins. The trust problem ## Let the joke stay attached to the product The vaults themselves needed faces because the product mechanics were simple and the differences between vaults were not naturally visual. One vault could be APE, another APE-USD, another APE-ETH, later more combinations could appear, with different APY, TVL and strategy logic, but most of that difference lives in labels, numbers and technical descriptions. If you show three vault cards for a fraction of a second without characters, many people will read them as three versions of the same thing. With characters, they immediately become three different entities, even before the user reads the token pair or compares the numbers. We didn’t pretend that each ape was somehow deeply matched to the risk profile of the vault, because that would be fake cleverness. The characters were mostly random assignments in terms of financial meaning, but visually they did exactly what they had to do: they gave each vault a body, a mood, a memory hook, a way to be recognized faster than a line of text. This is also where I strongly don’t believe in the baby version of color psychology. The blue vault is not blue because blue means some sacred emotional thing, and the orange one is not orange because a Medium article once said orange means excitement. Most of that is design numerology for juniors and people who want rules because they don’t yet trust their own eye. Success states are green and error states are red because that pattern has been burned into users for years and there is no good reason to fight it in a financial product. Everything else was taste, rhythm, contrast, composition and the feeling of the particular screen. We used color to make the vaults feel different and to make the whole product feel bright, quick and alive, not to perform a fake psychological ritual on the user. The obvious risk with a project like this is that it can slide into clown territory. You have money, deposits, APY, TVL, token pairs, wallets, transaction history, projected yield, and then suddenly there are apes in caps, bananas, “Check Dis Vault”, “Ya’ deposit”, and a sad banana judging you because you don’t have enough available funds. A lot of teams would panic here and try to balance it with some serious fintech wallpaper, as if a white card and a blue button automatically make a product trustworthy. I don’t think that’s how it works. Meme energy becomes a problem when it is executed badly. If the composition is weak, if the typography is lazy, if the hierarchy collapses, if the illustration quality is cheap, if the UI is screaming from every corner, then yes, it starts smelling like scam. But if the whole thing is drawn, composed and assembled properly, the joke doesn’t make the product weaker. In crypto, especially around ApeChain and the whole ape/NFT/meme context, a bit of well-made madness can actually make the product more honest than another sterile “secure DeFi infrastructure” dashboard trying very hard to look like a bank. So we didn’t solve the “how do we make this not look like a scam” problem as a separate problem. We solved it through skill. The interface still had basic UX discipline: clear hierarchy, obvious actions, consistent card logic, predictable deposit and withdraw flow, readable numbers, transaction history where it made sense, wallet states, empty states, error states, and enough repetition for the product to feel usable instead of poster-only. The wild part was not allowed to eat the functional part. The wild part gave the product a face, while the structure kept the face attached to a body that could actually move. A quick glance test on the three real vault cards: can you tell them apart with the faces and without them? It shows what the faces do for recognition. Building a world ## Give every vault a face The first concept was basically a controlled accident. I don’t remember if I started from the home page or the vault page, but I remember the state very clearly: I put on GTA San Andreas music and just started drawing as it felt right. This is a terrible recommendation for most people and a completely normal way to work if you have spent ten-plus years drawing interfaces and have enough hours in your hands for “spontaneous” decisions to be backed by actual experience. There was no sacred research ritual behind every sticker, every asymmetrical plate, every weird button, every handwritten tag. A lot of it was pure instinct, but instinct here doesn’t mean randomness. It means years of looking at screens, breaking them, fixing them, shipping them, seeing what feels dead and what suddenly starts breathing. The deposit widget is a good example of how we handled that balance. Structurally, we reused a pattern from previous DeFi work because it had already proved itself: wallet balance, selected asset, deposit amount, percentage shortcuts, projected yield, deposit action, and small support links where needed. We didn’t need to rediscover how a person puts tokens into a vault just because the project had apes on it. But visually we refused to leave the widget as a clean, generic fintech block. The input areas became slightly crooked, the labels became more like stickers, the cards started feeling like pieces of the same world as the characters, and the whole thing got this printed, poster-like attitude instead of standard SaaS neatness. At some point we checked with the developer, and the general vibe was basically “you’re insane, but fine, we can build it”, which is usually the correct zone for a project like this. Time was the other important constraint. Three weeks for a product like this is almost nothing, especially if you count desktop, mobile, visual direction, characters, product states, deck, and later branding materials around the same world. So we cut the things that would eat too much time for too little immediate value: advanced UX pleasures, unexpected convenience mechanics, nice microinteractions, motion details, little hidden jokes that need engineering love, all the cute things we usually like to add when the project has oxygen. Instead, we put a lot of the fun into static illustration and visual states, because illustration gives a huge emotional return without requiring the same development cost as animation or complex interactions. A sad banana in an error state is cheap to ship, easy to understand and instantly memorable. A beautifully animated multi-step wallet ritual might be lovely, but not when the whole thing needs to move like a small crypto raid. The deposit widget moving through Active, Filled and Error, with the sad banana and the design notes pinned to each state. One vault card exploded into seven layers. Use the slider, then hover or tap a layer to see why it’s there. ![ApeBro — visual direction, image 2](https://kalkaev.com/assets/0ekhA7VOu0sgc1HcF1qe6mgnPg.avif) ![ApeBro — visual direction, image 3](https://kalkaev.com/assets/GRDguIhZ6ruRTGQIrhojkA4qgE.avif) ![ApeBro — visual direction, image 4](https://kalkaev.com/assets/fq6Rs8DwYlPKgShfSvQ3SSN1g.avif) ![ApeBro — visual direction, image 5](https://kalkaev.com/assets/NquDeQHiiOjBaivEp8B7AoKvaYw.avif) Pilot scope ## Make the pilot feel complete ApeBro also forced a nice product decision around the transaction history. Inside one vault, the history would naturally be pretty modest because a user might have only one or two meaningful actions there: deposit, withdraw, maybe not much else. That could make the table feel a bit lonely if treated as a big product feature. In the chat we discussed whether it should live only inside the vault or also appear on the main page when the wallet is connected, and the more useful direction was to make the main page show the user’s activity across the product if there is something to show, or give them a good empty state if there isn’t. Again, the point was not to invent a huge analytics layer. The point was to make the product feel complete enough and clear enough for a pilot, without pretending it had already lived for years and collected a thousand events. The vault listing itself also had to grow while we were already moving. The original brief was very clear about three vaults, and the whole first visual structure was built around that small number. Then came the classic crypto product move: actually, maybe there will be five at launch, and maybe later even more, and ideally it should not require a global redesign every time. We didn’t want to hide extra vaults behind some “Explore more” drawer because then those hidden vaults would get almost no attention, and for a small yield product that is a bad trade. If you want users to compare strategies, everything important should be visible and more or less equally accessible. So the layout direction shifted toward a structure where more vaults could be added without breaking the whole thing, and where the visual identity of each vault could still do its job. ![ApeBro — research, image 1](https://kalkaev.com/assets/f6zEaLRnegGrLS1cQfT8ytzkZc.avif) ![ApeBro — research, image 2](https://kalkaev.com/assets/jGDMMKCdxqZgjX0NRSbL229pZ6U.avif) One visual world ## Carry one voice into the deck The pitch deck became the second half of the same artifact. There was a small moment where we had to decide whether investor materials should become more strict just because they are investor materials. The answer was no. If the product is ApeBro, the deck should not suddenly dress up as a McKinsey intern. It had to keep the gangsta-ape language, because that was already the product’s strongest asset. The deck had to explain the team, the roadmap, the revenue streams, the market logic, goals, private round and the whole investment story, but it had to do that in the same world as the dApp: big typography, sticker labels, ape characters, banana jokes, street-poster rhythm, strong colors, and enough financial structure underneath for the whole thing to still be readable. That is the part I like about this case: the pitch deck and the product screens are not two separate deliveries from two different planets. They feel like one product speaking in two formats. That matters because a lot of early-stage crypto products suffer from split personality. The deck is one style, the app is another style, the logo is a third thing, the social banners look like someone panicked in Canva, and the whole brand becomes a pile of disconnected assets. ApeBro avoided that because the world was strong enough to absorb everything: the vault pages, the home page, the mobile version, the pitch deck, the logo, favicons, Twitter avatar, Twitter header, and the small branding guide later on. Even the logo had that same slightly stupid charm. Masha drew it, we had a moment of “is this actually okay?”, and the answer was basically yes, who cares, it works, ship the monkey. That sounds unserious, but in the right project this is exactly how you keep the energy alive. You don’t murder the fun with committee polishing. You make it good enough, sharp enough, funny enough, and consistent enough to carry the product. The funniest thing is that ApeBro was never unique because of some revolutionary product architecture. It was a yield vault pilot on ApeChain. The mechanics were understandable, the scope was compact, the user flow was not trying to change the history of finance. The unique part was that a fairly normal DeFi hypothesis got a face, a tone, a small cast of characters and a visual world that made it feel bigger than the raw feature list. That is often where design does the most valuable work. It doesn’t always need to invent the product from scratch. Sometimes it takes something that could have looked like a spreadsheet with a connect-wallet button and makes it feel like a thing people can remember, pitch, screenshot, send to investors, joke about, and actually want to open again. ![ApeBro — design solution, image 1](https://kalkaev.com/assets/iL2tPnhBukViXBi9TwMKYkfJzk.avif) ![ApeBro — design solution, image 2](https://kalkaev.com/assets/S5HUPxAbWM4UdKberWNh8elKVE.avif) ![ApeBro — design solution, image 3](https://kalkaev.com/assets/PfRV2VatytxDv2e9tCFpwFYA.avif) ![ApeBro — design solution, image 4](https://kalkaev.com/assets/FjdBH9heFqz9YrYM6CP8FEobk.avif) ![ApeBro — design solution, image 5](https://kalkaev.com/assets/DJ2waE5GVKyQIvO5rr0JqwW4.avif) ![ApeBro — design solution, image 6](https://kalkaev.com/assets/LJLcg96CfEvkNivlPDcPS0WQ.avif) ![ApeBro — design solution, image 7](https://kalkaev.com/assets/5CBR9NMqpvIcIFt2MMAJwS7A2E0.avif) ![ApeBro — design solution, image 8](https://kalkaev.com/assets/9cJMgXBvZoeybmzVqsAFsA7zYI.avif) The shipped pilot ## A DeFi universe people remember The final result was a working pilot direction for ApeBro: product screens for the dApp, vault cards, vault detail pages, deposit and withdraw logic, transaction history, connected and disconnected wallet states, error states, mobile versions, a pitch deck in the same gangsta-ape universe, and later a small branding package around the same visual language. The project was launched and used as part of the team’s investor conversations, and after that its fate moved outside our direct responsibility, which is normal for this type of early crypto experiment. We were not there to become the permanent internal design department for ApeBro forever. We were there to take a fast hypothesis, give it enough product shape to exist, and enough visual force to not disappear into the endless swamp of identical DeFi dashboards. For me, this case shows one of the main things I care about in product design: taste is not a surface layer. Taste can change how a product behaves in people’s heads. A vault can remain a vault, a deposit can remain a deposit, and a transaction table can remain a transaction table, but the way you frame them can turn the whole thing from “yeah, another crypto tool” into something with a name, a mood and a little mythology around it. ApeBro was a prank that escaped containment in the best possible way. It started as “let’s make a quick dApp with apes” and ended as a small, usable, pitchable DeFi universe where even the error state had a character, even the deck had swagger, and even the boring parts looked like they belonged to the same gang. ![ApeBro — outcome, image 1](https://kalkaev.com/assets/9syR2WwBD1w9XpjmwVwOCnbYZxk.avif) ![ApeBro — outcome, image 2](https://kalkaev.com/assets/Few7BeqkdjP9kU1iYaFuTKlXI.avif) ![ApeBro — outcome, image 3](https://kalkaev.com/assets/j6EGPLFxnyt5xjZbG8TMTL0fHE.avif) - [Previous case](https://kalkaev.com/works/blastup) — BlastUP. The funnel is the product. - [Next case](https://kalkaev.com/works/arkada-app) — Arkada App. A quest platform with a second loop. --- More: [llms.txt](https://kalkaev.com/llms.txt) · [HTML page](https://kalkaev.com/works/apebro) · [Text view](https://kalkaev.com/agents/works/apebro/) --- title: "Arkada App | Ivan Kalkaev" description: "A quest platform with a second loop." url: https://kalkaev.com/works/arkada-app --- Arkada App # A quest platform with a second loop. ![Arkada App — hero visual](https://kalkaev.com/assets/FjH2KnXjAudyvW0Qu9wVSd0s8Q-w768.avif) Service · Web Design · Art Direction · Motion Design · Tools used · Figma · Cinema 4D · Year · 2025 Quest platform ## One product for quests and collectibles Arkada was building a Web3 quest platform while campaign traffic was already moving through the product. The platform needed to handle quests, points, rewards, leaderboards, profiles, partner campaigns, and a presale story without feeling like a generic crypto dashboard. 2025. Seven artifacts, each hand-modeled in 3D. A lore bible I wrote before touching any AI. A lighting direction lifted from a horror episode nobody watched. 30,000+ holders. Every piece sold out between February and September. In an industry built on generative randomness, we made everything by hand — and that was the point. Traffic in motion ## Traffic arrived before the system settled The harder problem was positioning. Arkada had to feel close enough to Soneium to borrow ecosystem trust, but independent enough to keep its own visual identity. The NFT universe added another layer. Artifacts, badges, maps, and campaign visuals had to connect back to user status and quest behavior, not live as a separate drop beside the product. ### Why seven artifacts Most NFT collections are a character design sheet fed through a combinatorial script — ten hairstyles, eight backgrounds, six accessories, shuffle, mint ten thousand. The creative work is the character. Everything after that is automation. Arkada is seven unique 3D artifacts, each individually modeled, individually lit, individually animated, each placed in its own environment, each carrying a lore fragment that only makes narrative sense in relation to the other six, culminating in a burn mechanic where collecting and destroying all seven produces a single Super-NFT. No trait randomization. No generative shuffling. Every piece art-directed from scratch. This is roughly fifty times more expensive and slower than the standard approach. In a market that optimized for volume, we optimized for depth. The case study isn’t about overcoming some dramatic obstacle — the project ran smoothly, the client was aligned, the timeline held. The case study is about why you’d choose to build something this way at all, and what becomes possible when you do. One connected surface ## Landing, app, profile, and rewards ### One connected product surface I treated Arkada as one product surface: landing, app, profile, leaderboard, quest cards, NFT rewards, and campaign visuals. The landing page was organized around launch-critical clarity: presale context, current stage, promoted quests, top winners, and a direct path into the app. The app redesign focused on the screens the product needed immediately: quest home, leaderboard, profile, quest detail, mobile states, notifications, reward assets, and basic progression. Arkada Score was intentionally pushed down because the team did not yet have enough live data to calculate it properly. Quest cards, premium states, and quest detail pages were redesigned so different partner mechanics could scale without breaking the interface. Profile became the place for visible status: badges, achievements, rank, points, and later NFT-related assets. The NFT layer became part of the same system: seven hand-modeled Shogun artifacts, OG/Bushi badges, Soneium ecosystem badges, SONEX collab badges, Path of Soneium maps, seasonal rank assets, and campaign visuals. One quest card through its whole life, from locked to reward received. Each state puts a different question first: what unlocks it, what to do next, how far along you are, what you get. Seven artifacts, one world ### Arkada Shogun Denis — one of the founders — had been circling the theme for weeks with his team. They knew they wanted cyberpunk. They knew the platform was called Arkada. Beyond that, the meta-layer was open. At some point on a call, Denis just said it: Arkada Shogun. Cyber-samurais. And I remember everyone pausing, and then Denis going, “I don’t know, but what the fuck is actually cooler than cyberpunk ninjas and samurais?” And there was this beat where we all just sat there, because — yeah. He’s right. Nothing is. We pitched five concepts — samurai artifacts, demon masks, mecha-clans, dragon-forged weapons, capsule figurines — each with full lore, mechanics, and visual direction. I wrote the concepts in a few hours using AI to scaffold my ideas, but I was pushing for Bushi from the start: seven pieces of samurai armor, each tied to one of seven masters who shaped Arkada’s reality. The client picked it immediately. The samurai framework was structurally flexible, instantly legible across cultures, and the collect-and-burn mechanic mapped perfectly onto Arkada’s existing quest platform. ### A month on the helmet The first NFT was the helmet. It was also the longest — over a month of work — because the helmet was where every visual decision for the next seven months had to be made simultaneously. Static images were out immediately. We decided every NFT would be a looping 3D animation — the artifact rotating on its axis, visible from every side, fifteen to twenty seconds at 4K, zipped into a seamless loop. Kolya — our 3D artist, found through his Behance portfolio, now basically part of the UNIPAWS team for everything 3D — built the models. The pipeline started with Midjourney: I’d generate directions, curate, combine. Kolya would build the actual model from scratch in Cinema 4D, starting with a grey base mesh and adding or subtracting detail until the balance felt right. The rotation format created a constraint we hadn’t anticipated: detail density. Too much detail and everything blurs into noise as the object spins. Too little and there’s nothing to discover when someone freezes a frame and zooms in at full resolution. The sweet spot was objects detailed enough that a collector studying a high-res render would notice something they missed on first viewing, but clean enough that the overall silhouette reads instantly during rotation. And then there was neon. Neon is seasoning, not a main course. If every surface glows, nothing glows. We had to be deliberately restrained about where light lived on each object. No other NFT in the collection took as long as the helmet. It couldn’t, because the helmet was where the style crystallized — after that, every subsequent artifact was built on decisions we’d already fought through. ### The episode nobody talks about About a year before this project, I watched Guillermo del Toro’s Cabinet of Curiosities on Netflix. Almost nobody talks about episode seven — The Viewing, directed by Panos Cosmatos, the same guy who made Mandy with Nicolas Cage. It wrecked me visually. Not Blade Runner cyberpunk, not Ghost in the Shell cyberpunk — something else. A specific quality to the light: the way illumination disperses through haze, how highlights bloom and dissolve into atmospheric fog, the interplay between warm and cool sources creating a depth that tricks your brain into feeling physical space. That episode became the lighting DNA for every NFT in the Arkada collection. Not a vague mood reference. The actual foundation for how we handled post-processing, light placement, and atmospheric rendering across all seven artifacts. I showed Kolya screenshots first. He didn’t quite get it — stills couldn’t convey the thing that made it special, which was how the light *moved*. So I told him to just watch the episode. He did. Came back and said, “Yeah, I understand now.” And from that point forward, the direction was locked. This is how creative direction actually works: you don’t invent visual languages from scratch. You encounter something in a completely unrelated context that hits you in a way you can’t fully articulate, and you spend months translating that feeling into a different medium. A horror episode about a billionaire’s drug-fueled dinner party became the lighting bible for a cyber-samurai NFT collection. The connection is invisible unless someone tells you. I’m telling you. ![Arkada App — visual direction, image 2](https://kalkaev.com/assets/lAJhKsk5mFynpvS71owmmk7Ek0g.avif) ![Arkada App — visual direction, image 3](https://kalkaev.com/assets/h0zqeki1BJLI9cmEtqMLfZYTVs.avif) ![Arkada App — visual direction, image 4](https://kalkaev.com/assets/5INIgXezLKnkgMoJ1UJbSfbIlY.avif) ![Arkada App — visual direction, image 5](https://kalkaev.com/assets/jaFWR06Sk0inlwpxltnwgf9PuI.avif) ![Arkada App — visual direction, image 6](https://kalkaev.com/assets/rEWGTUAhn6wwDbsiLZigDWKUwpQ.avif) Status with a destination ## Every badge had to lead somewhere ### Writing the world backwards The lore was part of our offer, and I wrote it myself. This needs a specific distinction: the foundation — the cosmology, the story structure, the philosophical core — I wrote by hand, in a document, over four or five days. AI came after, for detailing, for expanding descriptions, for polishing the prose. But the bones were mine, written the old way, just a blank page and a head full of Dark Souls. I’ve played the third game more times than is probably healthy. What I love about Dark Souls — specifically the third one — is the silence. The world doesn’t explain itself to you. Every fragment of information feels like something you weren’t supposed to find, left behind by a world that doesn’t care whether you understand it or not. There’s this wordless reverence to it, a hush, and I wanted that exact feeling for Arkada. The document I worked from was chaos — not chronological, not structured, just a pile of fragments. A paragraph about visual details for the environments, then a paragraph about a pivotal event in the lore, then a note about how the magic system should feel more like engineering than sorcery. At the bottom, a numbered list of how it all fit together chronologically. That’s what I took to AI for assembly. The first thing I wrote was the ending. The twist that holds the whole narrative together: what’s sealed behind the Sevenfold Gates isn’t a threat. It’s Arkada’s own consciousness — the first non-human intelligence, born not from written code but from self-organizing data patterns. The Seven Masters weren’t jailers. They were guardians, protecting something they couldn’t fully comprehend from humans who would destroy what they couldn’t understand. The artifacts aren’t weapons. They’re a translation layer — each one decodes a specific aspect of that alien consciousness into something a human mind can process without breaking. I wrote the ending first because the ending is the reason the world exists. Everything else — the masters, the artifacts, the rituals, the historical notes — all of it only matters because it’s leading somewhere that reframes everything you thought you knew. I wanted that same structural trick Dark Souls pulls constantly, except the flip happens when all seven artifacts unite and burn in the Ritual of the Seven Gates, and the Super-NFT that emerges — the Aspect of the True Shogun — represents not power, but mediation. A bridge between two forms of consciousness that have been trying to talk to each other since Arkada first woke up. ![Arkada App — research, image 1](https://kalkaev.com/assets/sGHGaph4Of1vtyRQwF1iWcN5Ec.avif) ![Arkada App — research, image 2](https://kalkaev.com/assets/fMYT6fVtmrD2FKlY7GV7o7dCgQ.avif) ![Arkada App — research, image 3](https://kalkaev.com/assets/mGsKhuxyiwc8KSJENzuYi6rf8EQ.avif) ![Arkada App — research, image 4](https://kalkaev.com/assets/GlyYXIYU9rLgNgt2mZhXTLXMWHs.avif) Artifact system ## Turn collection into participation ### After the helmet The katana was the fastest. Clean geometry, iconic silhouette, the kind of object that practically art-directs itself. The pauldrons were the worst. Technically, they were a nightmare — there’s an animated element, essentially an aquarium built into the shoulder piece with glowing particles suspended inside. And because nothing in Arkada’s world runs on magic — everything operates on engineering logic — the particles needed visible infrastructure. Tubes running along the surface, connecting to the chamber, carrying whatever substance kept the particles in suspension. The particles themselves had to move, pulse, travel through the tubing. The belt had its own drama, though not technical. We built it with a red cloth element — fabric designed to contrast with the breastplate it would sit on top of. The client thought it looked too gypsy. We cut the red cloth. The belt shipped without it. I still think it looked better with it. Seven artifacts, February to roughly September 2025. Each one taking two to three weeks on average, with the helmet as the month-long outlier that front-loaded all the style decisions. ### Collect, destroy, transcend The burn mechanic is the narrative climax disguised as a product feature. Collect all seven artifacts. Activate a smart contract. All seven tokens burn — permanently destroyed. A new token emerges: the Aspect of the True Shogun. In design terms, it’s a mechanic where the reward requires destroying your entire collection. You can’t keep what you have and get what’s next. The Gates don’t open for collectors. They open for someone willing to sacrifice everything to learn what’s on the other side. That’s not a gimmick bolted on after launch — it’s the reason the lore exists in the shape it does. The reward roulette after a completed quest. Spin it: it lands on a demo points boost, and the next quest card shows it applied, 500 base × 1.5 = 750. ![Arkada App — design solution, image 1](https://kalkaev.com/assets/gPKDsN97o5QZNFjxZhNHTT2h1uw.avif) ![Arkada App — design solution, image 2](https://kalkaev.com/assets/GGp2mjcc9HIZgK0lfVzmILKC8o.avif) ![Arkada App — design solution, image 3](https://kalkaev.com/assets/EBEpvGJQEsqf0tJhsriZMLuTY.avif) ![Arkada App — design solution, image 4](https://kalkaev.com/assets/sc3qJqTWNhn5WiNN4oGC1TkaxoM.avif) ![Arkada App — design solution, image 5](https://kalkaev.com/assets/F2QGsRQUGUrpJC1I6hFJdz8J0xI.avif) ![Arkada App — design solution, image 8](https://kalkaev.com/assets/geihKQOBsNpdvJJqCNy4eYMFOI.avif) ![Arkada App — design solution, image 9](https://kalkaev.com/assets/fQKep7G3QXjVVWw6lvQ4ZRbYClw.avif) ![Arkada App — design solution, image 10](https://kalkaev.com/assets/xWPE2wcqZm5TFAz5RFAkd4vM2yg.avif) Across five seasons ## A world that kept the loop alive Arkada got a launch-ready design system for a Web3 quest platform, not a cosmetic reskin. The first release package covered the landing page, app master screens, mobile adaptations, quest cards, leaderboard, profile, reward states, and campaign visuals. It gave the team a clearer surface for presale and quest traffic while the product was already seeing 20K+ active campaign traffic. The NFT layer gave the platform a second loop: users could complete quests, earn badges, climb rankings, collect artifacts, and follow seasonal campaigns inside one recognizable world. The Shogun artifact set reached 30K+ holders, while Path of Soneium expanded the system into five 10-day ecosystem seasons. The result was continuity: Arkada could move from presale to quests to NFT drops to partner campaigns without redesigning the product language every time. ### The thing that cannot be replicated Over 30,000 holders across the collection. Every piece sold out. These are good numbers in any NFT market, and exceptional in a market that by early 2025 had already gone through its disillusionment phase. But the number I keep thinking about isn’t on a dashboard. It’s the fact that people read the lore. They discussed the connections between artifacts in community chats. They theorized about what happens when you burn all seven. The world I wrote over four chaotic days landed. People moved into it. That’s the thing a generative collection can’t replicate. You can shuffle ten thousand unique images from a single character sheet and every one of them will be technically unique and narratively identical. Arkada’s seven artifacts share a story that only makes sense as a set — each lore fragment is incomplete alone, and the ending only reveals itself when you’ve held all seven pieces in your mind simultaneously. This is what happens when you build a world first and make the NFTs second. The collection isn’t seven products. It’s seven chapters of a story that can only be completed by an act of faith. Your season boost in one view, rebuilt from the original dashboard. Connect X, Discord, Telegram and the Shogun NFT: each source reshapes the radar and adds to Total Boost, from +14% up to +67%. ![Arkada App — outcome, image 1](https://kalkaev.com/assets/jPOFgmiSWzTzm4FEhqyrPW8.avif) ![Arkada App — outcome, image 2](https://kalkaev.com/assets/JQ3IJbvKzzKgJOZH4XBvs2rcH4.avif) ![Arkada App — outcome, image 3](https://kalkaev.com/assets/3Qqrf3i2MP4UGCRvrAJ7xlUnR3w.avif) ![Arkada App — outcome, image 4](https://kalkaev.com/assets/OkuTMAo65CMIGG9Phdb2UDKMOxw.avif) - [Previous case](https://kalkaev.com/works/apebro) — ApeBro. DeFi with a face. - [Next case](https://kalkaev.com/works/open-wallet) — Open Wallet. The retainer became the team. --- More: [llms.txt](https://kalkaev.com/llms.txt) · [HTML page](https://kalkaev.com/works/arkada-app) · [Text view](https://kalkaev.com/agents/works/arkada-app/) --- title: "Open Wallet | Ivan Kalkaev" description: "The retainer became the team." url: https://kalkaev.com/works/open-wallet --- Open Wallet # The retainer became the team. ![Open Wallet — hero visual](https://kalkaev.com/assets/C23Dg1C3EYdo541s6n14e46vK4-w768.avif) Service · Web Design · Art Direction · Branding · Tools used · Figma · Framer · Year · 2025–2026 The first sprint ## A strong wallet that looked familiar Cold outreach through a Telegram network. First sprint: seven screens of a debit card flow. Six months later, the previous team is gone and we’re the only design function the product has. A year in, we’re speccing features that shape the company’s business strategy. 93 tasks. One retainer. No formal pitch ever. ### The cold open Mitul Manish — co-founder, CPTO — had a design problem he couldn’t name. Open Wallet was a technically solid self-custodial crypto wallet with a patented keyless recovery system, free Solana transactions, built-in bank transfers via IBAN, and a real user base north of 45,000. The engineering was strong. The product looked like every other crypto wallet: dark theme, flat illustrations, a color palette and rendering style close enough to Trust Wallet that you’d mix them up at a glance. Not bad. Just invisible. He had a team handling design. He wasn’t happy with them. Alice reached out through our Telegram network, and the timing landed. First message in the work chat, March 25, 2025: “Mitul — meet Ivan and Marie.” Mitul’s first message to us contained a sentence that turned out to be our job description for the next year: “I am not a designer.” The first sprint was modest by any measure: quick audit, card flow wireframes, clickable prototype, UI for five to seven screens. Fixed price, two-week sprint. We didn’t even have a legal entity yet — Alice invoiced as an individual. A visual opening ## Recognition had to start before the feature list ### The thing that changes the relationship Two weeks into the first sprint, before it was formally over, I wrote Mitul a message nobody asked for. Not about the card flow. About the product’s visual identity. The argument was simple: Open Wallet’s illustration style was too close to Trust Wallet. Same flat vectors, similar palette, similar rendering logic. It wasn’t hurting anything, but it wasn’t building anything either — the product had no visual signature a user would remember or a competitor couldn’t replicate overnight. I proposed a shift to 3D. More flexibility, more identity, motion-friendly assets for onboarding, a natural bridge to their planned physical cards. Mitul’s response: he personally didn’t love the current illustrations either. Felt they were disconnected from real-world objects because of how flat everything was. This was the first moment we stopped being contractors executing a brief. Nobody asked us to evaluate the visual language. Nobody put “3D exploration” in the sprint scope. We saw something we could fix, built the case, and proposed it. The second sprint already included the 3D direction as a formal deliverable. There wasn’t one clean moment where the relationship shifted. But I’d mark this as the point where the pattern locked in: we show up with ideas, not deliverables. Everything after was that pattern repeating. ### The brand that started as a website Mitul asked us to update the website. “Continue with website for the moment” — that was the brief. What we delivered was a visual identity for the entire product. He sent references he liked: family.co, phantom.com, coinbase.com/wallet, strike.me. We looked at all of them and pushed back — they felt too playful, too startup, too crypto. We’d agreed on moving Open Wallet away from that territory, and these references were pulling it right back. The concept I built started from Frutiger Aero. Not the visual language — not the reflections and transparency and gloss — but the philosophy underneath it. The reason Frutiger Aero worked wasn’t the shiny surfaces. It was the idea that technology should feel like clear sky, like open space, like something made for people with lives and errands and Tuesday mornings. That’s what I wanted for Open Wallet, stripped of the decorative layer and rebuilt for 2025. Blue sky as the visual anchor — not a dark crypto interface but a light, warm space. Real people — AI-generated at photographic quality, retouched to studio-shoot standards, each carrying an Open Wallet username, surrounded by floating UI fragments that show features in context. And usage scenarios instead of feature lists, because the point of Open Wallet isn’t that you can transfer crypto to a card — it’s what that capability lets you do with your afternoon. Same logic as buying an expensive jacket: you’re not paying for the jacket, you’re paying for how you feel wearing it. Mitul wanted a version without the people. I wrote him a long message explaining why that would gut the concept — remove the humans and you lose the story, and the site turns into a feature showcase that could belong to any wallet. We built both versions and shipped both to Framer so he could compare on a live site. Then a user sent Mitul feedback criticizing the visual direction, and Mitul forwarded it to us. I was direct: user interviews are 99% noise. The second you ask a random person what they think about a design, they step into an expert role they’re not qualified for, feel pressured to sound smart, and start inventing opinions. Bounce rates, conversions, deposits — that’s the data. Alice backed this up with a visual comparison: one design built on team instinct, one built on “best practices” and user feedback. The difference was obvious. The site shipped. Stakeholders loved it. And the visual language we’d created for a website — the sky, the people, the warmth — migrated into the app, into promo videos, into partner decks, into app store screenshots. A deliverable that started as “update the website” became the brand. From sprint to retainer ## Ideas turned a sprint into a team ### How a retainer happens Nobody plans a retainer. It shows up when the contract can’t keep up with the work. Sprint one was fixed scope, fixed price. Sprint two added hourly extras at $70/hour for requests that spilled over — card customization, Mastercard logo placement, things that didn’t fit the box. By late May, tasks were arriving faster than sprints could contain them: website, videos, moodboards, product updates, brand materials, all at once. Alice proposed the retainer — a monthly block of hours, rush fee for emergencies like the partner pitch deck we built in a day when Mitul needed it for a stablecoin meeting. He agreed immediately because the alternative was negotiating scope on every new request, and by then there were new requests every day. The shift wasn’t strategic. It was the format catching up with the fact that we were already functioning as the product’s design team — we just hadn’t called it that. ### September September 16, 2025. Six months after the first message. Mitul wrote in the chat: the previous design team was gone, Unipaws was now working exclusively on Open Wallet. “And it goes without saying how much I love working with the team.” What changed practically: everything came to us. Strategic features, country flags for forms, LinkedIn banners, production UX fixes. Daily communication with Mitul on strategy, daily communication with A G — dev/PM on their side — on operations. The scope wasn’t “design” anymore. It was whatever the product needed on any given Tuesday. ![Open Wallet — visual direction, image 2](https://kalkaev.com/assets/UQn9OUHXR9rEShocihKq1et96oM.avif) ![Open Wallet — visual direction, image 3](https://kalkaev.com/assets/IvtnjbKwPkTGixeci1u4a15OuQ.avif) ![Open Wallet — visual direction, image 4](https://kalkaev.com/assets/mrcQUHaDbtWGFljhle3sO805boo.avif) ![Open Wallet — visual direction, image 5](https://kalkaev.com/assets/abLTWK21wE9aZRdpzIxmklWLncY.avif) ![Open Wallet — visual direction, image 6](https://kalkaev.com/assets/meHcJTihcYaWbKDY2jKFzB6w7bk.avif) Beyond the sprint ## The brief grew into product strategy ### The depth that earns the scope I want to talk about the prediction markets work because it shows what a retainer makes possible and what sprint engagements can’t buy. January 2026. Open Wallet gets approval from Dflow/Kalshi to launch prediction markets. We’re asked to design the feature. What we delivered: a research study of fourteen platforms — Robinhood, Polymarket, Revolut, Coinbase, Binance, nine others — not a screenshot gallery but strategic analysis with specific recommendations. A product spec running nineteen sections. Thirteen FigJam flow diagrams with color-coded decision logic. A working React prototype. Six promo video concepts, each with its own narrative. Mitul’s response: “This is one of the main reasons we love working with Unipaws.” The key design constraint: no gambling aesthetics. Mitul was explicit. Prediction markets in a financial app can’t feel like a betting platform. We framed everything around “price equals probability” — $0.65 means 65% chance, and the interface reads as investment analysis, not a sportsbook. Neutral palette. Green and red reserved strictly for profit and loss. Nobody asked for fourteen platforms worth of competitive analysis. The brief was “design prediction markets.” But you can’t design this well without understanding how other teams solved the same problems and where they failed. The depth came from caring about whether the feature actually works for Open Wallet’s users — and the retainer is the structure that makes that kind of caring sustainable, because you’re not optimizing for deliverables within a sprint box, you’re optimizing for the product. The lending research went deeper still. Forty-plus financial products analyzed. The central finding: over-simplifying is as dangerous as overcomplicating. Users lose collateral because they don’t understand liquidation, but dense interfaces kill adoption before anyone gets that far. The solution: make the simplest path also the safest, and replace the scariest metric — loan-to-value ratio — with two things anyone understands: a color-coded health indicator and a liquidation price in dollars. The full UX schema of the lending flows, as it was drafted in FigJam. Drag to move around it and zoom in to read any branch. Against invisible wallets Open Wallet was technically strong but visually close to Trust Wallet. The opportunity was not to make another dark crypto interface; it was to build a recognizable financial product with a point of view. ![Open Wallet — research, image 1](https://kalkaev.com/assets/0fVyCR9u0UD7Lr0hDlpOpGfOQ.avif) ![Open Wallet — research, image 2](https://kalkaev.com/assets/OkNvXckoFc3X00lkazGsYHvMUcc.avif) 93 tasks later ## One language across the product ### What a year looks like Debit card flows. A website that became a brand. Partner pitch decks built in a day. KYC flows. Notification center architecture. Gasless UX fixes where “0/5” read as “zero out of five used” when it actually meant “zero remaining” — the kind of thing that only surfaces in production and only gets caught by a team watching the product after handoff. CEX swap interfaces designed revenue-first because the client said “simplicity over beauty” and we agreed, and then a debit card onboarding with 3D animations and haptic feedback because that same client also wanted magic, and knowing which context calls for which approach is the job. Off-ramp flows — ten steps from stablecoins to money in your bank account. Payment links. On-chain bank accounts. Nigeria expansion. App store screenshots redesigned after Apple rejected an update. A design system reorganized from legacy chaos into a functioning library. Ninety-three tasks. Some were a meme with Patrick from SpongeBob. One was a nineteen-section product specification. The range is the point — when you’re the design function of a product, nothing is beneath you and nothing is above you. The purchase journey next to a working prototype. Move identity verification between the entrance and the purchase, or switch to the architecture after the provider change, to see which steps stay with the user and which become system work. A face for financial tools The visual language started with blue sky, warm light, real people, and usage scenarios instead of feature lists. The goal was to give a technically strong product a face of its own. ![Open Wallet — design solution, image 1](https://kalkaev.com/assets/t6X1yVK7J3QQggRa79AOIj2u9Y.avif) ![Open Wallet — design solution, image 2](https://kalkaev.com/assets/2H8XT36ojmyrhLHZ70UhsuNTIg.avif) ![Open Wallet — design solution, image 3](https://kalkaev.com/assets/6ipnqd6rNuUjRQOxtS2igaOckCY.avif) ![Open Wallet — design solution, image 4](https://kalkaev.com/assets/bf9A2hirOGaDk27F9fddg7EE.avif) ![Open Wallet — design solution, image 5](https://kalkaev.com/assets/Tn4Rw7D85Fl3jfH5B9zkklplrr4.avif) Three decisions behind the purchase flow: artwork per sport, keeping event, market and outcome together, and treating a position as more than a balance. Pick one and the prototype opens the screen where it shows. ![Open Wallet — design solution, image 8](https://kalkaev.com/assets/NPX7NMZ6RN4BpW7effEouQ0qx8.avif) From external to internal ## An external team became the design function ### What the relationship became This case study is about what happens when an external team earns the position of an internal one. Task by task, pushback by pushback. The model is called a retainer, and the mechanics are simple: monthly hours, flexible scope, daily communication. But the mechanics aren’t the thing. The thing is treating someone else’s product as if your name were on it — and meaning it in a way that shows up at 6 AM when a pitch deck is due, or in a fourteen-platform research document nobody requested, or in a Slack message three weeks after screens shipped flagging something that doesn’t look right in production. Open Wallet went from a crypto wallet that looked like Trust Wallet to a financial product with a face of its own. That happened across a year of retainer work, not in a single dramatic moment, but through accumulation — every small decision pointing the same direction, a team that showed up every day and treated the product as theirs. It wasn’t ours. But that’s the whole point. ![Open Wallet — outcome, image 1](https://kalkaev.com/assets/BDAWlpoaIaBo2uorCstoEIILzQ.avif) ![Open Wallet — outcome, image 2](https://kalkaev.com/assets/6mQwBpz6QTjN5WzCEOJPQW9loE.avif) ![Open Wallet — outcome, image 3](https://kalkaev.com/assets/hrOQI5lONcPF0c7lviAEL0aIc.avif) ![Open Wallet — outcome, image 4](https://kalkaev.com/assets/7XBDa8AfuxOhVTCn9FpQGMBH0Y.avif) - [Previous case](https://kalkaev.com/works/arkada-app) — Arkada App. A quest platform with a second loop. - [Next case](https://kalkaev.com/works/roketo-app) — Roketo App. AI was the production pipeline. --- More: [llms.txt](https://kalkaev.com/llms.txt) · [HTML page](https://kalkaev.com/works/open-wallet) · [Text view](https://kalkaev.com/agents/works/open-wallet/) --- title: "Roketo App | Ivan Kalkaev" description: "AI was the production pipeline." url: https://kalkaev.com/works/roketo-app --- Roketo App # AI was the production pipeline. ![Roketo App — hero visual](https://kalkaev.com/assets/a2Xwgeo0yukdlXsJpNTj0IB5eno-w768.avif) Service · Web Design · Art Direction · Motion Design · Tools used · Figma · Year · 2024 Two weeks, one bet ## The visual identity had to do the marketing 2024. Everyone uses AI to generate moodboards. We used it to ship an entire product — icons, characters, backgrounds, UI elements. All Midjourney. 250,000 users in month one. ~$5,000 in marketing. The missing asset ## We could not draw, hire, or wait ### The constraint that shaped everything Sasha Isaev came to me during peak Hamster Kombat era with a Telegram Mini App that needed to attract a massive audience for his L3 chain, and the brief had a specific asymmetry that I found interesting from the start: UX could be predictable — lean on what the tap-to-earn market already trained users to expect — but the UI had to be so visually different that it could functionally replace a marketing budget. Near-zero spend on ads, with design itself being the mechanism that makes people share. Two weeks to build the first version, no existing assets beyond a landing page with some colors, and the product clearly needed illustrated characters — warm, cartoonish, personality-driven, the kind you’d screenshot and send to a friend rather than scroll past. Not stock vectors, not 3D renders. Something with soul. The problem is that we can’t draw. I’m genuinely terrible at illustration, the timeline ruled out hiring someone, and stock was out because it would chain every creative decision downstream to someone else’s asset library. So the constraint crystallized into something very specific: we need a visual identity built entirely on illustration, we can’t illustrate, we have two weeks, and the result has to be good enough to carry the entire go-to-market. That’s the box we were in. AI as production ## Every visual came from the same fight ### AI became the pipeline I’d been running hundreds of Midjourney generations a week at that point — not for concepts or moodboards, just learning the tool, its quirks, its stubbornness, where it surprises you and where it completely falls apart. The design industry at the time was treating AI generation as a concepting layer: generate something, get inspired, then make the real thing by hand. Nobody was using it as an actual production pipeline for a shipped product. I generated a few astronaut characters on a hunch — little goofy cosmonauts — and they came out with exactly the kind of naive charm the product needed, something between children’s book illustration and indie game art. We put one bouncing off the screen edges like a DVD screensaver logo, showed the concept to Sasha, and he said yes immediately. That was the bet. Not “let’s use AI to speed up our process” — let’s make AI *the* process. Every visual element in the product, from navigation icons to character illustrations to background textures to UI decorations, would come from Midjourney. The tool wouldn’t assist production. It would be production. ![Roketo App — visual direction, image 2](https://kalkaev.com/assets/OxOtzSlGCM0d7YMjzYrQiW8xw.avif) ![Roketo App — visual direction, image 3](https://kalkaev.com/assets/LhNgmDtPC9PNeSZFi0YWhRRjzRE.avif) ![Roketo App — visual direction, image 4](https://kalkaev.com/assets/4PL8PeTMQXA5zhl1xgqHANebHY.avif) Consistency by repetition ## A thousand generations became a system ### What a Midjourney production pipeline actually looked like in early 2024 No style browser, no fine-tuned style weights, no sref controls — the tool was powerful enough to generate beautiful individual images and too dumb to maintain any consistency between them, which is the single most important requirement for a product’s visual identity. My solution was brute force. I maintained a set of five or six reference images, including finished app screens, and attached them as style anchors to every single generation — every prompt carried these references, like showing up to work every morning with the same stack of printouts to re-explain the project to a brilliant artist who has amnesia. Sometimes it clicked on the first try. Sometimes the tool decided it had never seen your references and gave you something from a completely different universe. Over a thousand generations across the project. When we later added a city-building feature, I generated all the buildings in about a day — that went fast. But then there was the pickaxe. There was a tap-to-mine mechanic where you tap the screen, a pick hits a stone, loot falls out, and I needed one cartoon pickaxe — two-sided, pointy, matching the style of everything else. Midjourney gave me hammers, one-sided picks, shovels, things with teeth on one side only, and I went through style references, image references, iPad sketches, every prompting trick I knew, hundreds of attempts over several hours for a single object that a junior illustrator would sketch in fifteen minutes. But this is where the approach reveals something non-obvious. A junior illustrator would draw one pickaxe in isolation. I was building a system where every visual element came from the same generative source, and the pickaxe had to fit an aesthetic that existed not as a style guide on a Figma page, but as a statistical tendency across a thousand generations. When everything comes from the same imperfect source, the imperfections themselves become the style. It all coheres into something you genuinely cannot replicate by mixing AI-generated assets with hand-designed ones. The tool’s limitations became the product’s visual signature. Open the Cosmic Case in the phone: the pickaxe breaks the geode, the crystal opens and the reward card claims Moon Crystals. Against tap-to-earn sameness ### Why this worked in this specific market Telegram Mini Apps in crypto were — and mostly still are — visually awful, built from generic UI kits with token logos slapped on top, and the design bar wasn’t just low, it was underground. This context matters, because the 250,000 users didn’t show up because we hit some absolute quality threshold — they showed up because the contrast between Roketo and everything else in that ecosystem was so sharp that the app became remarkable in the literal sense, worth remarking on. The message people passed around in crypto community chats wasn’t about yield or tokenomics — it was “look at these funny astronauts.” The design did exactly what Sasha asked it to do: the job that money would normally do. And this virality was designed, not accidental. From day one, the cosmonauts almost never appear alone — on onboarding screens, loading states, feature illustrations, there’s always a group, multiple characters doing things together, which is a deliberate visual message that this is a social experience, bring your friends. We decided on this approach before writing a single line of referral copy. The tone of voice across the entire app was deliberately absurd, and I’d genuinely recommend opening it just to read any random notification, because things happen to the cosmonauts, they have little storylines, the notifications read like dispatches from a tiny unhinged universe, and you come back partly to check your progress and partly because you want to know what these idiots are up to now. I think about Water Llama a lot when explaining this — it’s an app where I paid for a lifetime subscription to a water-drinking reminder, a function identical to fifty free alternatives, because the camel on my Apple Watch is cute and everything makes pleasant bubbling sounds. You’re paying for a tiny world you visit for a few seconds each day. That’s what Roketo was. Drag Planets and Decode Combination as a small game: five attempts to find the winning constellation, and each Confirm tells you how many planets are right. ![Roketo App — research, image 1](https://kalkaev.com/assets/TUF43Mei71JdkZvt2LL5Ia8DC0.avif) ![Roketo App — research, image 2](https://kalkaev.com/assets/YR4DTApROiovWMLHcdR9OC4igU.avif) Teach by discovery ## Let the world explain itself ### Teaching without explaining Most tap-to-earn apps have a simple cognitive contract — tap, earn, done. Roketo had its own mechanics, its own economy, its own vocabulary: Lunar Loot, Docks, harvesting, boosts. A new user launches the app with zero framework for understanding any of it. We went the opposite direction from tutorials. The first thing the app tells you is “X Lunar Loot has been sent to your Dock,” the Dock icon glows, and you don’t know what Lunar Loot is, you don’t know what a Dock is, but you know you received something and something is highlighted. I think of this as the Morrowind principle — drop the player into an unfamiliar world and let curiosity do the teaching, where every unknown word is a hook rather than a barrier. You tap the glowing icon, it opens, explains itself, shows you how to upgrade, and now you want to know what Lunar Loot actually is, then what it’s for, and each discovery branches into the next like wandering through Skyrim and picking up quests you weren’t looking for. An unfamiliar term in a banking app is a UX failure. An unfamiliar term in a game about space cosmonauts mining lunar loot is an invitation. Stellar Stakes rebuilt in code: pick a share of your Lunar Loot, call the ETH rate up or down and see what the multiplier would pay. ![Roketo App — design solution, image 1](https://kalkaev.com/assets/uw6PTkiwLBJCoqjyEuTMSvEN4eI.avif) ![Roketo App — design solution, image 2](https://kalkaev.com/assets/WPn2ozZBR1hPK0GxCDBcgIM.avif) ![Roketo App — design solution, image 3](https://kalkaev.com/assets/2uFPntc9bYPu7JN1EUzGXSjtSoA.avif) ![Roketo App — design solution, image 4](https://kalkaev.com/assets/YUPJ2o5emUlcoK8eRaDVuPyom90.avif) ![Roketo App — design solution, image 5](https://kalkaev.com/assets/6EZ8mwkiMYOaF3ASH2gX702GhY.avif) What it did ## Design carried the launch ### The trade-offs I’d take back The leaderboard is the one that still bothers me — navigation structure was locked by the time we added it, and it ended up as an appendix, technically present but hard to reach. Animation is the biggest sacrifice. The budget didn’t allow for it, and this was the right trade-off at the time, but the product would have been substantially better with even basic motion design. It’s the most visible gap in the finished product. Geo distribution was poor — mostly Nigeria, Indonesia, users with no spending power. That’s a marketing problem more than a design one, but it affected the project’s commercial outcome regardless. ### What the pipeline left behind People started copying our cosmonauts on Dribbble and Pinterest — same characters, same poses, showing up in other people’s projects. We never pursued anyone. Felt like confirmation more than theft. This project exists at a very specific intersection of timing and stubbornness. Midjourney in early 2024 was powerful enough to generate production-quality assets and limited enough that getting consistency across an entire product required a handmade pipeline of reference images, brute-force iteration, and a tolerance for spending hours on a single pickaxe. Today’s tools would make the same project faster, cleaner, more technically refined — they’d also make it less interesting as a story, because the difficulty was the point, and the aesthetic came from fighting the tool rather than from the tool cooperating. What the project proved is that a generative AI pipeline — not as a supplement to production, but as production itself — could define a product’s entire visual identity, and that identity could be distinctive enough to replace a marketing budget in a market where everything else looked the same. That was the bet. It paid off. The Daily Rewards card as a physical object: it tilts under the cursor or with the phone’s gyroscope, and the light moves across it. ![Roketo App — outcome, image 1](https://kalkaev.com/assets/7Vr0epiz2AKi5BMW5f2Uz9GpecM.avif) ![Roketo App — outcome, image 2](https://kalkaev.com/assets/uw6PTkiwLBJCoqjyEuTMSvEN4eI.avif) ![Roketo App — outcome, image 3](https://kalkaev.com/assets/2uFPntc9bYPu7JN1EUzGXSjtSoA.avif) - [Previous case](https://kalkaev.com/works/open-wallet) — Open Wallet. The retainer became the team. - [Next case](https://kalkaev.com/works/payvda) — PayVDA App. Crypto without the chaos. --- More: [llms.txt](https://kalkaev.com/llms.txt) · [HTML page](https://kalkaev.com/works/roketo-app) · [Text view](https://kalkaev.com/agents/works/roketo-app/) --- title: "PayVDA App | Ivan Kalkaev" description: "Crypto without the chaos." url: https://kalkaev.com/works/payvda --- PayVDA App # Crypto without the chaos. ![PayVDA App — hero visual](https://kalkaev.com/assets/woVnoIqJZ9N5iz1lCRtlLjyhrg-w768.avif) Service · Web Design · Branding · Art Direction · Tools used · Photoshop · Framer · Year · 2026 Everyday money ## A crypto wallet for normal decisions ### Start with the product PayVDA started as one of those projects that look simple only if you describe them in one sentence: a crypto wallet for India and the UAE, focused first on India, with QR payments, real-time crypto-to-fiat conversion, multi-chain wallet creation and import, KYC where it actually matters, and a plan to make crypto usable around something as normal and everyday as UPI. On paper, this sounds like a product task. In reality, it was one of those cases where the interface was probably the most visible part of the work, while the real work was happening somewhere much deeper: in positioning, in trust, in tone of voice, in making a financial product feel like something a normal person could open without immediately feeling that cold little “I’m going to lose money if I tap the wrong thing” panic. ### A working relationship The founder, Robin, came to us with a fairly clear product idea and a pretty rare level of trust for a first big project. I think part of that trust came from the fact that from the very beginning I wasn’t trying to behave like a polite vendor who agrees with every idea just to keep the invoice moving. If something sounded wrong, I said it sounded wrong. If an idea felt weak, overcomplicated, or just kind of pointless, I said that too. There’s a very specific kind of relationship that forms when a client realizes you’re not only there to draw screens, but also to argue with them when the product needs it. It creates a different kind of energy in the work. Less “here is your deliverable, sir”, more “let’s actually make this thing alive and useful, even if we need to push each other a bit to get there”. ### The scope At first, the scope was app and landing page, and then the project kept expanding in the most natural way possible. Once we had the app concept, the landing page started forming around it. Once the landing page had a direction, the brand needed a more precise system. Once the brand had a system, it became obvious that social posts, ads, product storytelling, investor materials, and the pitch deck should all speak the same language. Over time, PayVDA became a pretty large design organism: brand identity, logo, colors, product UI, onboarding, wallet flows, swap, QR payments, crypto-to-fiat logic, landing page design and Framer implementation, 3D visuals, social content, ad materials, and later a pitch deck that had to explain the product to investors without turning into a boring blockchain PDF. The final product scope had 120+ product screens and a whole ecosystem of materials around the app, but the central question stayed the same the whole time: how do we make crypto feel usable for people who are not crypto people? The PayVDA mark drawn as one line, then taken apart into its layers, its joint, the lockup and the app icon. It shows how the logo is put together. The first barrier ## Crypto asked too much of new users ### The crypto category Most crypto products still look like they were designed either for traders, terminal addicts, or people who enjoy feeling like they’re entering a very expensive spaceship where every button can destroy their day. The older visual language of crypto was neon, gradients, cyberpunk-ish darkness, endless glowing graphs, and that whole “future finance cult” vibe. Then crypto started becoming more institutional, and a lot of products went in the other direction: clean fintech, banking minimalism, safe blue-and-white dashboards, everything very rational and very serious. Then another layer appeared, the tasteful designer layer, which is often just laconic minimalism with nicer typography and fewer sins. Some products managed to become genuinely memorable — Phantom, Solflare, Family — but most wallets still feel like they were designed around the assumption that the user already knows what they’re doing, or at least has enough patience to pretend. ### The everyday user PayVDA needed the opposite instinct. Its first audience wasn’t the expert crypto guy who already has ten wallets, three browser extensions, twelve tokens he forgot about, and a very developed opinion about gas fees. The interesting audience was the person who has money to send, receive, spend, move, or convert, but doesn’t use crypto because everything around it feels too technical, too risky, too weird, too easy to mess up. For India especially, this mattered a lot, because the product wasn’t trying to invent some abstract Web3 ritual detached from real life. It was trying to connect crypto to something people already understood through UPI and QR payments. The task was almost cultural before it was visual: take a mechanism from the crypto world and make it feel closer to daily payments, small business, friends, merchants, phones, receipts, cards, contacts, and all the boring-normal things that actually make financial products useful. Familiar by design ## Keep the mechanics people already know ### Anti-crypto That’s where the “anti-crypto crypto brand” direction appeared. We weren’t trying to make PayVDA look like another wallet from the same shelf. We wanted it to feel almost weirdly welcoming for the category. Bright colors, rounded shapes, physical objects, friendly characters, playful coins, a wallet icon that actually looks like a wallet, and interface moments where the product behaves less like a dashboard and more like a companion that gently shows you what just happened. The Pixar-style direction was not just some cute visual trick. It solved a real communication problem. Crypto has a trust problem, a complexity problem, and a loneliness problem. When you’re new to it, you feel like you’re alone with a system that will not forgive you. A friendly character holding a card, celebrating a successful wallet import, or guiding you through a small moment doesn’t magically solve the engineering complexity, obviously, but it changes the emotional temperature of the whole product. ### The first impression A lot of the thinking was basically: this should feel closer to Canva than Photoshop. Photoshop is powerful, incredible, deep, and absolutely capable of making you feel useless in the first three minutes if you don’t already know the logic of the tool. Canva has a completely different promise: come in, do the thing, you’ll be fine. PayVDA needed that kind of first impression. Not because the product was primitive, and not because the financial mechanics were simple under the hood, but because the user should not be punished emotionally for being new. The interface had to communicate that someone already thought through the scary parts. You can create a wallet. You can import a wallet. You can send. You can receive. You can scan. You can understand what happened. You can see the receipt. You can go back to the wallet. The product should hold your hand without making a big sentimental performance out of it. ### Familiar mechanics At the same time, we were careful not to over-invent the actual mechanics. That was important. It would have been very easy to get drunk on originality and start replacing known financial patterns with “better” ideas just because we could. But for a product like this, especially at launch, familiarity is part of the trust layer. The wallet looked like a card because people know cards. The product had clear transaction states because money needs clarity. The QR scan had to be obvious because QR payments are already a familiar behavior in the target market. We could add personality around these mechanics, but we couldn’t make the user relearn basic financial logic just so the design could feel special. A lot of our product decisions were built around this balance: keep the structure familiar enough to feel safe, then use the visual layer, motion, characters, icons, and micro-interactions to make it feel unmistakably PayVDA. The send flow in an iPhone: type an amount on the keypad, confirm with a swipe and get to the sent screen. You can go through the whole path yourself. ![PayVDA App — visual direction, image 2](https://kalkaev.com/assets/WyZKmaYX18vuNEx5d5zieRDttk.avif) ![PayVDA App — visual direction, image 3](https://kalkaev.com/assets/KFTaH51XXAE5A9yK8My9COmuM.avif) ![PayVDA App — visual direction, image 4](https://kalkaev.com/assets/ZWB5WXLRa1xtIrDZaC5WtCaUQ.avif) ![PayVDA App — visual direction, image 5](https://kalkaev.com/assets/PjWL8ApyO42WtjIozBs6gFA190.avif) ![PayVDA App — visual direction, image 6](https://kalkaev.com/assets/GUXsWWeHSdiIjsCkQvQm7RrM.avif) The PayVDA card reacts to the pointer or the phone’s motion sensor. Turn the phone face down and the balance dissolves. Product diagnosis ## Make the scary parts feel handled ### Product diagnosis One good example was the wallet dashboard. The main card could change color depending on the asset the user holds the most — green for USDT, orange for Bitcoin, and so on — so the interface could feel alive without becoming chaotic. The central glowing QR/payment button gave the app a recognizable product gesture and made the most important behavior visually obvious. The side buttons were still labeled and understandable, because clever icons alone are rarely enough when money is involved. We explored avatars for recent people and transaction entries, but kept the conversation tied to what could actually make sense in a wallet without creating a fake social layer. Even when the client wanted something more unique, a special “tadka”, as he called it, the answer was never to throw random cool visuals on top. The answer was to find places where the product could feel more ownable without breaking the mental model. ### Physical metaphors The skeuomorphic direction was probably the part I personally enjoyed the most, because it gave the product this semi-physical quality that most modern financial apps have lost. A crypto wallet is already an abstract object by default. It’s keys, addresses, chains, tokens, balances, confirmations, conversions, and a lot of invisible infrastructure. So if you want to make that world easier to enter, physical metaphors become useful again. A wallet can look like a wallet. Coins can feel like coins. A receipt can feel like a receipt. A card can look like something you can hold. These things are almost embarrassingly obvious, but that’s exactly why they work. They create a bridge between the invisible and the familiar, and that bridge matters more for first-time users than some beautifully austere list of assets in a grey fintech layout. Wallet creation in an iPhone: the three consents someone accepts before the Secret Phrase appears. Try it to see the order and the wording. ![PayVDA App — research, image 1](https://kalkaev.com/assets/dqUJ41MufDR1FL6xByOmcn2YpJg.avif) ![PayVDA App — research, image 2](https://kalkaev.com/assets/NnuWnMDbzE4YDeiZ7miTkTEwJd8.avif) Physical bridge ## A wallet can look like a wallet ### The wallet icon The app icon became the purest version of that idea. I rarely get to make an icon like this for a real product anymore, because most teams either want something flat, something logo-only, or something that looks like it belongs inside a very safe SaaS brand book. For PayVDA, I sat down and drew the icon properly in Photoshop: dark soft material, stitching, a little button, a clasp, a blue symbol that sits on top like a tactile object, everything with enough depth and craft to feel like a small thing you could almost pick up from the screen. I didn’t generate it with AI. I drew it because I wanted that level of control and materiality. I spent enough time on it that I didn’t even bill part of the hours, because at some point it was just my own stubborn desire to make the thing exactly the way I felt it should be. That icon became one of those artifacts that later people brought back to us as a reference without even realizing we had made it, which is always a funny little design-world loop: someone finds your stolen work on Pinterest, brings it to you as inspiration, and you get to say, yes, truly, whoever made this must have been a master. ### Small decisions, same direction There were plenty of small process moments that shaped the final thing. Robin asked for all-lowercase text at one point, and we talked through the trade-off because lowercase can feel more informal and chat-like, but it can also hurt readability. He asked about font directories, and I pushed back because font curation is part of the design work, and having a client choose from a list rarely leads to a better result. We discussed avatars, QR logic, merchant vs. person language, whether the scanner should be universal, how much animation freedom we had, whether Framer would be performant enough, and whether React Native made sense for the app. None of these conversations are spectacular on their own, but together they’re the real texture of product design. A case like this doesn’t become coherent because someone had one genius idea in the shower. It becomes coherent because dozens of small decisions keep pointing in the same direction. Clear paths, less density ### Landing page The landing page became its own little product theatre. We didn’t want a generic fintech landing where you scroll through hero, features, security, FAQ, done. The idea of “crypto fluidity” became the narrative backbone: flow through crypto, move through payments, scan, pay, send, receive, see clearly. The landing had a narrow active width around 960px, partly because it made responsive adaptation easier, but more importantly because it made the whole page feel mobile-first from the start. It felt less like a corporate website and more like a clean scrollable product presentation. The motion direction supported that too: elements moving upward like a scroll, the blue card and “Your Wallet” label snapping into the phone screen, the blue area expanding to fill the section, labels and arrows appearing gradually as the user moved through the story. Even the multilingual detail — English, Arabic, and Hindi dynamically writing themselves out in an Apple-style animation — was there to make the product feel native to its intended markets, rather than a generic wallet with a different country name in the strategy doc. ### Less density What I still like about the landing is that it didn’t try to prove the product through density. A lot of crypto projects overload their pages because they’re afraid that if they don’t explain every mechanism, nobody will believe them. PayVDA needed confidence in the opposite direction. Big friendly type, clear surfaces, bright cards, a phone in hand, QR logic, coins floating around, characters peeking in from the edges, and enough copy to understand the value without turning the page into a whitepaper. The product already had enough complexity inside it. The website’s job was to make the whole thing feel light enough to approach. A few live pieces of payvda.com: the self-writing word in English, Arabic and Hindi, the floating objects and the chain coins. Icons, receipts, and onboarding ### Onboarding The onboarding followed the same idea of being simple without feeling empty. There was no need to explain the entire crypto universe in four screens. The screens had to do something much more focused: create the right first emotional contract. Welcome to PayVDA. Manage your crypto assets in one place. Send, receive, and swap with ease. Stay in control of your keys and funds. Create or restore a wallet in a few taps. That’s it. The illustrations carried part of the weight, because they made the flow feel friendly and complete without dumping text on the user. The success modal with the girl celebrating the imported wallet is a good example of the tone we wanted. It treats a small technical step like a little achievement, because for a new user, importing a wallet can actually feel like one. The product says, basically, “you did it, everything is okay, let’s continue”, and that is a much better emotional state than “here is your address, good luck”. ### Pitch deck The project also had a very strong narrative layer through the pitch deck. That part was especially important because at some point the product needed to become investor-showable faster and cheaper than building a full production app. Token2049 Dubai was part of that urgency, and the deck had to explain PayVDA as a serious opportunity without killing the friendly tone we had built. Alice led a lot of the writing and structure there, and I still think it became one of the strongest decks we’ve done as a team. It had a clean linear logic, the right amount of product story, and a way of presenting the market and the use case that didn’t feel like another crypto deck about abstract adoption. Later, when the deck was refined, we even prepared separate drafts for India and the UAE and reworked the storytelling flow while keeping the same PayVDA voice. That mattered, because by then the brand had already become specific enough that you could feel when a slide belonged to it and when it didn’t. The four real onboarding screens in an iPhone. Swipe or tap through them. ![PayVDA App — design solution, image 1](https://kalkaev.com/assets/LzGpC7rIThxdwNCWLGuT7Q6oYHw.avif) ![PayVDA App — design solution, image 2](https://kalkaev.com/assets/PVZ6ea4lX6TqgunhWknS2GCmo.avif) ![PayVDA App — design solution, image 3](https://kalkaev.com/assets/Vi88rFHNlUnq4KZ2Y2FIWdedio.avif) ![PayVDA App — design solution, image 4](https://kalkaev.com/assets/41wiDPMAsNLAC8m6EwT9NWikUM.avif) ![PayVDA App — design solution, image 5](https://kalkaev.com/assets/vXHmPzrtBDc9jPyhYyhrKMtze9A.avif) ![PayVDA App — design solution, image 6](https://kalkaev.com/assets/Eti2alC3f2n1SriBrmXuAJU1s7U.avif) ![PayVDA App — design solution, image 7](https://kalkaev.com/assets/tocHrMUIvJHnrXkJTMsDQO9oU8.avif) From wallet to deck ## Wallet, brand, and deck in one language ### Make crypto usable And the direction was clear: make crypto feel less like crypto, without hiding what it is. Keep the mechanics real. Keep the product useful. Keep the user in control. But remove the feeling that they’ve accidentally opened a professional tool for someone else’s world. That’s why the project worked as a system. The wallet, the icon, the landing page, the characters, the ads, the social posts, the pitch deck, the product language — everything was orbiting the same central idea. PayVDA was a crypto wallet designed for people who actually have everyday reasons to move money, but don’t want to become crypto-native just to do it. ### A world around it Looking back, the thing I like most is not one particular screen, although there are plenty of screens and scenes I still love. I like that the project produced a whole set of visual artifacts that feel alive outside the app itself. The icon stands on its own. The landing has its own rhythm. The wallet screens have their own product logic. The success modals and receipts feel like little moments, not placeholders. The pitch deck has a narrative spine. Even the social content had a direction beyond “post some pretty stuff”. That’s rare, because many product projects become a pile of well-designed surfaces with no atmosphere between them. PayVDA had atmosphere. It had a world. ### The trust to build it It also had the kind of trust that makes this work possible. Robin didn’t just buy screens from us. He let us argue, recommend, push back, make the project friendlier than the category usually allows, and build a product image that was unusual for crypto without becoming unserious. That’s probably why the project stayed coherent even as the scope expanded from app and landing into brand, visuals, content, pitch materials, and development conversations. The core never changed. We were building a wallet that could bridge crypto and everyday payments, but the design challenge was bigger than that: we were translating an industry that loves complexity into a product language that could survive first contact with normal people. ![PayVDA App — outcome, image 1](https://kalkaev.com/assets/PfS7leSNFozi2juPz3ZthEY0Rdk.avif) ![PayVDA App — outcome, image 2](https://kalkaev.com/assets/DPQcE5O6u6lriYR50zvePETNY.avif) ![PayVDA App — outcome, image 3](https://kalkaev.com/assets/fAQh2jvu13nX63G6oxnOCtKgyhc.avif) - [Previous case](https://kalkaev.com/works/roketo-app) — Roketo App. AI was the production pipeline. - [Next case](https://kalkaev.com/works/vibe-skills) — Vibe Skills. A landing page in one take. --- More: [llms.txt](https://kalkaev.com/llms.txt) · [HTML page](https://kalkaev.com/works/payvda) · [Text view](https://kalkaev.com/agents/works/payvda/) --- title: "Vibe Skills | Ivan Kalkaev" description: "A landing page in one take." url: https://kalkaev.com/works/vibe-skills --- Vibe Skills # A landing page in one take. ![Vibe Skills — hero visual](https://kalkaev.com/assets/W0EGqxb6UiR44mMTOkNLFR1g-w768.avif) Service · Web Design · Branding · Art Direction · Motion Design · Tools used · Figma · Year · 2025 Starting with a kit ## A course platform that refused the catalog look 2025. AI education platform. Brief said “make us a Skillbox.” I went to buy cigarettes, came back, drew the whole concept in one sitting, and that concept is now the reason three unrelated clients knocked on our door. An American startup, a Swedish fintech, and an American infra company — all from this one landing page. ### The kit we never opened Taras and Sergey were building an online school for vibe coding, vibe prompting, vibe whatever — teaching non-technical people how to actually work with AI instead of just watching YouTube videos about it. Their references were Skillbox and Zegocloud, their brief lived in a Notion doc, and their explicit request was to buy a UI kit and slap a landing page together from it. We bought the kit. Sigma UI, cheap, decent enough. And then I went to buy cigarettes, came back, sat down, and in a few hours drew a concept that made the kit irrelevant. Everyone looked at what came out, looked at the kit, and decided to eat the extra complexity in exchange for something that didn’t look like it was assembled from a catalog. The kit stayed in the Figma library like a reference book nobody opens after the first week. This happens with me more than it probably should — I draw most concepts on the first try, not because I’m guessing right, but because fifteen years of projects don’t evaporate when you open a blank file, they sit behind your eyes and answer the brief before your conscious brain has finished parsing the Notion doc. I’ve had projects where the first concept gets torn apart and we iterate for weeks. This wasn’t one of those. The concept landed, Taras approved, and what shipped is what I drew that afternoon with minor adjustments to particle density because Danila thought the original looked like Windows 7 wallpaper, which — fair enough, if you squint and have no taste, I suppose you could see it. A market of clones ## Skillbox was the category default ### CIS design is a visual disease I need to explain something about the CIS online education market, because without this context the design decisions don’t make sense. Skillbox, Practicum, SkillFactory, every platform in this space — they all look the same. Flat vectors, clean in that way where clean actually means empty, a color palette that could belong to any of them because it doesn’t belong to any of them specifically. You could swap their logos and it would take a week for anyone to notice, and that’s being generous. We told Taras and Sergey this in roughly those words, minus some of the profanity that tends to accompany my design opinions. The pitch was simple: if you build something that looks like Skillbox, you’ll compete with Skillbox on content and price, and you’ll lose, because they have more content and lower prices. If you build something that looks like nothing else in this market, you compete on a dimension where nobody else is playing. They agreed, partly because the argument made sense and partly because the concept I’d already drawn was sitting right there looking better than anything Skillbox ever shipped. One afternoon ## Draw the direction before the page ### The wide-angle trick We have a style that shows up across our projects — soft lighting, physically correct shadows, materials that feel like they have weight and texture rather than being flat shapes on a screen. For Vibe Skills, that foundation fused with something I’d been wanting to try: cinematic wide-angle perspectives with heavy lens distortion, the kind of shots you see in films where the landscape stretches and bends toward the edges of the frame and everything feels enormous even though the central figure is tiny. The distortion does something very specific — it makes the scene feel like a place you could walk into, not a banner you’re scrolling past. Low perspective, rolling hills, an enormous open sky, a lone figure walking forward, and these luminous technological particles scattered through the air like data that somehow became visible. The figure is small but sits dead center of the composition, so despite the scale of everything around them, your eye knows exactly where to land. Perplexity was the closest existing reference point, that sense of intelligence presented through spacious, confident design — but Perplexity goes cosmic and nocturtal, all dark backgrounds and starfields, and we went the opposite direction. Daylight. Earth. Grass under your feet and sky above your head and technology as something that lives in this world rather than replacing it. The keyframes were generated in Midjourney, because at that point in spring 2025 nothing else could handle compositions this painterly — Nano Bana couldn’t do atmospheric art direction at this level, and Midjourney was still untouchable for this specific kind of imagery. The hero video on the landing page came from Runway, which was the best option for cinematic scenes with depth and atmosphere, while Kling at the time was better for rotating 3D objects and interface animations but would have butchered something like this. The video has problems that I deliberately left in. Character consistency across scene cuts was shit — we faked our way around it with operator tricks, showing the figure from the back in one shot, close-up in another, never repeating the same angle across separated scenes because that’s exactly where the AI inconsistency would be most visible. Kling 3.0 or Ominni would produce something technically cleaner today, and I could regenerate the whole thing in an afternoon. I won’t. The video is an artifact of what the tools could do in spring 2025, made with those specific constraints, and I think that’s more interesting than a perpetually polished showreel — the same way I didn’t go back and update Roketo’s Midjourney assets when newer versions dropped. The work is the work, made when it was made, with what existed at the time. The Midjourney keyframes and Runway Gen-4 clips behind the wide-angle look, drifting on three ribbons at their own pace. Drag them, or open any frame. ![Vibe Skills — visual direction, image 3](https://kalkaev.com/assets/yJ0ilquDW0xoqkt39JW3XQVCY.avif) ![Vibe Skills — visual direction, image 4](https://kalkaev.com/assets/wVdgfdqOIFJhxghoGljUvBHXuM.avif) A visual argument ## The world became the research ### Everything else that shipped The landing page went to Webflow — our developer built it, which meant we controlled animations and interactions directly instead of writing specifications that a separate dev team would inevitably misinterpret. Hero section with the video, a social proof ticker running early adopter quotes for trust (because when you’re a new platform with no track record, you need something human moving across the screen to compensate), an animated chat widget that simulates a real AI conversation, course cards, pricing. Marie designed the course page template, and the important decision there was making it deliberately boring. Not visually boring — structured. Content-heavy, text-forward, no parallax bullshit, no scroll-triggered animations that make you wait three seconds to read the next paragraph. People on a course page are there to decide whether to give you money, and the last thing you want is a beautiful animation standing between them and the information they need to make that decision. This is something I keep having to explain to clients who want every page to look like an Awwwards submission — sometimes the most effective design choice is restraint, and course pages are one of those times. The Russian version got treated as a separate design effort because I refused to let it be a direct translation with Cyrillic swapped in. Different typographic choices, slightly adjusted layouts — the goal was for it to feel like a localized product, not a downgrade. We had a whole argument about whether to write “вайб” in Cyrillic or keep “vibe” in Latin. I pushed for Latin, Sergey pushed for Latin, Danila thought Cyrillic looked like TikTok branding, and in the end Latin won because it reads as a brand name rather than a borrowed word. We also did their course presentation templates for the actual educational content — slide decks that students would sit through — and this was a small scope addition that mattered more than it looked on paper, because if the website feels like one brand and the course materials feel like a different one, the whole experience fractures. Spacing, hierarchy, consistent use of the type system, consistent visual language in the illustrations. A student should feel like they’re inside the same world from the moment they hit the landing page to the moment they’re watching a lecture, and that continuity is built from unglamorous decisions about margins and font weights that nobody notices unless you get them wrong. The same course page in English and Russian. Russian copy runs longer, so lines re-break and every block below settles into its new place. A brand that travels ## One system from landing to lesson ### The first mark First round of logos: rejected, completely. Sergey’s exact words were something like “nothing clicked,” and the team wanted a mark that would work in a square format for social avatars and icons. Fair request, and the first batch didn’t answer it. Second round came the next day — new directions, new geometry, and they picked the final mark immediately. It’s a faceted diamond shape that reads as a V, works on any background, scales down to a favicon without losing legibility, and has this quality of dimensionality without being literally 3D, like a gem cut from light rather than modeled in Cinema 4D. That last part matters because the whole visual language of the project sits in this space between flat and three-dimensional — things that feel physical, have weight and light interaction, but aren’t rendered objects. The logo had to live in that same uncanny middle ground or it would have looked like it belonged to a different brand. The course player, built on the landing’s system. Completing a lesson moves through progress, the module list and the next step; the last lesson of a module closes it and opens the next one. Inter meets Editorial Inter for body and headlines, PP Editorial New Italic for accents and display. The serif italic against the clean geometric sans-serif does something I still find genuinely hard to articulate — it feels editorial and technological at the same time, like a magazine about the future written by people who actually live there rather than people speculating about it from 2019. This specific pairing is what caught the Swedish fintech. They found us through this project, and these are not playful people — bank-adjacent, regulation-heavy, the kind of company where you’d expect them to want Helvetica and navy blue and nothing that could possibly offend a compliance officer. Instead, they wanted what we did with the typography on Vibe Skills, that same energy, applied to their product. The American startup came through the same door, and most recently an American infrastructure company — all three saw this project and decided they wanted to work with whoever made it. I keep thinking about the Sigma UI kit sitting unused in that Figma library. It would have been faster. It would have been cheaper. And nobody would have come looking for us afterward, because a landing page assembled from a kit looks like a landing page assembled from a kit, and the world has enough of those. ![Vibe Skills — design solution, image 1](https://kalkaev.com/assets/64jWkbq8eKAMROLdLKiAcZ3mUE.avif) ![Vibe Skills — design solution, image 2](https://kalkaev.com/assets/MoMzqxBenjRlRDIGsjq5gWo8Vg4.avif) ![Vibe Skills — design solution, image 3](https://kalkaev.com/assets/hIJXXLxU4aHtgjGf1qOXrqCsdAM.avif) ![Vibe Skills — design solution, image 4](https://kalkaev.com/assets/a4LDWvqf863PaIfZxEHWnHp63dE.avif) ![Vibe Skills — design solution, image 5](https://kalkaev.com/assets/DKlZr5hS2ZnXOgWlxUbSVFkzss.avif) ![Vibe Skills — design solution, image 8](https://kalkaev.com/assets/TDDP14EsqNE5e8hVEnhJ0x07t8.avif) The door it opened ## A three-week concept became a door ### The three-week artifact Brief to shipped website: about three weeks, including the landing page, course page template, brand guidelines, logo, Webflow build, and presentation templates. The concept that drives all of it was drawn in a single sitting on a single afternoon. I don’t think this is a story about speed, even though the speed is the most visible part of it. It’s a story about what sits behind the speed — every project before this one, every visual decision that worked and every one that didn’t, every argument about typography and every time a client said “nothing clicked” and I went back and drew something better the next day. All of that is in the room when I open a new file, and sometimes the brief hits it at exactly the right angle and the whole thing comes out in one take. This was one of those times. - [Previous case](https://kalkaev.com/works/payvda) — PayVDA App. Crypto without the chaos. - [Next case](https://kalkaev.com/works/ez-wallet) — EZ Wallet. A wallet grew into a payment system --- More: [llms.txt](https://kalkaev.com/llms.txt) · [HTML page](https://kalkaev.com/works/vibe-skills) · [Text view](https://kalkaev.com/agents/works/vibe-skills/) --- title: "EZ Wallet | Ivan Kalkaev" description: "A wallet grew into a payment system" url: https://kalkaev.com/works/ez-wallet --- EZ Wallet # A wallet grew into a payment system Service · Product Design · Art Direction · Branding · Tools used · Figma · Year · 2026 Overview ## Building a portfolio that feels less like a showcase and more like a conversation. A customer follows a payment link from a chat. They want to pay for a booking, support a creator, or buy access to a course. Somewhere along the way, they may need to verify their identity, use a bank card, or connect a crypto wallet. EasyWallet had to connect those steps without losing the reason the customer came there. What started as a wallet brief grew into a broader design project: a wallet, a payment layer, a merchant interface, and a brand that had to work across all of them. Challenge ## My role I was the project's art director and the stakeholder for the design side, working with designers and a project manager. My role was direction and review within that team. The interface design was a collaborative effort. As the scope expanded, the design had to accommodate new payment scenarios, external providers, and a clearer distinction between two related products: Wallet and Pay. Approach ## Work out the product before choosing its look The first detailed brief arrived as a Miro diagram. We started with rough black-and-white prototypes to establish the sequence of actions and the states each screen needed. Small questions had consequences across the product. Could someone connect several wallets at once? How much transaction history did the first version need? What belonged in the developer section? We kept the first version focused. Connecting a new wallet would replace the previous one. Transaction history would distinguish incoming and outgoing payments without adding statement downloads. The developer area would concentrate on keys and documentation. The main desktop flow took shape as a set of prototypes. That gave us a common structure to discuss before we introduced colour, illustration, or motion. We then developed two visual directions. When the client asked why the concept did not yet show every scenario, including buying crypto, we clarified the distinction: the prototypes covered the product logic; the concept demonstrated the visual language we would apply across it. Keeping those stages clear helped us discuss the right decision at the right time. Visual Direction Research ## Keep the reason for paying on screen The payment layout put the action in one column and its context in the other. The customer could keep seeing who they were paying and what the payment was for while moving through the process. That second column also gave the product room to adapt to different merchants. A creator's page could use a portrait and an expressive background. Another business could use a more neutral treatment. The payment controls retained a consistent structure. We also designed a simple explanation of the money's route: the customer, EasyWallet, and the recipient. Someone arriving from a familiar chat or website was suddenly inside a different service. The interface needed to explain where they were and why this service was part of the payment. The same thinking continued into the smaller states. The top-up flow showed the choice between a bank card and crypto, including the relevant network and connected wallet. The confirmation used a receipt-like object to make the amount and recipient easy to recognise. Later iterations reduced the technical detail on completion screens to the information the customer actually needed. The aim was to keep each step connected to the original purchase, even when the mechanics underneath became more complicated. Competitor Analysis Design solutions ## Design the joins between services Buying crypto with a bank card depended on an external provider. Identity verification introduced another interface, another set of rules, and another possible break in the flow. We investigated SumSub and Banxa to understand the experience a customer would encounter: which screens could be styled, where the product would hand over to another service, and what would happen afterwards. While provider decisions were still open, we continued designing the parts of the product that did not depend on them. Demonstration flows made those questions concrete. In the car-rental scenario, a customer followed a payment link from a chat, uploaded identity documents, took a selfie, supplied a driving licence, and proceeded to payment. We separated the checks into individual steps and placed short video instructions between them. The final action returned the customer to the chat, closing the loop with the merchant. The retail demonstration had a different shape. A member of staff entered the amount, the customer chose a card or crypto, and the crypto route generated a QR code to scan with a wallet. The terminal then displayed a receipt animation. These prototypes let us examine the transitions in context. The important design question was what the customer needed to understand at each handover, from the merchant's environment through verification and payment and back again. Outcome ## Let the brand grow with the product Both visual concepts moved away from the dense, dark appearance associated with crypto tools. The product was intended for people whose main interest was sending or receiving money. The first direction used dimensional buttons, crystals, coins, soft dividers, and small physical metaphors. The second was flatter and more graphic, with black typography, drawn shadows, patterns, and confetti. The client chose the more dimensional direction. As the scope widened, the early identity needed another look. Its purple palette and crystal motif had become closely associated with the initial creator-focused scenarios. The product now had to make sense for other kinds of business as well. The distinction between Wallet and Pay made this more important. Wallet covered balances, transfers, and assets. Pay covered the payment layer, including a scenario where the customer paid by card and the recipient received crypto. They needed a shared identity with enough flexibility to distinguish their roles. I initially argued for keeping the familiar EasyWallet spelling because it was easy to hear, remember, and search for. Merchant referrals and direct links made that concern less decisive, and the naming exploration continued towards EEZY Wallet. Later, I rejected the first compact-symbol proposals and asked for another iteration. We needed a square mark that could work as a logo, favicon, and potential app icon. The wallet direction eventually moved towards a more universal symbol, leaving room for Pay to develop a related identity of its own. ## Carry the same logic through the whole product The work extended into the everyday parts of the wallet: balances, top-ups, connected wallets, transaction history, sending funds, notifications, and purchased assets. For merchants, we prioritised readable figures and short summaries over a dashboard full of charts. The immediate task was to understand the state of the business. Empty states also needed to move the user forward: a wallet without transactions could suggest a first operation; an attempt to send from an empty balance could lead to a top-up. New requirements changed the order of work. A responsive web version became a priority, followed by a simple NFT view required by a payment partner, before further work on the payment flow and merchant tools. Mobile was a web adaptation of the same product, with its own layouts and states. By the later stages, the design work covered desktop and mobile interfaces, payment and verification flows, merchant tools, prototypes, presentation demos, and branding. The desktop work had reached a point where developers could begin implementation, with subsequent screen sets reviewed for the same purpose. That is the scale of the project: a connected set of product decisions, carried from the first rough flows into detailed interfaces. Art direction had to keep those parts coherent while the definition of the product kept changing. - [Previous case](https://kalkaev.com/works/vibe-skills) — Vibe Skills. A landing page in one take. --- More: [llms.txt](https://kalkaev.com/llms.txt) · [HTML page](https://kalkaev.com/works/ez-wallet) · [Text view](https://kalkaev.com/agents/works/ez-wallet/) --- title: "AI-agents are the new type of users | Ivan Kalkaev" description: "AI agents now read pages, click controls and fill forms on people's behalf. What product design has to add beyond the pixels so both humans and agents can use it." url: https://kalkaev.com/writings/ai-agents-are-the-new-type-of-users --- # AI-agents are the new type of users May 21, 2026 · 29 min read For most of the web’s history, digital product design had one obvious user in mind: a person in front of a screen. The screen had to work for eyes, fingers, attention span, memory, impatience, habit, fatigue, and all the little mistakes people make when software asks too much of them. That job hasn’t gone away. Most products still have plenty of work left there. The new thing is that another operator is now present in the chain. A person gives an AI agent a goal, and the agent starts doing the boring middle part: reading pages, opening files, clicking controls, filling forms, calling tools, comparing options, writing into tables, and stopping when it needs confirmation. The person still owns the intent and the responsibility. The agent is just the executor. Still, in the day-to-day mechanics of the product, it behaves like a user. OpenAI describes ChatGPT agent as a system that can use a virtual computer, work with websites, and operate on connected data. Anthropic’s computer use docs describe Claude interpreting screenshots, clicking coordinates, typing text, and pressing keys. Google’s web.dev article on agent-friendly sites already treats delegated user tasks as a live web design problem. The category has left slideware and entered production. Agents are already operating ordinary products, often through interfaces that were never built to be read by anything except a human who can squint and infer the missing structure. That is the frame I find useful: design now has to cover the screen a person sees and the computable layer an agent can act on. Intent, actions, permissions, state, risk, result, and error all need to exist somewhere other than the pixels. The word “agentic” makes this sound more mystical than it is. Most of the work is inventory, semantics, contracts, and permissions. Dry stuff. Which is usually where the real product architecture lives. ## 1. The design problem has moved under the interface The old interface question was whether a person could understand what to do next. That is still the first test. The second test is whether an agent can extract what exists on the page, what changed, which actions are available, what it is allowed to do, and what will happen after it acts. A polished card can still be useless to an agent. The product image looks good, the price is visually balanced, the buy button sits in the right place, the hover state is tasteful. Underneath, the name may have no clear link to the price, the variant may be implicit, the button may have no accessible name, and the availability state may be just a color. A person glues those pieces together with visual memory. An agent needs the relationship to be present in the structure. This is where a lot of modern UI starts to look fragile. Custom controls, decorative wrappers, icon-only actions, hover-only explanations, motion-heavy state changes, modals stacked over modals, PDFs used as data containers, and tables rendered as images all make sense in a certain visual culture. They also ask the agent to reconstruct the product model from clues. Sometimes it will manage. Sometimes it will click the wrong thing with great confidence. ![AI-agents are the new type of users](https://kalkaev.com/assets/zNeXHf58YDQh94QQuVVZ2tQX4o.avif) ## 2. Agents read signals, not taste An agent using a browser does not experience a website as a person does. Even visual browsing is mediated through screenshots, model inference, DOM structure, accessibility trees, text extraction, browser tools, APIs, and any direct actions the product exposes. Google describes three main channels: screenshots, raw HTML, and the accessibility tree. Screenshots help with spatial cues, but they are slow, token-expensive, and brittle. HTML gives nesting and document structure. The accessibility tree gives roles, names, states, and relationships in a form originally built for assistive technology. Agents often combine these channels because each one fails differently. A button drawn in Figma still needs a button role in the page model. A product list needs real product objects rather than a row of cards separated by spacing. An error needs to be tied to the field it explains. Price, date, availability, risk, permission, and confirmation status need to be readable facts. Accessibility matters here for the same reason it has always mattered, plus one more. WCAG 2.2, semantic HTML, accessible names, logical source order, focus handling, and properly connected form errors make products usable by more people. They also make products easier for agents to parse. I do not love that some teams need the agent argument to take accessibility seriously, but fine. Take the win and fix the markup. ## 3. Three layers of agent access Agent access will live across three layers for a while: visual interpretation, structural interpretation, and direct capabilities. Old sites will be operated through screenshots and clicks. Better sites will be read through semantic HTML, accessibility trees, and structured data. Mature products will expose actions through APIs, MCP, WebMCP, commerce protocols, and capability catalogs. The visual layer is the most human-like and the easiest to break. A screenshot gives the agent clues about hierarchy, grouping, and state, but layout shifts, overlays, animation, tiny hit areas, ambiguous icons, and delayed loading all raise the failure rate. Screenshot use is useful as a fallback. Treating it as the main integration path is expensive theater. The structural layer is where HTML, DOM order, accessibility roles, accessible names, states, and relationships start doing useful work. Chrome DevTools already lets teams inspect the accessibility tree, computed accessibility properties, ARIA attributes, and source order. That tooling was not made for AI, and it does not need to be. It already exposes the same kind of structure agents need. The direct capability layer is cleaner. The agent stops imitating a person with a mouse and calls a product action: search flights, create a support ticket, fetch orders, prepare a payment, reserve a slot, draft a message, cancel a subscription. MCP gives model applications a standard way to connect to tools and data. WebMCP, in Chrome’s early browser work, lets a site expose page-level actions to a browser agent. The standards will move around. The direction will not: agents need callable actions with constraints, not nicer guesswork. ## 4. Where ordinary interfaces break Icon-only controls are the easy example. A person can read a cart icon, a pencil, a trash can, a heart, or a three-dot menu from context. An agent may see an unnamed button, an unlabeled graphic, or nothing useful. The damage gets worse when the action deletes, pays, publishes, sends, or cancels. Custom controls create the same mess with better CSS. MDN’s advice is plain: use the correct HTML element for the job. Native buttons already carry keyboard behavior, focus behavior, and activation semantics. A clickable div can look fine while failing as a button in the accessibility tree. If a team adds role=”button”, it has promised to implement the rest of button behavior. Plenty of interfaces make that promise and then quietly break it. Visual grouping without structural grouping causes subtler errors. A product card may look like one object, while the title, price, rating, discount, image, variant, and buy button are scattered across unrelated nodes. The person reads proximity. The agent needs an object relationship: this price belongs to this product, this discount expires at this time, this button applies to this variant, this shipping estimate depends on this address. State often disappears into styling. Loading, selected, unavailable, failed, saved, pending confirmation, completed. If those states live only as color, icon swaps, spinners, or nearby text, the agent can double-click, proceed too early, miss a failed save, or act on stale data. The same weakness annoys people too, which is the funny part. Agent readiness often exposes ordinary bad UI hygiene. Hover text, tooltips, carousels, image text, PDFs, and modal layers can carry supporting detail. They are bad places for conditions that change the decision. Shipping fees, medical disclaimers, cancellation terms, compatibility notes, legal consequences, and last-step payment warnings need a more stable home than a tooltip. Security is the sharper edge. OWASP treats prompt injection as one of the main LLM application risks. OpenAI has written about malicious instructions hidden in web pages, emails, comments, and documents. An agent that reads external content and can act on private data is exposed to instructions the user never gave. The more power the agent has, the less acceptable it is to let arbitrary page text steer the workflow. ## 5. Semantics before visual improvisation The goal is to keep the visual richness while moving meaning out of pixels alone. Human interface design works with visual hierarchy: size, color, rhythm, grouping, contrast, state, and motion. Agent-ready design adds another hierarchy underneath it: role, name, relationship, permission, risk, consequence, reversibility, result. Every visual fact that affects a decision should have a machine-readable twin. If the screen shows $29.99, the system should know amount, currency, tax status, availability, and validity window. If the UI says “last ticket”, limited availability should exist as state. If a button pays for an order, the action model should know the order, amount, payee, permissions, confirmation requirements, and side effects. A good interface can still look like a normal human product. It just has a computable skeleton. That skeleton is where the agent understands what the screen means. ## 6. What teams can fix now Use native HTML before inventing clever controls. Buttons, links, fields, headings, lists, and tables should be exactly those things unless there is a real reason to do otherwise. ARIA is for describing complex widgets when native elements are insufficient; it is a bad cover story for broken markup. The WAI-ARIA Authoring Practices Guide is useful because it treats role, state, property, and keyboard behavior as one contract. Accessible names should be written like product copy. A visible label can be short, but the accessible name needs enough context where ambiguity exists: add Bialetti Moka Express 3 cup to cart, remove shipping address, open delivery settings, compare this plan, cancel booking. That helps screen reader users, keyboard users, agents, and regular people who are tired of guessing which identical “More” link belongs to which row. Forms need labels, hints, validation rules, and errors tied together. Required, invalid, disabled, saved, loading, and success states should exist in the structure rather than in color alone. Source order should follow the product logic, not the visual hack that made the grid easier to style. If a card looks coherent but the source order mixes content across several objects, the agent has to rebuild the model using layout residue. Do not hide critical information in hover states, modals, image text, or PDFs. If a fee, rule, deadline, risk, or restriction changes the action, make it structured. Each meaningful action should also return a clear result: what happened, when, which object or reference ID was created, what can be undone, and what still needs a person. CAPTCHA is a blunt instrument. It blocks malicious automation and useful delegated agents at the same time. Products that want agent access need narrower controls: agent identity, scoped permissions, rate limits, human confirmation, and visible audit logs. Google’s Web Bot Auth experiment points in that direction with cryptographic request signing for bots, so sites can distinguish declared identity from spoofed headers and IP addresses. ## 7. Structured data is no longer just SEO plumbing [Schema.org](https://schema.org/)used to sit in the SEO bucket for most teams. Add product schema, maybe get a rich result, move on. That framing is too small now. It gives a shared vocabulary for Product, Offer, Event, Organization, Place, FAQ, HowTo, Review, AggregateRating, BreadcrumbList, Action, potentialAction, and EntryPoint. Google Search Central describes structured data as a standardized format that helps classify page content. Agents need the same kind of clarity, only with more pressure on correctness because they may act on the result. A product should be represented as a product. A date should carry timezone when that matters. A price should include amount and currency. An address should be structured. An action should include consequences. If JSON-LD says an item is in stock while the visible interface says it is unavailable, the agent may prepare the wrong order. For a person, that is annoying. For an agent, it is a system error with a polite tone. ## 8. Documentation is part of the interface now The llms.txt proposal is a useful signpost even if it is still a practical initiative rather than an RFC-grade standard. It puts a Markdown file at the site root with a curated map of useful pages, instructions, and links to cleaner machine-readable resources. The underlying idea is right: agents need compact, current, high-signal entry points. Cloudflare’s 2026 Agent Readiness work looks at discovery, content, controls, and capabilities, including Markdown content negotiation, API Catalog, MCP Server Cards, OAuth discovery, and WebMCP. Their scan found robots.txt almost everywhere and newer agent-facing standards barely anywhere. That matches the state of the web. Most sites still assume a browser and a search crawler are the only serious readers. Agent-facing documentation should describe product capabilities, core entities, current canonical links, restrictions, usage rules, common workflows, versions, deprecated features, migrations, and available machine interfaces such as OpenAPI specs, MCP servers, and API catalogs. Stale documentation needs dates and context. A person may notice a deprecation warning. A model may copy the old integration path and run it with full confidence, which is how a small docs problem becomes a support ticket with teeth. ## 9. Actions need their own architecture Button labels are the surface. The product’s action model is the thing underneath. Every meaningful action should have a name, inputs, preconditions, permissions, side effects, reversibility, confirmation rules, result shape, audit behavior, and machine-readable errors. “Buy product” is a chain: select product, select variant, check inventory, calculate delivery, apply discount, show final price, get confirmation, create order, initiate payment, return receipt, expose cancellation or support. Human UI often hides that chain behind screens. Agentic systems need enough of the chain exposed to delegate safely. Otherwise the agent clicks like a person while lacking the human’s contextual intuition and without a stable way to know whether it understood the consequence. Mature products will keep a human representation and an agent representation of the same model. The human one is visual, explanatory, emotional, decision-oriented. The agent one is structured, scoped, auditable, and fit for direct action. If the two disagree, the product has a bug. The user may not see it immediately, but the agent will eventually find it. ![AI-agents are the new type of users](https://kalkaev.com/assets/jRtQkHzAaveBGwPG4McOz6gL60g.avif) ## 10. API, OpenAPI, API Catalog, MCP, WebMCP Direct APIs are the cleanest path when precision matters, but an API sitting in a developer portal is not enough. The agent has to discover it, understand it, authenticate to it, select the right operation, pass valid arguments, and recover from errors. OpenAPI 3.2 gives teams a language-agnostic description of HTTP APIs that humans and computers can read without source code or traffic inspection. RFC 9727 api-catalog adds a predictable discovery point at /.well-known/api-catalog, where a publisher can expose API descriptions, purposes, policies, and endpoints. MCP gives model applications a standard way to call tools and read data. WebMCP helps a web page expose page-specific capabilities to a browser agent during a visit. The practical artifact is a capability catalog. The agent does not really want POST /orders; it wants to create an order draft for the current user, get an estimated total, cancel an order that has not shipped, prepare payment, or request human confirmation before execution. Those are different product actions with different risk levels. ## 11. Delegation without handing over the account The worst version of agent access is simple and terrible: the agent logs in as the user, keeps the session, and clicks whatever the account can click. This will happen during the transition because it is easy. It is also a weak architecture. Permissions are too broad, delegation is vague, revocation is messy, audit trails are thin, and the system cannot reliably separate “the human did this” from “the agent did this because the human asked.” OAuth 2.0 is closer to the right model because it grants limited access to a service on behalf of a resource owner through approval. Agent access needs short-lived tokens, narrow scopes, separate read and write permissions, human confirmation for irreversible actions, simple revocation, visible logs, and a clean split between preparation and execution. The agent should get a mandate, not the whole account. Read the calendar. Draft an email. Find options. Prepare an order. Compare plans. Stage a cancellation. Payments, publications, deletions, legal actions, medical decisions, and high-impact transfers need a stronger boundary. ![AI-agents are the new type of users](https://kalkaev.com/assets/kkXGSs7ZQuUxjbZy6mxv17YQk4.avif) ## 12. Security without pretending every bot is the same Agent-friendly access means separating useful delegation from scraping, abuse, impersonation, and uncontrolled automation. Robots.txt remains a preference signal, and RFC 9309 is explicit that it is not authorization. Cloudflare says the same thing operationally: robots.txt expresses preferences but does not technically prevent access. Cloudflare’s Content Signals Policy adds newer machine-readable preferences for search, ai-input, and ai-train. Useful signal, not a wall. Real control starts with action risk. Low-risk actions include public reading, search, comparison, and navigation. Medium-risk actions include reading personal data, creating drafts, or changing reversible settings. High-risk actions include sending messages, publishing, placing orders, cancelling services, or sharing personal data with a third party. Critical actions include payment, money transfer, medical instruction, legal action, trading, and data deletion. High and critical actions need confirmation, constraints, auditability, and clear responsibility boundaries. OpenAI’s ChatGPT agent documentation talks about explicit confirmation before real-world actions and active supervision for critical tasks. That is not safety theater. That is the minimum sane shape of delegated software. ![AI-agents are the new type of users](https://kalkaev.com/assets/D6bC6uSTFdd0n5ktpi5uxzun0A.avif) ## 13. Commerce will feel this first Shopping delegates well. People already ask assistants to find a gift under a budget, compare vacuum cleaners, reorder pet food, find flights with tolerable layovers, assemble a cart, and wait for approval. OpenAI and Stripe have pushed Agentic Commerce Protocol and Instant Checkout for purchases through AI agents. Google has announced Agent Payments Protocol, AP2, with attention to user control, authorization, and verifiable transaction trails. The exact winner matters less than the direction: commerce is moving toward structured catalogs, scoped payment authority, user confirmation, and clean merchant handoff. For merchants, the catalog becomes infrastructure. Product, variant, price, currency, inventory, delivery, returns, seller, warranty, compatibility, restrictions, package contents. All of it needs to be accurate and structured. Checkout should separate order preparation from payment execution. Payment authority should be scoped by amount, merchant, expiry, and confirmation, with only the order data passed along. A weak agentic store makes the agent scrape product cards, guess variants, read shipping rules from a modal, and click a generic buy button. A strong one gives the agent a structured catalog, lets it calculate an order, prepares the purchase, and shows the person a confirmation before money moves. That difference looks technical until it starts deciding where the order goes. ## 14. Some products should keep friction Agent access is not equally good for every product. If attention is the economic unit, an agent can weaken the model. Media, ad-supported sites, entertainment catalogs, recommendation platforms, and some marketing funnels monetize visits and engagement, not pure task completion. Some friction protects the user. Finance, healthcare, legal workflows, access management, personal data, and account recovery need carefully designed confirmation and audit paths. A slower step can be better design. Data-heavy products will also restrict machine access when extraction threatens the business. Flights, hotels, rentals, marketplaces, live pricing, closed databases, and professional directories will keep balancing user-agent usefulness against large-scale scraping. Products that want to become agent layers themselves may treat outside agents as competitors. Refusing all agent access has a cost. If two banks, marketplaces, travel products, or delivery services are equally good for humans, while one lets agents safely read, compare, stage actions, and request confirmation, that product becomes easier to delegate to. Agents will become a selection layer because some products will be less structurally dishonest than others. ## 15. A practical migration path Start with an inventory of delegatable scenarios. Pick five to ten tasks a user would actually hand to an agent: find information, compare options, fill a draft, prepare an order, book a slot, check status, cancel a service, assemble a report. The question is what is useful and acceptable to delegate, not what an agent can technically stumble through. Then map the actions. For each action, define risk, inputs, permissions, confirmation, reversibility, result, and audit behavior. This step tends to make teams uncomfortable because many products do not have a real action model. They have screens. Audit the accessibility tree across those scenarios. Use Chrome DevTools, Lighthouse, keyboard testing, and real browser agents. Inspect roles, names, states, source order, focus behavior, labels, errors, and ARIA. This is accessibility work, and it is also a machine-legibility diagnostic. Fix the cheap semantic damage first. Replace fake buttons with buttons, add field labels, connect errors to fields, repair headings, remove ambiguous links, expose states, and stabilize cards and forms. Then add structured content: Schema.org where appropriate, sitemaps, canonical pages, Markdown versions of important docs, llms.txt if it helps, and clear status and error pages. Only after that does the programmatic layer make sense: OpenAPI descriptions, API Catalog, OAuth delegation, direct actions for the main scenarios, WebMCP where the page context matters, MCP where external tools and data matter. Building tools before fixing semantics usually just gives agents a more formal way to misunderstand the product. Access policy comes last in this pass, but it should not be vague. Separate search crawlers, AI training crawlers, agents acting on behalf of users, partner integrations, and malicious automated traffic. One bot policy for all of them is either too hostile or too naive. ## 16. New design artifacts Agentic products need a few extra artifacts in the design process. A delegation map shows which user goals can be delegated, which are blocked, which require confirmation, and which require active supervision. An action registry lists meaningful operations across reading, creating, updating, deleting, publishing, paying, and sharing data, with permissions, risk, reversibility, interfaces, and audit behavior attached. A semantic screen spec describes roles, accessible names, states, relationships, errors, and structured data alongside layout. An agent error map separates missing permission, invalid format, state conflict, stale data, required confirmation, unavailable action, and rate limit. A confirmation policy defines where an agent may act alone, where it may prepare a draft, where it must ask a person, and where execution is forbidden. The final artifact is an agent action log. The user should be able to see what the agent did, when it did it, on whose behalf, with which data, and what can be undone. Without that log, agent access is just account magic with better branding. ## 17. Product notes by category E-commerce should start with catalog quality. Product, variant, price, inventory, delivery, returns, seller, rating, warranty, compatibility, and restrictions need structure. A visual dropdown barely connected to the SKU is a bad place for size selection. Keep order preparation separate from payment. SaaS should expose work actions as APIs and tools. An agent should be able to list projects, create tasks, prepare reports, find documents, and stage changes, while staying inside the user’s role and delegated scope. Logs matter more here than animation polish. Media and content products need a strategy. They may want agents to find, quote, summarize, and route people back. They may want to restrict AI use, license access, or expose paid partner feeds. Robots.txt, Content Signals, clean excerpts, canonical pages, and commercial access paths all belong in that decision. Financial services can use agents for reading, analysis, comparison, draft preparation, and explanation. Transaction execution needs limits, confirmations, and audit. In finance, lower friction is not automatically better design. Healthcare products can use agents for scheduling, forms, information search, and question preparation. Records, medical instructions, and data transfer need explicit consent, data minimization, and clear identity of the acting party. Travel and events products should make dates, time zones, cancellation rules, fees, availability, and restrictions machine-readable. These products often hide the expensive conditions behind tidy cards, which is exactly where agents make expensive mistakes. Government and education services may benefit the most because the tasks are bureaucratic and multi-step. They also tend to have the worst machine readability: PDFs, old portals, unclear forms, and errors with no explanation. In that area, accessibility and agent readiness are almost the same project. ## 18. Metrics worth tracking Track the share of main scenarios an agent completes without intervention, the share where it asks for confirmation correctly, the number of steps to completion, the number of ambiguous elements per scenario, and the failures caused by misread state. Track interactive elements with correct roles and names, forms with labels and connected errors, structured data coverage, current OpenAPI descriptions, API Catalog or discovery support, and fallback moves into screenshot-based interpretation. That last one is a tax. If the agent keeps falling back to vision, the product is probably hiding its own model. Risk metrics matter too: dangerous actions stopped by confirmation policy, token and time cost per scenario, stale content appearing in agent answers, and cases where the agent can prepare but not execute. These belong in design QA next to accessibility, performance, and search hygiene. ## 19. Technical appendix: descriptors, arguments, contracts Agent-ready products need machine-readable contracts. A contract should describe the entity, available actions, required arguments, risk level, result, errors, and execution policy. A descriptor is a formal description of an object or action that the agent can read without guessing. The human interface shows a product card, a price, and a buy button. The agent-facing model says this is product sku_123; it has price, currency, availability, and variants; it exposes cart.add; the action accepts skuId, quantity, and variantId; it modifies the cart; payment needs human confirmation. The screen should be a visual representation of that stricter model. It can still be expressive, but it should not be the only place where product meaning exists. ### Interface semantics data-action and data-entity-id are internal conventions rather than browser standards. They still help because designers, frontend engineers, QA, analytics, and agent-layer developers get a shared language. The agent needs to know which object the action belongs to. ### Entity descriptor This can live in application state, an API response, JSON-LD, a catalog, or a separate agent layer. Public pages can use Schema.org where it fits. Private product logic will usually need a richer model. ### Action descriptor The contract matters more than the button because the contract is what lets the agent act without guessing. It is also where the product states the cost of being wrong. ### Policy descriptor This layer matters most for payments, messages, deletion, bookings, financial operations, medical flows, and legal consequences. Low-risk actions can often be delegated. High-risk actions should be prepared by the agent and confirmed by the human. ## 20. Action schemas Every agent-accessible action needs a consistent vocabulary: name, title, description, entityTypes, inputSchema, outputSchema, riskLevel, sideEffects, isReversible, requiresHumanConfirmation, authScopes, rateLimit, preconditions, postconditions, errors, auditPolicy, and uiFallback. Treat this vocabulary as product infrastructure, because it is where design intent becomes executable behavior. Bad schemas look flexible to the developer and vague to everyone else. The agent receives a bucket and has to guess what belongs inside: Better schemas reduce wrong choices. They force the caller to name the decision it is making: Avoid abstract fields such as data, payload, and value when concrete names are available. Use enums where the choice set is known. Include units such as currency, timezone, grams, meters, or percentage. Separate object IDs and display names. Return { “amount”: 3490, “currency”: “RUB” } rather than forcing the agent to parse “3,490 RUB”. Keep search and action separate. Name dangerous operations by consequence. placePaidOrder says more than submit. ## 21. OpenAPI, MCP, and WebMCP examples OpenAPI is a good base for HTTP API descriptions, especially when agent policy lives near the operation through extensions. The point is to keep the operational contract close to the code path that enforces it. The x-agent-* fields are custom OpenAPI extensions. They keep the agent policy beside the operation instead of in a stale slide deck. In MCP, an action usually looks like a tool. The same naming discipline applies there: update is a weak tool name. updateDeliveryAddress, cancelBooking, prepareOrder, and confirmPayment tell the agent what the action does and how much risk it may carry. WebMCP-style page registration helps a website expose page-specific capabilities to a browser agent that is already visiting the page. The page gets to state its own affordances: The page can expose safe actions instead of waiting for an agent to reverse-engineer them from pixels. Cheaper. Less weird. ## 22. Components as action carriers The useful chain is visual element to entity to action to argument schema to policy to result. A button labeled “Add to cart” maps to Product sku_123, action cart.add, input { skuId, variantId, quantity }, low risk, no confirmation requirement, and a result containing cartId, lineItemId, and subtotal. Design systems can encode this directly. The component spec starts carrying product semantics: A component then carries action semantics as well as visual layout. That is where design and frontend architecture meet properly, instead of exchanging screenshots and hope. ## 23. Errors and confirmations Generic errors block agents because they do not describe the next move. They turn a recoverable branch into a dead end. A useful error gives the agent a branch. It names the failure and points toward a possible recovery: If the item is out of stock, the agent can find alternatives. If permissions are missing, it can ask the user to sign in. If confirmation is required, it can present a summary. If data is stale, it can refresh the estimate. «‎Something went wrong»‎ mostly says the implementation got tired. Confirmation should use the same discipline. Split dangerous operations into preparation and execution, then make that split visible in the contract: The confirmation action carries the high-risk boundary. The name alone should make the cost of execution obvious: The agent prepares, the human confirms, and the system records what happened. That pattern will age better than a generic checkout call that quietly does six different things. ![AI-agents are the new type of users](https://kalkaev.com/assets/CoyGDG1kpvO07sdGBURXos74Q.avif) ## 24. Design systems for agentic products Design systems should add semantic passports to important components. A button spec should include visibleLabel, accessibleName, actionName, entityId, riskLevel, disabledReason, loadingState, successState, and errorState. It should forbid icon-only actions without names, “Next” without context, critical information hidden only in tooltips, and destructive actions without a confirmation state. A product card spec should include productId, name, price.amount, price.currency, availability, primaryImage.alt, primaryAction, and variantState. Its agent requirements should say that the action button is linked to the product ID, price is not text-only, availability is not color-only, and variants have stable IDs. That is the design-system version of agent readiness. Less glamorous than a new component library. More useful. ## 25. Readiness checklist Before claiming agent readiness, a team should answer the boring questions. Each main action should have a machine name, input schema, output schema, risk level, and confirmation policy. Dangerous actions should have a separate confirmation step. The system should distinguish preparation from execution. Errors should have codes. Buttons should be connected to entities. Product cards, events, bookings, documents, and orders should have stable identifiers. Price, date, currency, timezone, availability, and permissions should be structural data rather than strings the agent has to parse. Forms should have labels, descriptions, and connected errors. Custom components should fulfill their ARIA roles. Agent actions should be logged. Some scenarios should explicitly forbid agent execution. Human fallback should exist when the agent cannot finish the task. If half the answers amount to “it’s obvious in the interface”, the product is not ready. It may be obvious to a person who already knows the pattern. That is not the same as being computable. ## 26. The useful formula The old component model was visual block plus state plus behavior. The agentic component model adds entity, action, schema, and policy. That is the useful shift for designers and frontend engineers. Teams do not need websites for robots. They need products where important actions have readable contracts. The person gets a normal interface. The agent gets a map of capabilities. AI agents do not replace human interfaces. People still need screens for understanding, choice, trust, control, and meaning. The screen remains where the person decides and feels the product. It just cannot be the product’s only interface anymore. The new baseline is a product that speaks honestly to humans, browsers, assistive technologies, search systems, API clients, and agents. Different languages, same product reality. Design the screen for the human. Design the structure for the machine. Design actions for delegation. Design permissions for safety. Design logs for trust. The agentic web will not start because one standard wins. It will start because products with clear semantics, accessibility, structured data, exposed actions, and sane authorization become easier to delegate to. The rest will remain beautiful pages that agents click through half-blind. ![AI-agents are the new type of users](https://kalkaev.com/assets/MS11t1OcAOoWhZImsDCsBYmtlk.avif) ## Sources - OpenAI Help Center:[ChatGPT agent](https://help.openai.com/en/articles/11752874-chatgpt-agent) - OpenAI:[Understanding prompt injections](https://openai.com/safety/prompt-injections/) - OpenAI:[Designing AI agents to resist prompt injection](https://openai.com/index/designing-agents-to-resist-prompt-injection/) - OpenAI:[Buy it in ChatGPT: Instant Checkout and the Agentic Commerce Protocol](https://openai.com/index/buy-it-in-chatgpt/) - OpenAI Developers:[Apps SDK reference](https://developers.openai.com/apps-sdk/reference) - Anthropic Docs:[Computer use tool](https://docs.claude.com/en/docs/build-with-claude/computer-use) - web.dev:[Build agent-friendly websites](https://web.dev/articles/ai-agent-site-ux) - Chrome for Developers:[When to use WebMCP and MCP](https://developer.chrome.com/blog/webmcp-mcp-usage) - Chrome for Developers:[Registered WebMCP tools in Lighthouse](https://developer.chrome.com/docs/lighthouse/agentic-browsing/registered-webmcp-tools) - Chrome DevTools:[Accessibility features reference](https://developer.chrome.com/docs/devtools/accessibility/reference) - W3C:[WCAG 2.2](https://www.w3.org/TR/wcag/) - W3C WAI:[ARIA Authoring Practices Guide](https://www.w3.org/WAI/ARIA/apg/) - MDN:[HTML: A good basis for accessibility](https://developer.mozilla.org/en-US/docs/Learn_web_development/Core/Accessibility/HTML) - OWASP:[Top 10 for Large Language Model Applications](https://owasp.org/www-project-top-10-for-large-language-model-applications) - Schema.org:[Action](https://schema.org/Action),[Product](https://schema.org/Product) - Google Search Central:[Structured data markup that Google Search supports](https://developers.google.com/search/docs/appearance/structured-data/search-gallery) - OpenAPI Initiative:[OpenAPI Specification v3.2.0](https://spec.openapis.org/oas/latest) - IETF:[RFC 9727, api-catalog](https://www.rfc-editor.org/rfc/rfc9727.html) - IETF:[RFC 6749, OAuth 2.0 Authorization Framework](https://www.rfc-editor.org/rfc/rfc6749) - IETF:[RFC 8414, OAuth 2.0 Authorization Server Metadata](https://www.rfc-editor.org/rfc/rfc8414) - IETF:[RFC 7591, OAuth 2.0 Dynamic Client Registration](https://www.rfc-editor.org/rfc/rfc7591.html) - IETF:[RFC 9309, Robots Exclusion Protocol](https://www.rfc-editor.org/rfc/rfc9309) - Cloudflare Blog:[Introducing the Agent Readiness score](https://blog.cloudflare.com/agent-readiness/) - Cloudflare Docs:[robots.txt setting and Content Signals Policy](https://developers.cloudflare.com/bots/additional-configurations/managed-robots-txt/) - Google Cloud Blog:[Announcing Agent Payments Protocol (AP2)](https://cloud.google.com/blog/products/ai-machine-learning/announcing-agents-to-payments-ap2-protocol) - Model Context Protocol:[Tools](https://modelcontextprotocol.io/specification/draft/server/tools) - llms.txt reference:[llms.txt](https://llmtxt.info/) Written by - [@kalkaev](https://x.com/kalkaev) --- More: [llms.txt](https://kalkaev.com/llms.txt) · [HTML page](https://kalkaev.com/writings/ai-agents-are-the-new-type-of-users) · [Text view](https://kalkaev.com/agents/writings/ai-agents-are-the-new-type-of-users/) --- title: "The button was too easy | Ivan Kalkaev" description: "A crypto trading product had healthy engagement, but users stopped when serious money entered the flow." url: https://kalkaev.com/writings/the-button-was-too-easy --- # The button was too easy June 24, 2026 · 20 min read There is a specific kind of product problem that produces excellent dashboards and uncomfortable meetings at the same time. People open the app regularly, spend a respectable amount of time inside it, save things for later, complete small transactions, and generally behave like users of a product that works. Then the amount of money involved becomes meaningful, the same people suddenly slow down, and the team starts discussing button copy because the button is the last visible object before the numbers fall apart and the cheapest one to interrogate. This case began with that familiar setup, although the button turned out to be almost entirely innocent and had mainly suffered from being the only suspect everybody could fit into a sprint. The product was a retail crypto trading platform with a strong, lively interface and a growing audience. Monthly active users had reached 420,000, DAU/MAU was 31%, the average session lasted 11 minutes and 40 seconds, and 54% of users maintained a watchlist. Small trades below $100 were growing by 22% month over month, while ordinary trade completion sat at 71%. Those numbers described a product with healthy engagement and users who understood enough to explore, compare, return, and move smaller amounts of money through the system. The picture changed when they reached vault deposits. Deposits above $1,000 had stopped growing, deposits above $10,000 were down 14%, vault completion was only 29%, and 38% of users abandoned at the final confirmation screen. Usability sessions made the situation more confusing because participants could explain the screen perfectly well. They saw the amount, understood the network, recognized the fee, noticed the estimated APY and risk badge, and knew exactly which button would complete the deposit. The interface passed the usual clarity test while failing the only test that mattered commercially: users understood the action and remained unwilling to take it. This composite product case uses the supplied data to examine behavior familiar from years of working around crypto, fintech, gaming, and products where a cheerful interface eventually asks somebody to risk something real. I am interested in it because it demonstrates how quickly a design conversation becomes too small for the product problem in front of it. A tooltip, a larger warning, or a more serious button might improve one screen, while the underlying system would continue asking users to perform their own due diligence outside the product. ![The button was too easy](https://kalkaev.com/assets/aGdvq9bdvnAGo17DfjniyZ3Pjf8.avif) ## The Screen Worked Teams often treat clarity as a single property, although financial products need at least two different kinds of clarity. Mechanical clarity tells a user what a button will do, where funds will move, which network will process the transaction, and what fee will be charged. Decision clarity helps the same user judge whether moving this amount into this strategy makes sense given the source of yield, the range of possible outcomes, the exit conditions, and the risks that remain with the user. The final screen in this product had enough mechanical clarity to perform well in moderated testing, while decision clarity had been left to the user. That distinction matters because a usability test usually creates an artificial calm around the action. The participant sits in a controlled environment, follows a scenario, explains visible information, and demonstrates that they understand the interface. Real capital introduces a much less polite set of conditions. The user may be moving a meaningful part of their wallet balance into an unfamiliar strategy, through an unchecked contract, for an estimated return that can change after the transaction. The screen can remain perfectly legible throughout this process and still fail to support the decision being made. The team had effectively designed a transaction confirmation and placed it where users needed an allocation review. A transaction confirmation verifies that the amount, destination, network, fee, and final action are correct. An allocation review gives the user a structured way to understand what drives the return, what can change, how they can exit, what happens after confirmation, and whether the strategy suits the way they intend to use the money. Combining those jobs into a compact final screen creates an interface that looks efficient in Figma, where every financial decision is wonderfully calm and nobody has ever lost money, and feels strangely underweight when somebody reaches it with $5,000. This is where traditional UX criticism tends to become decorative. A reviewer can point at a small risk badge, an unclear APY label, or a weak hierarchy and produce several valid recommendations, yet the user still arrives at the same point before completing the intellectual work required for the deposit. The architectural gap sits across the entire journey, beginning on the strategy page and continuing through amount entry, review, confirmation, and the state after the transaction has been submitted. ## The Interface Had One Emotional Setting Retail crypto products need energy because a completely restrained interface tends to become a spreadsheet with a wallet connection, which may satisfy people who already know exactly what they want while doing very little for everyone else. Color, movement, compact cards, watchlists, fast comparisons, and visible opportunities help users explore a complicated market with the ease of a consumer product. The product in this case was good at that part, and preserving its character was a core constraint for the redesign. The issue appeared because the same emotional language continued across several very different modes of behavior. Exploration is lightweight and reversible; the user scans markets, opens strategies, saves a few options, and builds a rough understanding of what is available. Small trading is also relatively forgiving; somebody moving $30 or $50 usually wants a fast path that lets them learn by doing. Serious allocation changes the relationship because the amount has become meaningful and the user starts evaluating concentration, yield stability, liquidity, and exit conditions. Irreversible execution has even less room for ambiguity because the user is about to sign and send a transaction that remains final after the interface completes its part. Those modes can live inside one product and carry different levels of visual gravity. A $50 trade and a $5,000 vault deposit can share components, brand colors, typography, and interaction patterns while adapting the emphasis of the interface. The amount should become more prominent, promotional language should recede, APY should gain context, risk should become specific, and the final action should describe exactly what will happen. A sufficiently flexible visual system can express both playful discovery and high-consequence execution as parts of the same brand. iGaming products provide a useful parallel because mature operators have spent years learning to express excitement and consequence at different levels of intensity. The lobby is allowed to be loud, fast, promotional, and packed with movement because its job is discovery. Deposit limits, withdrawals, identity checks, and responsible gaming controls require a calmer and more explicit language because the user is managing money or setting boundaries. The strongest products preserve the brand across those modes and give a withdrawal screen the composure appropriate to its job. Crypto often borrows the visual energy of iGaming while skipping the operational maturity that tells the interface when to calm down. ![The button was too easy](https://kalkaev.com/assets/a1QLJI1Sqy9FumkgbHeERUd2KtY.avif) ## Experienced Users Were Slower The strongest behavioral clue was that experienced DeFi users hesitated more than less experienced users. A complexity-driven abandonment pattern would usually show experienced users moving faster because they already understood vaults, networks, contracts, liquidity, fees, and variable APY. Their caution showed that expertise was creating additional checks and revealing more uncertainty. They could see everything the interface had compressed into a tidy card, including the conditions that might make the headline return temporary or the exit more complicated than the product suggested. A novice can move quickly because the visible flow feels clear and several important questions remain outside their current mental model. An experienced user may pause because the APY depends on incentives, the risk level lacks a visible methodology, the strategy has limited liquidity, the contract deserves verification, or the exit conditions matter more than the current return. If the product measures speed and completion separately from the outcomes that follow, novice confidence can look healthier than informed caution. That produces one of the more dangerous analytics mistakes in financial products: the team celebrates the user who understood less because that user clicked faster, which is a surprisingly common way to turn ignorance into a conversion rate. Support data usually exposes this mistake later. A fast confirmation followed by a confused ticket, an immediate withdrawal, or a complaint about a changing APY represents a weak conversion even if it improved the funnel on the day of the transaction. Experienced-user hesitation can be commercially valuable because it shows the standard of evidence required for a user who understands the category to proceed comfortably. Treating those users as unusually difficult removes a useful source of product intelligence and leaves the product tuned for people still learning what can go wrong. I would use experienced users as a trust benchmark and study their behavior to reveal which questions deserve first-class product support and which pieces of information currently exist only in documentation, support conversations, block explorers, or external research. The resulting system would give due diligence a clear path, use progressive disclosure for technical depth, and let users decide how deeply they need to inspect before committing capital. ## Users Had Already Designed Their Own Flow As the intended deposit amount increased, users became more likely to go back, open help, copy an address, reduce the amount, perform a small test deposit, cancel a wallet signature, or leave to compare the strategy elsewhere. A conventional funnel labels most of this behavior as leakage because the user moved away from the shortest route to completion. That label is technically correct and strategically useless. The actions form a coherent safety process that currently lives outside the official product flow. Going back often means rebuilding the context of the decision after the final screen compressed it. Opening help at the last moment usually signals a specific unresolved concern. Copying an address can mean checking the destination, contract, custody model, or network through an explorer. A test deposit is frequently a high-intent action from somebody who wants to verify execution before sending the planned amount. External comparison shows that the user wants an impartial reference point for APY, risk, fees, liquidity, or exit terms. The team was worried that adding friction would slow users down, while the data showed that users were already slowing themselves down in ways the product could barely observe or support. They were opening competitor tabs, searching documentation, manually changing amounts, checking explorers, and contacting support, which is a fairly expensive way to admit the product forgot the checklist. This form of friction damages confidence because the user has to invent the process, and it damages the business because the product loses visibility at the moment of highest intent. Removing every pause would be reckless; bringing useful pauses into the product would make the experience easier to understand and much easier to improve. The product response should convert each unofficial safety behavior into a supported path, with backtracking preserving the review state and contextual help connecting directly to the selected vault, amount, network, and risk profile. Address copying gains a verified destination, a plain explanation, and a direct explorer link. A manual test deposit becomes an official option that remembers the original intended amount. External comparison becomes a product comparison layer that openly shows similar strategies, return ranges, risk dimensions, fees, liquidity, and exit conditions. ![The button was too easy](https://kalkaev.com/assets/34L6xsY7a2vky3ZyDDQaWJ9JcHw.avif) ## APY Was Doing The Wrong Job APY is unusually easy to turn into a prize. It fits neatly into a large number, supports sorting and comparison, looks good in a card, and gives the visual system an obvious object to emphasize. In a lively interface, the number quickly acquires the emotional role of a bonus multiplier or a jackpot even when the label says estimated. Users may understand intellectually that the return can change while still reading the design as an invitation to act before the opportunity disappears. Discovery needs a headline APY because users require a quick way to scan opportunities. The presentation should change as the user moves closer to execution. On a strategy page, APY needs a range, timestamp, source of yield, incentive component, fee assumptions, and a clear description of what can reduce it. During capital review, the number should behave like a financial estimate with supporting context. On final confirmation, the amount, destination, and finality deserve greater visual weight. A credible APY module could explain that the current estimate is 12.4%, that the strategy ranged between 8.1% and 15.7% over the previous 30 days, and that liquidity incentives, pool activity, and market volatility are the main drivers. A compact decision module can communicate this context clearly and give the estimate an appropriate level of visual prominence. Risk had suffered from the same compression. A low, medium, or high badge can be useful while scanning a list, while a useful risk module identifies the two or three material risks, describes the practical consequence, explains the exit implication, and defines the limits of the platform’s guarantees. A medium-risk badge remains available as the summary, while the underlying system performs actual decision work. The art direction here needs controlled range. Serious financial information benefits from hierarchy, calm contrast, precise language, and fewer celebratory signals around the final action. Brand character survives this change because a brand with only one volume setting behaves like a style preset, and style presets have a poor record with other people’s money. ![The button was too easy](https://kalkaev.com/assets/AK2pM3YUJVa4VEDLhq2wPa4ycVw.avif) ## The Product Needed A Rules Engine For Trust A universal review screen for every deposit would create a new problem immediately. Somebody repeating a familiar low-risk action with an amount well within their normal behavior deserves a lighter flow than a first-time user moving half of a visible wallet balance into an unfamiliar vault. Absolute amount matters, although relative amount, product type, strategy risk, user history, and current behavior often matter more. A static threshold such as “$1,000 always requires review” would become clumsy as soon as real users reached it. The execution system should combine several inputs. It needs the absolute amount and the amount relative to the connected wallet balance, previous transactions, and the user’s normal behavior. It needs to understand whether the action involves spot trading, staking, a liquidity pool, a vault, or a structured product. It needs the strategy risk profile, including liquidity, lock-up, incentive dependence, and experimental status. It also needs user-state signals such as first vault deposit, prior large deposit, experience proxy, support history, and hesitation during the current session. Those inputs can produce four practical execution modes. Fast confirm serves small or familiar actions with a clear amount, fee, network, and precise action. Guided confirm adds a compact strategy summary, top risks, exit hint, and contextual help for first-time or mildly risky actions. Capital review supports serious allocation with APY assumptions, risk anatomy, exit conditions, a saved decision state, and an optional test deposit. High-consequence execution handles unusually large, complex, locked, or risky actions through a two-stage review, verified destination, explicit finality, and stronger post-confirmation monitoring. This is the design-engineering part that disappears when a case study presents only polished screens. The visible interface depends on thresholds, states, events, component variations, content rules, and data that may be incomplete or unavailable. Designing the conditions alongside the review page turns a static concept into a working product. The real output is a system that knows when to stay out of the way, when to offer support, and when to give the action enough weight to feel credible. iGaming offers another useful comparison here because good risk controls are rarely applied with one universal interruption. Deposit limits, affordability checks, cool-off periods, withdrawal states, and session interventions depend on jurisdiction, user state, behavior, and consequence. A player making an ordinary low-value deposit receives a lighter flow than somebody showing a sharp and unusual change in behavior. Crypto products have different obligations and user expectations, although the product-design principle transfers cleanly: consequence-aware systems need adaptive states, and generic warning modals handle that job poorly. ![The button was too easy](https://kalkaev.com/assets/wHXsXtxqer5V6HAVov9eyotPw.avif) ## A Better Large-Deposit Journey The redesigned journey should begin before the user enters the amount because decision context develops across the entire flow. The strategy page needs to explain the source of yield, current estimate and historical range, primary risks, exit conditions, liquidity notes, historical behavior, and the kind of user or use case the strategy suits. A sentence such as “Best for users who can tolerate variable APY and accept a longer exit window” connects the product mechanics to a real constraint more clearly than a vague medium-risk label. Amount entry should help users calibrate the action in a factual and neutral tone. The interface can show the connected balance, estimated return at the entered amount, fee impact, and factual relative cues such as the deposit being 6.4 times larger than the user’s previous vault deposit or representing 32% of the visible wallet balance. These cues require careful handling because personalized warnings can feel patronizing or invasive very quickly. Their value comes from providing context the user would otherwise calculate manually, while leaving the decision with the user. Capital review should gather the five pieces of information the user needs before execution: what they are doing, what drives the estimated return, what can change after deposit, how they can exit, and what happens after confirmation. The review should preserve progress and allow the user to leave, compare, inspect a contract, or return later with the decision intact. This deliberate pause brings the user’s existing external checks into a faster and calmer product flow. Final confirmation can then return to a narrower job. It verifies amount, strategy, network, wallet, destination, fee, material risk summary, finality, and expected next state. The action label should describe the transaction precisely, such as “Confirm $5,000 vault deposit,” because promotional language near an irreversible action weakens trust and creates unnecessary ambiguity. After the transaction, the product should show status, expected settlement time, current location of funds, monitoring options, exit access, and the boundaries of support. A celebratory success state can wait until the transaction catches up with the confetti’s legal confidence. The native test deposit deserves particular attention because users had already demonstrated demand for it. The product can offer a small suggested test amount, save the original $5,000 plan, and return the user to that plan after successful execution. The explanation should state that the test verifies the wallet, network, and vault setup while market, liquidity, APY, and protocol risk remain. This framing gives the feature a precise and credible scope. ![The button was too easy](https://kalkaev.com/assets/LVsQ2H8RAwLXqi3baEWRYP3Zq8.avif) ## Measuring A Better Decision Raw deposit completion is a tempting primary metric because it is easy to explain and moves quickly. It is also easy to improve in ways that make the product worse. A brighter action, fewer warnings, less visible risk, and a shorter flow can increase same-session deposits while producing more confusion, support contacts, immediate withdrawals, and low repeat trust. The dashboard celebrates before the consequences arrive. I would introduce Qualified Capital Conversion as the commercial outcome for serious deposits. The metric would track users who begin considering a deposit above a defined threshold, complete it, retain the position for seven or thirty days, and avoid a confusion or regret support contact within the early post-transaction window. It should be segmented by amount, product type, risk profile, first versus repeat deposit, experience level, and the treatment the user received. The exact formula requires validation with the business, although the principle is straightforward: completion has value only when the user understood enough to remain comfortable with the action afterward. Hesitation also needs a richer model than abandonment. Time on the final screen, backtracking, opening APY details, expanding risks, checking exit terms, copying an address, comparing strategies, selecting a test deposit, or canceling a wallet signature can represent very different states. Productive hesitation helps the user learn, compare, test, save, and return. Panic hesitation creates loops, unexplained exits, canceled signatures, and support contacts after an under-informed confirmation. The product should move behavior from the second category toward the first and treat useful pauses as part of a good decision. Instrumentation turns this model into something the team can operate. Discovery events show what the user evaluated, amount events reveal calibration, review events show which decision modules mattered, final events capture execution and hesitation, and post-deposit events reveal whether the user remained comfortable with the result. The event model should include amount tier, relative amount, product type, strategy risk, APY variability, first-vault status, previous maximum deposit, experience proxy, support history, and experiment group. This is design work because responsible improvement depends on the team’s ability to distinguish useful caution from confusion. ## What We Agreed To Ship First The first release focuses on measurement and obvious credibility problems. Within one or two weeks, the team will segment the funnel by amount, instrument hesitation signals, improve support taxonomy, label APY as estimated and variable with a timestamp, add consequences to risk explanations, and replace promotional final-action copy with precise transaction language. This establishes the baseline and removes some of the signals that currently make serious actions feel lighter than they are. The next phase introduces a Capital Review MVP for serious deposits, initially using a simple threshold and a limited set of risk conditions. It includes APY assumptions, risk anatomy, exit summary, contextual help, and a precise final confirmation, tested against completion, abandonment, retained deposits, support contacts, and small-trade guardrails. The threshold can remain intentionally imperfect during the experiment because the purpose is to validate whether better-placed decision support improves qualified conversion before investing in a more advanced engine. Native safety paths follow once the core review demonstrates value. Test deposits, saved decisions, in-product comparison, verified destinations, and post-test prompts bring existing user behavior into the product and make it measurable. The final phase develops the adaptive rules engine, relative thresholds, user-state logic, risk model, and qualified capital dashboard. At that point the work has moved far beyond a redesigned confirmation screen and become a product capability that can support future strategies, networks, and high-consequence actions. This sequencing also protects the product’s strongest surfaces. Small trades and exploration remain guardrails throughout the rollout, keeping their existing speed and character as serious execution improves. A team can easily overreact to a trust problem and cover the entire interface in warnings, disclaimers, and muted colors. That approach communicates fear more strongly than control and weakens trust in a different way. ![The button was too easy](https://kalkaev.com/assets/MMLnp5Noi3Bi3tbzZHUMhwvmPg.avif) ## The Designer’s Actual Job This case describes the kind of work that becomes awkward when design roles are separated too cleanly. The product designer needs to model behavior, identify the difference between transaction clarity and decision clarity, map the hidden safety process, and redesign the journey around user intent. The art director needs to protect the energy that made the product appealing while giving high-consequence actions a calmer and more precise visual language. The consultant needs to show how fast conversion and trust can reinforce each other once the business brings existing user-created friction into the product. The funny part is that everyone in the room usually recognizes this work immediately. They just prefer to file it under a cleaner title before procurement, HR, or somebody with a competency matrix gets nervous. The design engineer needs to make the proposed system real enough to survive contact with the product. That includes component states, threshold logic, data availability, event definitions, fallback behavior, copy rules, analytics properties, guardrails, and rollout constraints. A beautiful Capital Review screen is easy to draw; a review system that appears for the right users, explains the right risks, preserves progress, records useful signals, and respects the speed expected by repeat users requires much more careful work. This is where modern design practice becomes closer to product architecture than screen production. I have seen this gap enough times to distrust beautiful rectangles with moral confidence. The mockup looks expensive, the prototype feels decisive, and then the first real edge case walks in with muddy shoes. That is usually the moment when design becomes a system or remains a screenshot with better lighting. I have spent fifteen years shipping products, collected awards along the way, worked as an art director, product designer, consultant, and increasingly as the person who turns the design into something close enough to code that engineering has to acknowledge the difficult states. I am also currently having a remarkably difficult time finding a job, which is either a useful reminder that the hiring market has its own experimental risk model or evidence that I should have added a larger green button to my CV. The self-irony aside, the situation reflects a genuine category problem: companies say they want designers who connect product strategy, systems, visual direction, analytics, and implementation, while hiring processes remain much better at recognizing a tidy title than a person who works across the boundaries. The market loves hybrid designers in keynote language and punishes them in dropdown menus. Somewhere between Product Designer, Design Engineer, Art Director, and Consultant there is usually a person doing the actual work, politely confusing the ATS while the product keeps asking for exactly that range. The broader lesson is useful well beyond crypto. Products often become very good at helping users begin an action and surprisingly weak at helping them understand the consequences of completing it. Growth systems naturally favor momentum, while trust is built through appropriate resistance, visible context, and a credible sense that the product understands the weight of the decision. When the action is small, speed communicates competence. When the action is consequential, unlimited speed can communicate carelessness. The platform needed enough range to stay lively during exploration, stay quick during small actions, and become precise when real capital entered the flow. Users were already doing the work required to feel safe through backtracking, external comparison, manual tests, contract checks, and support conversations. Bringing that work into the product would improve trust, measurement, and conversion quality at the same time, while making the final button’s personality considerably less important. Written by - [@kalkaev](https://x.com/kalkaev) --- More: [llms.txt](https://kalkaev.com/llms.txt) · [HTML page](https://kalkaev.com/writings/the-button-was-too-easy) · [Text view](https://kalkaev.com/agents/writings/the-button-was-too-easy/) --- title: "Fast image feeds are a scheduling problem | Ivan Kalkaev" description: "Image-heavy feeds feel fast when the browser does the right work in the right order. A practical guide to image sizing, loading, caching, and scroll UX." url: https://kalkaev.com/writings/fast-image-feeds --- # Fast image feeds are a scheduling problem July 29, 2026 · 13 min read How to make media-heavy feeds feel fast by controlling the order in which the browser discovers, downloads, and renders their content. Image-heavy feeds often begin to feel slow before anything particularly dramatic happens on the network. The browser discovers the important images too late, requests variants that are much larger than their rendered slots, waits for missing geometry, and spends resources on distant content while the first screen remains incomplete. Compression helps with transfer size, although the experience itself is usually decided by the order of work. This makes a feed a scheduling system as much as a collection of media. The first viewport needs to become visually complete, the next viewport needs to be prepared before scrolling reaches it, and everything farther away can remain dormant until its turn comes. Once those distances are treated differently, the browser has a much better chance of doing useful work first. The implementation may currently involve server-rendered HTML, srcset, native lazy-loading, IntersectionObserver, a CDN, and a few browser priority hints. Those details will evolve. The underlying UX problem will remain: every resource enters a queue, and the quality of the feed depends on which resources reach the front. ## The path from URL to pixels An image passes through several stages before it appears inside a card. The browser has to discover the URL, choose a source, assign a priority, transfer the file, decode it, and place the resulting pixels into a known area of the layout. Delays at any of these stages can leave a visible hole even when the image server itself is fast. **Stage** · **Browser question** · **Typical failure** · Discovery Which images exist on this page? Important URLs appear only after JavaScript and an API request Selection Which available source fits the rendered slot? A large original is selected for a small card Priority Which requests should move first? Visible media competes with offscreen content Transfer Can the file be served nearby or reused? The browser repeatedly downloads an unchanged asset Decode When can the compressed file become pixels? Several large images finish together and create main-thread work Present Where should the image appear? The browser learns the card dimensions after loading begins Looking at this complete path is more useful than treating every slow image as a compression problem. A smaller file can still arrive late, decode at an inconvenient moment, or push the rest of the layout around when it appears. ## Three practical distances A feed becomes easier to reason about when its content is divided by distance from the current viewport. The first group contains what the person can already see. The second contains the next one or two viewports. The third contains the rest of the feed, which may never be reached during the session. Visible content should be discoverable early, rendered into reserved space, and given enough priority to complete the first screen. Nearby content can begin loading quietly in the background, with enough lead time to be ready when scrolling reaches it. Distant content needs almost nothing yet. The exact boundaries depend on the product. A compact marketplace grid may prepare several rows at once, while a feed of large editorial posters may need a smaller batch because every card carries more bytes and more decoding work. Scroll velocity, API latency, image weight, device class, and connection quality all affect the useful preparation distance. This is why a fixed instruction such as “lazy-load every image after the first six” rarely survives contact with a real product. The more durable decision concerns distance and urgency. The number of cards follows from that. ## Make the first viewport discoverable Many feeds introduce their first images through a long client-side chain: By the time the browser learns which images matter, it has already downloaded, parsed, and executed the code required to reveal them. A fast CDN can shorten the final request, but it cannot recover the time spent before discovery. Rendering the initial cards into the HTML response gives the browser an earlier work order. That HTML may come from server rendering, static generation, streaming, or another architecture; the relevant part is that the image URLs are visible during the first parse. The probable Largest Contentful Paint image should load eagerly. A fetchpriority=”high” hint can help the browser recognise its importance sooner, especially when several images appear near the top of the document. Applying the hint to one or two critical resources preserves the distinction that the hint is supposed to communicate. Current browser guidance recommends exposing the LCP resource in the initial HTML and avoiding loading=”lazy” on it. The implementation advice may change as browser heuristics improve, while early discovery will continue to matter because the browser can only prioritise resources it knows about. The[web.dev LCP guide](https://web.dev/articles/optimize-lcp)describes this part of the loading path in more detail. ## Match image dimensions to the rendered slot A product may store a 2048px source because the image also appears in a lightbox, detail page, or high-density display. The grid card still needs a source appropriate for its own dimensions. Responsive image markup gives the browser a set of derivatives and a description of the slot: srcset lists the available files and their intrinsic widths. sizes describes the expected rendered width of the slot at each breakpoint. The browser uses both values, together with display density and its own selection logic, to choose a source. The fragile part is usually sizes, because the layout continues to change after the image component has been written. A four-column grid becomes five columns, gaps are adjusted, or a sidebar is added, while the old slot description survives untouched. The markup still looks responsive, although the browser is making decisions from obsolete information. The selected file can be checked through currentSrc: Comparing currentSrc, clientWidth, naturalWidth, and the device pixel ratio usually reveals systematic over-delivery quickly. The goal is a sensible match across common conditions rather than mathematical perfection for every possible viewport. Modern formats remain useful because they can reduce transfer size at comparable visual quality. Their effect compounds with correct dimensions. A well-sized WebP or AVIF variant has a much easier job than a full-resolution source being compressed into a small CSS box.[MDN’s responsive image guide](https://developer.mozilla.org/en-US/docs/Web/HTML/Guides/Responsive_images)explains how srcset and sizes participate in source selection. ## Reserve the geometry before the pixels arrive A feed can finish loading quickly and still feel unstable when every arriving image changes the page geometry. Cards move, text shifts, and the scroll position drifts under the pointer. The interface keeps renegotiating its shape during the exact moment when someone is trying to understand it. An aspect-ratio container gives the browser a stable box from the beginning: Explicit width and height attributes provide the intrinsic ratio at the HTML level, allowing the browser to reserve space before the image has been transferred and decoded. CSS can still change the rendered dimensions while preserving that ratio. The placeholder mainly needs to hold the layout together. A neutral colour often handles this well. Low-resolution previews can create a smoother visual transition when the imagery itself carries the product experience, although they introduce another representation that has to be generated, delivered, decoded, and replaced. Animated shimmer across an entire grid adds constant motion and can make the page feel busier during loading. Accessibility remains part of the image contract. Content images need useful alternative text, while decorative images can use alt=””. Performance attributes should not change the semantic role of the image. ## Use lazy-loading according to location Native lazy-loading works well for ordinary images below the initial viewport because the browser already understands its layout and current resource pressure. An image that remains far outside the visible area can wait, and an image that is never reached may avoid the request entirely. Using JavaScript to reproduce basic image lazy-loading can delay discovery further when real URLs are hidden inside data-src attributes. It also adds code and main-thread work around a capability already available in current browsers. JavaScript still has a role when the product needs custom loading behaviour, but ordinary offscreen elements rarely need an entire loading framework. The decoding=”async” attribute gives the browser a preference about image decoding. Its visible effect may be small for static images, so it belongs in the category of useful hints rather than foundational fixes. When an interface replaces one image with another dynamically, HTMLImageElement.decode() provides more direct control: The replacement happens after the new file is ready to render, reducing the chance of an empty frame during the swap.[MDN documentsdecode()](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/decode)and the situations where it is useful. ## Prepare the next batch before the boundary appears Native lazy-loading schedules individual files, while infinite pagination decides when the product should request another group of cards. Waiting until the final loaded row reaches the viewport exposes the API latency, rendering time, and image discovery delay in sequence. A sentinel placed near the end of the loaded feed can trigger the next page earlier: The loading guard matters because a moving sentinel can otherwise create overlapping requests. Those requests may return duplicate pages, render several batches together, and introduce a large group of image downloads at the same moment. The feed creates congestion while trying to stay ahead. The rootMargin controls the preparation distance. Its useful value depends on scroll behaviour, API latency, batch size, image weight, and the devices on which the product is used. Testing should find the smallest margin that keeps the boundary out of sight under normal conditions. Fetching many pages in advance makes the loading gap less likely, although it also increases wasted transfer, decoding work, memory use, and competition with current interactions. Backpressure keeps anticipation bounded. ## Give stable files stable identities Generated image variants work well with long cache lifetimes when every URL identifies a particular file: The response can then be cached aggressively: When the underlying image changes, the asset receives a new URL. The browser and CDN can safely continue reusing the old representation because its identity still points to the old file. Teams often shorten cache lifetimes when a URL can silently change its contents. Every visit then pays for uncertainty in the asset pipeline. Content-addressed or versioned URLs remove that ambiguity and allow the caching layer to behave predictably. The immutable directive has formal HTTP semantics described in[RFC 8246](https://www.rfc-editor.org/info/rfc8246/). The broader principle is simply that a stable representation needs a stable identity. ## Long sessions introduce DOM and memory pressure A feed may perform well during initial loading and gradually become less responsive after substantial scrolling. At that stage the page contains far more than image requests: thousands of DOM nodes, layout boxes, observers, event handlers, decoded bitmaps, and retained component state may all remain active. Native lazy-loading reduces early network work, while previously rendered cards still accumulate in the document. Style calculations and DOM mutations become more expensive as the feed grows. Returning to a background tab can also reveal how much memory the session has retained. The first response should usually be measured restraint: reasonable page sizes, bounded prefetching, efficient card components, and careful cleanup of observers or listeners. content-visibility can reduce rendering work for large offscreen sections. Full list virtualization becomes useful when long-session measurements show that DOM size is the actual constraint. Virtualization changes product behaviour and deserves testing beyond frame rate. Browser search, accessibility, scroll restoration, anchors, variable card heights, and returning from a detail page can all become more complicated when offscreen items are removed from the DOM.[web.dev’s long-list guide](https://web.dev/articles/virtualize-long-lists-react-window)describes the performance pressure that leads products toward this technique. ## Loading states should preserve the feed A useful loading state shows where content will arrive without replacing the surrounding interface. Stable card shells work well because the feed structure remains visible and already loaded content stays interactive. Image failures should remain local to the affected card. The card can keep its dimensions, metadata, and actions while offering a retry or fallback inside the media area. Restarting the entire feed for one failed image destroys context and makes a small network problem feel like a product failure. Scroll restoration matters for the same reason. Someone who opens a card and returns expects the previous position and loaded content to remain available. Reconstructing the feed from the beginning may technically load quickly, but it discards the state the person had already built through navigation. Image reveal animation also deserves restraint. A brief opacity transition can soften a dynamic replacement, while a long fade delays content that has already completed its network and decoding work. Applying the same entrance animation to every card means the effect repeats throughout the entire session. ## Measure the experience across the whole feed Lab tools such as Lighthouse and browser performance traces make controlled comparisons possible. Field measurements show how the feed behaves across real devices, connections, cache states, viewport sizes, and scrolling patterns. Both views are useful for different reasons. Core Web Vitals cover part of the experience. LCP can expose a late or poorly prioritised first image, CLS catches unstable geometry, and INP can reveal contention between rendering work and interaction. A feed also needs measurements that reflect its own interaction model. First viewport completion measures the point at which the visible cards contain their intended media rather than placeholders. LCP only describes the largest qualifying element, so several neighbouring cards may remain empty after LCP has already been recorded. Blank exposure measures how often scrolling reaches an unloaded card or the end of the current batch. This connects directly to the preparation distance and pagination schedule. Useful bytes measure how much image data was transferred before the first screen became complete, which helps reveal distant resources competing with visible ones. Selected-source accuracy compares the rendered dimensions with the files chosen through currentSrc. Long-session measurements cover memory, DOM size, frame stability, and interaction after substantial scrolling. A clean initial load can hide problems that only appear after the feed has been used for several minutes. Field data should be read as a distribution rather than a single universal number.[web.dev’s comparison of field and lab data](https://web.dev/articles/lab-and-field-data-differences)gives a useful account of why the two views differ. ## A review sequence for image-heavy feeds A practical review starts by tracing the first visible image from HTML discovery to presentation. Check when its URL becomes available, whether it is loaded eagerly, which source the browser chooses, when its geometry becomes known, and what other requests compete with it. The next pass should follow the feed during movement. Scroll quickly enough to expose the pagination boundary, inspect overlapping requests, and watch which images begin loading before they are useful. Slow connections and mid-range mobile devices tend to reveal scheduling mistakes more clearly than a local desktop connection. The final pass should cover time and failure. Continue scrolling until the DOM has grown substantially, open an item and return, suspend and restore the tab, fail several image requests, and repeat the flow with warm and cold caches. This shows whether the feed remains coherent after the ideal first-load scenario has ended. The resulting order of work is usually straightforward: expose the first images early, serve variants that fit their slots, reserve their geometry, defer distant media, prepare the next batch with bounded lead time, and control the cost of long sessions. Formats, frameworks, and browser attributes can change around that sequence without changing the method itself. Written by - [@kalkaev](https://x.com/kalkaev) --- More: [llms.txt](https://kalkaev.com/llms.txt) · [HTML page](https://kalkaev.com/writings/fast-image-feeds) · [Text view](https://kalkaev.com/agents/writings/fast-image-feeds/) --- title: "Designing a crypto onboarding flow | Ivan Kalkaev" description: "Behind the UX architecture of BlastUP's IDO flow: onboarding, wallet connection, staking, and the structural decisions that reduced drop-off by 40%." url: https://kalkaev.com/writings/blastup-crypto-onboarding-dropoff-40 --- # Designing a crypto onboarding flow July 26, 2026 · 7 min read 2024. A Notion doc with two pages of solid text. A staking flow with more branching logic than anyone expected. 40% less users bailing halfway through. The UI took a day and a half. Everything else took weeks. ## How it got to us BlastUP had designers. Working product, live economy, everything functional. But the co-founder knew us, and specifically knew that the kind of problem he had — structurally complex, full of technical constraints that create UX dead ends — was the thing we’re unreasonably good at. Road to IDO: a flow that takes a user from knowing nothing to having staked tokens and an IDO allocation, through wallet connections, a tier system nobody’s heard of, a choice between fiat and crypto payments, gas fees that technically have to be a separate transaction, and a third-party payment widget that looks like it might be a scam if you don’t frame it right. The brief was a Notion document. Two pages of continuous text explaining how it works under the hood. No states, no edge cases, no UX thinking whatsoever. That was it, that was the whole thing, everything else was our problem. ![Designing a crypto onboarding flow](https://kalkaev.com/assets/F5FnVF8OFqBUSksEFEMbj9R4Y8.avif) ![Designing a crypto onboarding flow](https://kalkaev.com/assets/P3NlhvKv5ss7ymsmvLoXiTNC04c.avif) ![Designing a crypto onboarding flow](https://kalkaev.com/assets/fTO23zaYyXoDyuR3ulyTXhiEZ7c.avif) ## Stealing from ourselves There’s a curly little arrow — decorative, does a little loop before pointing at something — that was first drawn by Vlad Pochukalin, the founder of a studio I used to work at. I liked it, used it in another project, then another, and it’s been migrating from file to file for four years now. It’s not that I’m copying an arrow. It’s that every project deposits things into a shared library — patterns, components, micro-decisions — and over time that library becomes the reason we work fast, because half the thinking on any new project has already been done somewhere else. For BlastUP, the deposit that mattered was from EZ Wallet. Den — one of our guys — had built an onboarding architecture for it that was, and I don’t say this about many things, genuinely brilliant. Left side of the screen: dynamic contextual guidance that changes with every step. Right side: the actual actions. The user is never sat down and taught. ![Designing a crypto onboarding flow](https://kalkaev.com/assets/71vTvjb5Wkft93OKop8PfdCHcxM.avif) They’re doing things and being guided simultaneously, and the seam between learning and doing doesn’t exist. We didn’t copy the screens. We took the idea that onboarding and participation should be the same thing, and rebuilt it from scratch for a completely different product. ![Designing a crypto onboarding flow](https://kalkaev.com/assets/nvayICRi8QWc28FRa1JpZVbWqo.avif) ## The part that was actually hard Normally we don’t need three weeks to think about UX on a crypto product. We’ve shipped enough of them that we could spec an NFT marketplace flow at three in the morning if someone shook us awake. The UX on most of these things is, frankly, trivial — the visual layer is where the actual craft lives. ![Designing a crypto onboarding flow](https://kalkaev.com/assets/9scCx38DUnSOnPwZxtppl09eI.avif) BlastUP was the inverse, and that’s what makes it worth telling. The visual layer came together in about a day and a half. The flow logic — the invisible part — took weeks, and it took weeks because every path through the system branched into states we hadn’t anticipated, and every state we missed was a user hitting a wall with money already committed. ![Designing a crypto onboarding flow](https://kalkaev.com/assets/sIx1mHFZMQKebSmCzENeWI9k114.png) Marie and I started by building something that looked, and I want to be precise here, like garbage. There were pieces from Kibra in it, pieces from NearWallet, chunks of Untitled UI from a kit we’d bought, elements from the Münzen widget — visually, a complete Frankenstein. But the structure underneath worked. Marie went through every screen sticking in comments — not design annotations, more like dispatches: here’s what this element does, here’s why it’s here, here’s what breaks if you remove it. We showed this beautiful disaster to the client, they approved the logic, and only then did we start making it look like something. The process was: write down every piece of information that could conceivably appear on every screen in every state. Then remove things. Then remove more things. Then take what’s left and find shorter ways to say it. The split between me and Marie: early-stage architecture was maybe 70/30 my direction. Mid-stage prototyping and the entire UI flipped heavily toward Marie. She built most of what shipped. I reviewed, redirected, caught inconsistencies. She’s not an assistant on these projects. She’s a co-author, and this specific project wouldn’t exist without her. ## Five clicks to irreversibility The thing that cut drop-off by 40% is hard to point at, because it’s not a feature — it’s a structural choice about where one thing ends and another begins. Or rather, the choice to not have that boundary at all. Standard flow: onboarding ends, real flow starts, user connects wallet, user begins participation. The problem is that the gap between “onboarding ends” and “real flow starts” is where most people leave. It’s a natural exit point — I’ve learned enough, I’ll come back later, maybe. What we built: five steps. First three are clearly onboarding — here’s how tiers work, here’s what allocation means, here are the UI elements you’ll see later, introduced now with text so they’re already familiar when they show up for real. You click “Let’s go.” Then “Great.” Then “Got it.” ![Designing a crypto onboarding flow](https://kalkaev.com/assets/ERkQz00qJ4dtilBwVx05E6zyVOg.avif) Step four looks like onboarding. Same layout, same pacing, same position for the button. It is not onboarding. You are now technically in the IDO participation flow. Step five: “Connect wallet” appears in the exact spot your thumb has been tapping for four screens. Nobody decides to participate. They just never encounter a moment that asks them to decide. ![Designing a crypto onboarding flow](https://kalkaev.com/assets/Xv3n01nP6GKldUmCvDAmKsEw.png) ## The modal that keeps its mouth shut After you connect your wallet, you choose how to pay — fiat or crypto. This shows up as a modal overlay, not a full page. This was a very deliberate, very small decision that I still think about. ![Designing a crypto onboarding flow](https://kalkaev.com/assets/ZS0cuynU0sQ0uTdYzqUI4IS0wOg.png) A full page communicates weight. It says: here is a significant decision, please pause. A modal communicates utility — quick thing, pick one, move on. At this point the user has already connected their wallet and tapped through four screens of forward motion. The last thing you want is a layout that whispers “maybe stop and think about whether you really want to do this.” The tier upsell operates on the same principle. On every relevant screen: what your current tier gets you, what the next tier would get you, and exactly how much more you’d need — calculated live from your existing staked balance, converted to fiat via API, shown right there in context. Not a popup. Not an interruption. Information that belongs where the user is already looking, arriving at the moment they’re already thinking about it. The gas fee step — technically forced, a constraint we couldn’t remove — became part of the same rhythm. Pre-warning on the screen before. The gas screen itself explains what you’re paying for. Everything presented as context for the step you’re on, never as a pitch for a step you haven’t chosen. ![Designing a crypto onboarding flow](https://kalkaev.com/assets/f2Y7wP3q4byamNcYmOI5t0wLrAk.avif) ## Surfaces The cyberpunk glow and volumetric tier cards, the shadows that make them feel like physical objects you’re picking up rather than flat images you’re selecting, the payment operator logo embedded directly in the action button so you know who’s processing your money before you tap — all of this is real craft, and all of it affects conversion. In crypto, visual confidence is spending confidence. But it was a day and a half of work on top of weeks of structural thinking, and I think that ratio — not the screens themselves — is the thing worth remembering about this project. The product that shipped looks clean and professional and glowy. The product that actually works, the one that reduced drop-off by 40%, is invisible. It’s the architecture underneath — which screen comes when, what information lives where, which moment feels like a pause and which feels like momentum, and the precise point at which onboarding stops being onboarding and starts being the thing itself, which is a point that, if we did our job right, nobody can find. Written by - [@kalkaev](https://x.com/kalkaev) --- More: [llms.txt](https://kalkaev.com/llms.txt) · [HTML page](https://kalkaev.com/writings/blastup-crypto-onboarding-dropoff-40) · [Text view](https://kalkaev.com/agents/writings/blastup-crypto-onboarding-dropoff-40/) --- title: "About cognitive load | Ivan Kalkaev" description: "Bright interfaces aren't necessarily confusing. The real cognitive load starts when people have to guess what happens next." url: https://kalkaev.com/writings/about-cognitive-load --- # About cognitive load July 16, 2026 · 4 min read Half of the rules in product design seem both oversimplified and wrong to me at the same time. The main one, the thing that makes me understand pretty quickly that we are probably not going to get anywhere, is cognitive load. I have only seen it seriously discussed in articles three or four times in my life, while I am subscribed to maybe ten different design newsletters, including paid journals and aggregators with posts, news and articles, my whole YouTube feed is full of design videos, my Twitter is full of design, so in this sense I am an absolutely ridiculous nerd and I read any kind of shit. One of my favourite genres of design content is intentionally shitty design. Reels about logos next to people’s own names, ten-dollar identities, all that. I do not watch it to make myself feel better, I just think it is interesting, because I personally know people who would choose this kind of design over mine or over the one I think is good. It is like Russian language and mathematics in school. People ask why the fuck they need this, where it will be useful in life. It will not be useful. Apart from basic education and some minimum cultural level, it is also a way to look at and perceive the world differently. Mathematics feels the world one way, Russian language another, literature another, physics another. It is the same here. For me it is an opportunity to have another prism for design. I want all of them, however many ways of looking at design there are. And cognitive load is probably the most ridiculous one. I like bright candy interfaces. I have heard from a lot of people, when they did not know who drew them and I asked for feedback, that they were too overloaded. I hear it from founders too. Not constantly, less often than I hear something good, but fairly often. Then we run tests and it turns out to be complete bullshit. The most interesting products do not give a shit about this rule. What I do not understand is where people get this from, where they read all this stuff about cognitive load, because I constantly read training articles and can count on one hand how many times I have seen it seriously discussed. Somehow everyone knows about this fucking cognitive load. The issue is not whether an interface has a lot of things in it. The issue is whether somebody can understand where they are, what they are being asked to do, and what happens after they do it. In one DeFi audit, the first important interaction was a generic “Connect Wallet” modal. The product was asking for the highest level of trust, access to somebody’s money, before it had properly explained what it was, why this person should trust it, or what they would get after connecting. Visually, it was not even a busy screen. It was just completely missing the context. After the wallet was connected, the same product showed a dashboard full of zero balances. Zero deposited, zero earned, zero everything. No clear next action, no explanation of where the person was supposed to go, no proper onboarding. The most valuable part of the screen was used to say that somebody had nothing. This is cognitive load. The same audit had more than thirty investment vaults on the main dashboard, each with APY, TVL and a bunch of other numbers, all presented with equal weight. A person who came in to make one first deposit was expected to become a yield-farming expert in thirty seconds. That is actual overload, not because there were too many colours, but because there was no curation, no hierarchy and no understanding of what this person was trying to do at that particular moment. Where can making something simpler create more problems than benefits? Almost everywhere. This obsession with reducing the number of clicks is usually what leads to weird shit. Instead of a convenient, logical, functional transfer, where a person goes into a function hub and can use the whole range of it, everything gets scattered who knows where and becomes who knows what. People also think too well of the people using their product. They see a crypto product aimed at crypto investors, people who put twenty dollars in, and assume these guys understand what they are doing. Most often, they do not. We had a case where people put real money into a token presale, and the most common question in their chat was basically: what do we do with this now, what do we do next, what button do we press. Not literally which button, there was staking and all that, but they did not understand what they were doing. They put their dollars somewhere and did not understand what was supposed to happen next. And then there is context. This is one of the most common incorrect design patterns, when people do not take the context of their product into account. Who gets there, how they get there, with what intention, what they want from it at that exact moment, whether they came from an ad or organic search. This can change absolutely everything! Written by - [@kalkaev](https://x.com/kalkaev) --- More: [llms.txt](https://kalkaev.com/llms.txt) · [HTML page](https://kalkaev.com/writings/about-cognitive-load) · [Text view](https://kalkaev.com/agents/writings/about-cognitive-load/) --- title: "Privacy | Ivan Kalkaev" description: "How this portfolio handles visitor information, messages and conversations with Blue." url: https://kalkaev.com/privacy --- # Privacy Updated 8 September 2026 This is the personal portfolio of Ivan Kalkaev. This page explains what happens to information when you visit, contact me, or use Blue, the site’s AI assistant. ## Visiting the site Framer hosts this site and provides aggregate visitor statistics, including pages viewed, referral sources, approximate country and device type. Framer’s built-in analytics do not use tracking cookies. Hosting providers may process technical information, including IP addresses, to deliver the site and protect it from abuse. ## Your browser The site uses browser storage to remember interface preferences and whether introductions have been shown. Blue keeps a short conversation history and a random session identifier in session storage for the current browser tab. You can remove this information by clearing this site’s browser data. ## Talking to Blue When you send a message, the recent conversation, current page context, detected language and a random session identifier are sent to the service that runs Blue on Vercel. Message content is processed by OpenAI to generate a reply. These providers may also retain technical or security logs under their own policies. Don’t include passwords, payment details or confidential project information in the chat. ## Contacting me If you email me or contact me through a social platform, I receive the details you choose to share and use them to respond and discuss work. Those conversations also fall under the relevant email or platform provider’s privacy policy. Correspondence may be kept for an ongoing conversation or work relationship, and where records are needed for legal or business purposes. ## Your choices You can browse without using Blue or sending me a message. Depending on the law that applies to you, you may have rights to access, correct or delete your personal information, restrict or object to processing, or complain to a data protection authority. For privacy questions or requests about information you have shared with me, email [ivanhorvud@gmail.com](mailto:ivanhorvud@gmail.com). ## Other services Links to social networks and other websites take you to services with their own privacy practices. The providers used here may process information in countries other than yours. Provider policies: [Framer](https://www.framer.com/legal/privacy-statement/) · [Vercel](https://vercel.com/legal/privacy-policy) · [OpenAI API data controls](https://developers.openai.com/api/docs/guides/your-data). - [Back to portfolio](https://kalkaev.com/) - [Back](https://kalkaev.com/) --- More: [llms.txt](https://kalkaev.com/llms.txt) · [HTML page](https://kalkaev.com/privacy) · [Text view](https://kalkaev.com/agents/privacy/)