Designing Scalable Systems Across Multiple Products
- Client
- Multi-client
- Role
- Design System Design
Product Design
Visual Design
Component System Design
Web Design
Frontend Developer - Team
- Designer
Engineer
Across multiple projects - Timeline
- 2022 to ongoing
Project Introduction
Creating reusable design foundations for fintech, community, and personal product work.
I created a set of design studies, style guides, and component libraries across multiple products including RationalFX, Solemates, and my own personal design system library.
The goal was not just to design nice-looking UI components. The goal was to create systems that could make products more consistent, easier to scale, and more practical to build.
Some of these projects involved me working mainly as the designer. Others involved both design and development, which meant I had to think beyond Figma and consider how the system would actually work when implemented.
The Starting Point
The design systems started from a simple problem: every product needed more than just polished screens.
Across different projects, I noticed that visual consistency was one of the biggest things that made a product feel professional. When typography, spacing, buttons, inputs, cards, and layouts are not consistent, the product starts to feel disconnected even if the individual screens look good.
So I started building reusable style guides and component systems for different products. The main goal was to create systems that could support real screens, real user flows, and future product growth. In other words, scalability.
From Screens to Systems
The products had different identities, but they shared a similar problem.
Without a clear system, components can easily become inconsistent. A button might look slightly different from one screen to another. Inputs might have different heights or states. Cards might use different padding. Typography might be manually styled instead of following a clear hierarchy.
For RationalFX, I studied fintech and international payment products like Wise, Revolut, Remitly, and LemFi to understand how they handled trust, transaction flows, forms, exchange rates, and financial clarity.
For Solemates, I looked at running, fitness, and community-based products such as Rocup, Nike, and Adidas to understand how they used event cards, check-ins, progress stats, leaderboards, and social motivation.
For my personal design system library, I studied broader design system references and UI libraries such as shadcn/ui, Untitled UI, Material Design, Atlassian, and Apple’s Human Interface Guidelines to understand how strong systems organize typography, colors, spacing, radius, buttons, inputs, cards, states, and documentation in a way that can be reused across different projects.
The goal was to understand familiar UI patterns, then create design systems that could support each product’s own identity.
The usual broader problem found during my research was that scalability can be really difficult.
The design challenge became:
How do we create a design system that is clear, consistent, easily adapts to multiple products, and most importantly is scalable?
My Role
I helped create the design foundations behind multiple product experiences.
For some products, I worked mainly as the designer, creating the style guide, visual direction, components, and reusable UI patterns.
For others, I worked as both the designer and developer, which meant I also had to think about implementation. I had to consider how buttons, inputs, cards, spacing, and states would translate into Webflow, HTML, CSS, or frontend components.
My work included creating typography systems, color palettes, radius rules, spacing structures, reusable components, UI states, and documentation that could support future screens.
The System Strategy
The goal was to make design decisions repeatable.
A design system is not just a collection of pretty components. It is a way to make decisions repeatable. It helps typography stay consistent, actions feel predictable, forms behave properly, and screens feel connected.
This became the design balance:
Consistent enough to scale and flexible enough to still feel branded.
System Foundations
The foundation had to come before the components.
Before creating full components, I focused on the basic visual rules that every product needed. These foundations helped create consistency across screens before any button, input, or card was designed.
Type Hierarchy
Type Hierarchy
Typography was one of the most important foundations because it controls how users scan a product. I created clear type styles for headings, body text, labels, captions, and button text. This helped reduce random text styling and made the hierarchy easier to understand across different screens.
Scalable systems
Designed to scale
From screens to systems
Functional colour
Send money abroad
Recent recipients
Every product needed more than polished screens.
Shared rules made design decisions repeatable.
Payments to new recipients need approval.
Updated 2 minutes ago · 12/200
Component architecture
GBP · EUR · 1.17
Functional Color
Functional Color
I structured colors by role. Primary colors were used for main actions. Neutral colors supported backgrounds, surfaces, borders, and text. Feedback colors were used for success, warning, error, and disabled states.
Neutral
Primary
Success
Warning
Error
Info
| Token | Light | Dark | Use |
|---|---|---|---|
--ds-text-strong | #1A1A1A | #FFFFFF | Headlines and titles |
--ds-text-body | #333333 | #D7D7D7 | Default body copy, labels |
--ds-text-sub | #767676 | #9A9A9A | Hints and supporting copy |
--ds-text-disabled | #D1D1D1 | #5E5E5E | Disabled labels |
--ds-bg-base | #FFFFFF | #111111 | Page and canvas |
--ds-bg-surface | #FFFFFF | #1C1C1C | Menus, focused fields |
--ds-bg-subtle | #F5F5F5 | #242424 | Input fills, chips |
--ds-stroke-mild | #E8E8E8 | #2A2A2A | Default component borders |
--ds-accent-base | #4E5BA6 | #717BBC | Primary buttons, links |
--ds-accent-hover | #363F72 | #9EA5D1 | Primary, hover |
--ds-accent-faint | #EAECF5 | #717BBC | Light buttons, selected tags |
--ds-focus | #0436FC | #528BFF | Focus rings, active fields |
--ds-success-base | #10B981 | #10B981 | Confirmations, passed checks |
--ds-warning-base | #F59E0B | #F59E0B | Cautions, pending |
--ds-error-base | #F04438 | #F04438 | Failures, destructive actions |
--ds-info-base | #2E90FA | #2E90FA | Tips and contextual notes |
Spacing Logic
Spacing Logic
Without spacing rules, even good UI can start to feel uneven. Cards can feel too tight, buttons can feel disconnected, and sections can lose structure. I created spacing and radius rules to make the systems feel more intentional. Components followed shared padding, gap, and radius values so they could feel consistent across different layouts.
Iconography
I use Iconsax for most of my designs.
Iconsax is one icon family with around 6,000 icons in six styles: Linear, Outline, Bold, Bulk, Broken and Two tone. Using one family keeps line weight, corner shapes and sizing consistent across every product, so icons never look borrowed from different places.
Icons sit on a 24px grid with a 1.5px stroke. They are decorative by default, and when an icon is the only label, its button carries an aria-label. See Iconsax.
Component Architecture
The components turned the foundations into reusable product pieces.
After setting the foundations, I created reusable components that could support real product screens. This included buttons, inputs, cards, navigation, badges, tags, alerts, and other interface elements. The goal was not just to create static UI pieces, but to create components that had states, hierarchy, and clear usage.
Action System
Buttons created the action hierarchy.
Primary buttons were used for the most important actions. Secondary buttons supported less dominant actions. Ghost or tertiary buttons were used for lighter actions that did not need as much visual weight.
I also created states like hover, active, disabled, and loading so the buttons could support real interactions, not just static screens.
Form Patterns
Inputs had to make data entry feel clear and reliable.
Many of the products relied on forms, reporting, onboarding, or dashboard actions, so input components were a major part of the system.
I created input states for default, focus, error, disabled, and filled conditions. I also included helper text and error messaging so users could understand what to do when entering information.
This was especially important for products like RationalFX, where users may be entering important financial data.
We’ll send the receipt here
Locked while a payment is pending
Add a note for the recipient
Must contain at least one:
- At least 1 symbol
- At least 1 uppercase character
- At least 1 lowercase character
- At least a minimum 8 characters
Enter the 6 digit code we sent you
Try 000000 to see the error state
Who should approve this payment
Supporting Elements
Small components helped make the system feel complete.
Badges, tags, alerts, dividers, empty states, tooltips, and status pills helped support the smaller moments in the interface. These elements are easy to overlook, but they make a big difference in how complete and polished a product feels. They helped communicate feedback, categories, status, and progress without overwhelming the user.
Payment sent
£2,300 is on its way to James Okoro. It should arrive today.
Why this matters
If the name is wrong, money could go to the wrong account and may not come back.
Why this matters
If the name is wrong, money could go to the wrong account and may not come back.
Approval for first payment
All payments to new recipients will require approval from the Admin
This is a hint text to help users
This is a hint text to help users
This is a hint text to help users
This is a hint text to help users
System in Context
The same system thinking had to adapt to different brands.
The products were not all the same. RationalFX, Solemates, and my personal library each needed a different visual personality and product focus.
RationalFX
RationalFX: Trust Through Structure
For RationalFX, I focused on components that supported financial actions and decision-making. This included buttons for transfer actions, input fields for forms, cards for rates and account information, and clear hierarchy for important financial content.
Personal Library
Personal Library: Reusable by Default
After working across multiple products, I started building my own personal design system library. This library became a way to organize repeated patterns I kept using across projects. Instead of starting from zero every time, I created a flexible foundation that could be adapted depending on the brand, product type, and platform.
The personal library included typography styles, color token structures, buttons, inputs, cards, navigation patterns, spacing rules, radius rules, and component variants.
Usage and Documentation
The system had to be easy to understand and reuse.
A design system is only useful if it can be understood by the people using it. I focused on organizing components with clear naming, states, variants, and usage rules. This made it easier to return to the file later, reuse components properly, and hand designs off for development. For projects where I also worked on implementation, I also considered how design tokens like spacing, radius, and colors could translate into frontend styles.
Reflection
What I learned
Good UI needs a system behind it.
This project reminded me that a polished screen is not enough. A strong product needs reusable foundations that keep the experience consistent as it grows.
Every brand needs its own system language.
RationalFX and Solemates needed different visual personalities. A design system should create consistency, but it should not make every product feel the same.
Components need states to feel real.
Buttons, inputs, cards, and forms are not complete if they only exist in one default version. Real products need hover, focus, error, active, disabled, and loading states.
Design systems make development easier.
The project worked because brand, design, motion, product, and marketing all had to connect. It showed me how important it is to design within a larger creative system, not just one screen at a time.
Systems changed how I design.
This project helped me move from designing individual screens to thinking more about structure, scalability, consistency, and long-term product use.