Yevgeniy Belov

Building a code-native design tool

A design workspace for exploring interactive user flows and responsive interfaces with the same components and libraries used in production.

Loading the live workspace…
Role
Creator, designer, and developer
Companies
HP Software, then Check Point
Stack
AngularJS, then React, Puppeteer, Node.js
Scope
Workspace app, slide rendering, thumbnails, deployment
Summary

Summary

Problem

Once I owned upstream UX as well as UI, I needed to explore and compare whole flows before implementation, without giving up the fidelity I had from designing in the browser.

My contribution

I conceived, designed, and built the tool, first at HP on AngularJS, then rebuilt it from scratch at Check Point on React.

Solution

One slide-based workspace where every design state is built with the product’s own components, organized in a tree, and reviewable as a working flow.

Impact

Teams reviewed working prototypes before implementation, engineers reused CSS and code from them, and a React Flow proof of concept helped management choose a library.

Context

Context

I was responsible for interface design in a new product, within a startup-like R&D group with limited resources. Every detail represented a deliberate design decision, but important details kept disappearing between design and implementation.

Hand-drawn comparison labeled Design and Implementation, showing a detailed, measured interface design on the left and the resulting browser implementation on the right, with red callouts highlighting spacing, button shape, and uneven card height in the implementation

Small fix, big change

One day, I asked a developer to show me how to fix the spacing on an implemented page. The product used Twitter Bootstrap, and I discovered how changing something in one place could influence the interface across the entire product.

It blew my mind.

It felt as if I was touching controls that only gods were supposed to touch. I could reach into the product and change it myself. That day, the small change I made directly in the product changed me.

Four-panel comic: the designer asks a developer for help, makes a small spacing change in code, sees it affect the whole product, then stares in amazement at his glowing fingertips as interface cards float out of the screen. Captions: Show me how? One small change. Across the whole product. Wait… I did that?

Diving into web design

I became obsessed with web design. I read every magazine, blog, and article I could find and followed the web-design stars of the time.

Hand-drawn gallery of seventeen web design websites in browser windows, including Smashing Magazine, A List Apart, CSS-Tricks, Atomic Design, SMACSS, and BEM

I learned CSS, LESS, SVG, JavaScript frameworks, version control, and the tools around them. Every new thing ignited my imagination: how could I use it in my next design or improve something we had already built?

Hand-drawn gallery of SVG, CSS, LESS, AngularJS, Git, command-line tools, debugging, IDEs, compiling, Grunt, Webpack, deployment, and JSON

Designing in the browser

After several months of customizations, I decided to stop fighting Bootstrap and replace it with a CSS framework of my own. By then, I was comfortable enough with code to make designing in the browser my primary approach.

I designed and refined the UI after engineers had implemented most of the functionality, pushing changes as if I was one of the developers. We could shape the product’s real behavior, using its actual data and components.

For several years, this process worked smoothly within our agile workflow.

Hand-drawn workflow showing wireframes by a UX designer, evaluation with stakeholders and users, implementation by frontend and backend engineers, and a UI designer working in the browser
The problem

The problem

When my responsibilities expanded from UI design to include the product’s upstream UX work, the situation changed dramatically.

I needed to explore complete user flows, compare multiple directions, share proposals, gather feedback, and iterate before implementation began.

I could no longer continue working the same way.

I needed the exploratory freedom of a conventional design tool, but I wanted to preserve the flexibility, efficiency, and product fidelity I had gained by working in code.

Puzzled designer balancing collaborative exploration with code-native fidelity, comparing several reviewed user-flow directions with a component-based browser interface and three implementation alternatives
Implementation

Implementation

Making it work

The concept was straightforward. Making it work took months.

Building the first viable version involved substantial engineering work. I had to solve challenges ranging from rendering slides inside iframes and communicating with them to generating thumbnails and deploying the application.

Three hand-drawn engineering workbenches showing repeated attempts to render and communicate with an iframe slide, generate reliable thumbnails, and deploy the completed application

First working version

The result was a lightweight, slide-based design environment in which individual states could use real components, realistic content, and the specific behaviors needed to answer design questions.

Loading the live workspace…

Taking it further

The tool was proof that it was possible to do UX design in code. I was using it daily and had plans to turn it into a mature design workspace.

Hand-drawn illustration of a designer imagining a mature workspace, with a ticketing system and user testing on the left, breadcrumbs inside the workspace, and slide navigation and code inspection on the right

The rebuild

After nine years at HP, I joined Check Point, where CloudGuard was moving toward React. It was an opportunity to take the tool further while continuing to design close to the real product.

I couldn’t reuse the original implementation: it belonged to HP and relied on AngularJS and HP-specific foundations. With a different design system and frontend stack at Check Point, I rebuilt the application from scratch and added capabilities the original version had been missing.

Breadcrumbs

See where you are and jump to a parent folder.

Loading the live workspace…
How I used it

How I used it

Creating user flows

I used slide sequences to explore user flows and refine design decisions with the team.

Loading the live workspace…

Creating responsive designs

I used the tool to explore how layouts adapt to limited space, working with real components and content in the browser.

Loading the live workspace…

Evaluating third-party libraries

I used the tool to evaluate third-party libraries in the product context, testing their capabilities and how well they fit our design system.

Loading the live workspace…

Leveraging the medium

Working directly in the browser gave me more ways to solve layout and interaction problems.

Loading the live workspace…

Exploring new interactions

I used the tool to explore new interaction ideas and test their behavior directly.

Loading the live workspace…

Designing with production components

I designed with the same components and libraries used in production, shaping layouts and interactions around their actual capabilities and constraints.

Loading the live workspace…
The impact

The impact

Across HP and Check Point, the tool gave my teams working prototypes they could review, question, and refine before implementation. We could discuss how an interface behaved alongside how it looked.

At HP, front-end engineers often reused parts of my mockups in their implementation. At Check Point, they could inspect the exact components, styling, and behavior behind a design, and sometimes reuse the CSS, configuration, or code directly. More of the design intent could carry through into the product.

The prototypes also helped inform product decisions. My React Flow proof of concept showed the library working with our styling and components, helping management evaluate and choose a direction that was subsequently adopted in the product.

For me, the lasting change was in how I approached design: exploring ideas through working behavior, with the product’s capabilities and constraints close at hand.

Next case study

Designing a conversation-first interface

I designed how customers move between a conversation and its artifacts in a Check Point interface.

Read nextor press →