Hydrogen was growing. The design was falling behind.
More products were being added to Hydrogen. More designers were working on different features, and more engineers were building them.
That growth was good, but it came with a problem.
Different teams were solving the same design problems in different ways. One team might use a button with a certain height and spacing, while another used something slightly different. Forms, tables, and other common elements also started to drift apart.
These differences seemed small at first. But as the product grew, they became harder to ignore.
Hydrogen was starting to feel like several products instead of one.
I worked on Poseidon to bring those experiences together and give every team a shared starting point.
We had components. We just didn't have one shared system.
The issue wasn't that we had no components. We had several versions of the same things, created by different teams at different times.
Each team was trying to get its work done. When someone needed a button, they made one. When another team needed a form, they built their own.
Over time, we ended up with differences in:
- Size and spacing
- Colours and typography
- Loading and error states
- Component behaviour
- How common patterns were built
None of these choices was necessarily wrong on its own. The problem was that they weren't connected.
We couldn't fix this by simply asking everyone to be more careful. We needed a system that made it easier to do things the same way.
How could we create one shared system that different teams could actually use?
Before building something new, I wanted to see what we already had.
I started by reviewing existing Hydrogen screens and collecting the UI elements teams were already using.
I grouped similar elements together: buttons, inputs, tables, dropdowns, modals, navigation, status indicators, and forms.
As I went through them, I found many examples of teams solving the same problem more than once. Sometimes the solutions were almost identical. Other times, they worked in completely different ways.
The audit helped us see where the biggest gaps were.
Instead of rebuilding everything from scratch, we could identify what needed to change, what could be reused, and where we needed a clearer set of rules.
That became the starting point for Poseidon.
First, we agreed on the rules.
I didn't want Poseidon to become a big collection of nice-looking components that didn't solve the underlying problem.
Before building the components, we needed to agree on the basic rules they would follow.
Colour
We created shared colour values for actions, success, warnings, errors, information, backgrounds, borders, and text.
One important decision was how we named those colours.
A name like Blue 500 describes what a colour looks like. But what happens when the brand changes or we introduce dark mode?
Blue 500
Describes what the colour looks like.
Action Primary
Describes what the colour is used for.
Instead, we used semantic names such as Action Primary. The name describes what the colour is used for, rather than what it looks like.
That meant the colour could change without forcing designers to rethink every screen that used it.
Typography
We defined shared text styles for page titles, section headings, body text, labels, supporting text, and tables.
Each style had clear rules for size, weight, and line height.
This meant designers didn't have to decide those details from scratch every time. They could use the same styles across the product.
Spacing
We also created a shared spacing scale.
Before Poseidon, similar elements could have different gaps depending on which team designed them. The new scale gave everyone a common set of values to work with.
Icons and other basics
We created shared rules for icons and other visual elements so they would feel consistent across Hydrogen.
Together, these foundations gave the components a common base. We could now build the UI without making the same decisions over and over again.
The small details needed to work the same way everywhere.
With the foundations in place, I worked on building and improving roughly 20 to 40 components for Poseidon.
But a component isn't finished just because it looks right in its default state.
What happens when it's disabled? What if something is loading? What happens when there's an error or the content is longer than expected?
We needed shared answers to these questions.
Buttons
We defined the main button types, sizes, and states, including primary, secondary, destructive, disabled, and loading.
Instead of creating a new button for every feature, designers could choose the right version from the library.
Inputs
Forms were an important part of Hydrogen, so we created reusable inputs for text, numbers, currency, search, selection, and dates.
We also defined how each input should look and behave when it was empty, focused, filled, showing an error, or disabled.
This gave designers and engineers a shared understanding of how forms should work.
Tables
Hydrogen handles a lot of business information, and tables appeared across different products.
We created shared rules for row heights, column spacing, statuses, actions, sorting, filtering, empty states, loading, and pagination.
The goal was simple: once someone learned how to use one Hydrogen table, the next one should feel familiar.
We applied the same thinking to other common elements, including badges, confirmation dialogs, date pickers, and empty states.
The result was more than a collection of components. It was a shared way to build the everyday parts of Hydrogen.
We needed to show teams how the pieces worked together.
Having reusable components was a good start, but product screens are made up of more than individual elements.
A payment flow, for example, might involve choosing a beneficiary, entering an amount, reviewing the details, confirming the payment, and seeing the result.
The components gave us the building blocks. Patterns showed teams how to use those blocks together.
We worked on common flows such as:
Onboarding
Collect information, upload documents, review, and submit.
Transactions
Search, filter, view transaction details, and take action.
Approvals
Review a request, check the details, approve or reject, and confirm the decision.
This changed how designers approached new work.
Instead of starting with a blank page and asking how to design a screen, they could first ask whether Poseidon already had a pattern that solved most of the problem.
That saved repeated work and helped different parts of Hydrogen feel more connected.
Building the system was one thing. Getting teams to use it was another.
Poseidon involved four designers and five product teams. Adoption couldn't depend on one person reminding everyone to use the library.
The system had to be useful enough to become part of their normal work.
That meant making components easy to find, giving them clear names, documenting their states, and creating patterns that solved real problems.
Naming mattered more than I expected.
When a library contains dozens of components, unclear names make it harder to find the right one.
Blue Button
Button / Primary / Medium
Red Input
Input / Currency / Error
The names described what the component was for, so designers could find what they needed without opening every option.
Design and engineering had to work together.
I worked closely with engineers to make sure the components could be built and used as intended.
We discussed things like longer text, error messages, loading states, reusable behaviour, and how the same component should work across different screens.
The Figma library was only part of the work. The components also needed to exist in code, with matching names, variants, and states.
We documented the designs alongside the code and the properties engineers needed to use each component.
That way, designers and engineers weren't working from two separate versions of the same idea. They had a shared reference for how each component should look and work.
A component was ready when the design and the implementation agreed.
We needed a better way to handle new design problems.
A design system can start well and still fall apart over time.
A team creates a one-off component to solve a problem. Another team copies it. Someone changes it to fit a different screen. Before long, there are several versions of the same thing again.
I wanted Poseidon to prevent that cycle, not just clean up the problems it had already caused.
So we established a simple approach for new UI work.
Check first.
See whether Poseidon already has something that works.
Reuse it.
Use the existing component if it solves the problem.
Improve it.
If it almost works, improve the shared component instead of creating another version.
Build something new when needed.
Not every problem will fit an existing component.
Share the improvement.
Work with engineering and add the approved solution back to Poseidon so other teams can use it.
We also defined stages for components, from experimental to stable, so teams could understand how ready a component was for wider use.
This helped Poseidon become an ongoing part of how we built Hydrogen, rather than a one-time project in Figma.
Four of the five products had moved to Poseidon.
Within six months, four out of five products had migrated to the system.
The results went beyond making the screens look more consistent.
Designers and engineers had clearer components, states, and rules to work from.
There were fewer differences between the designs and what was built.
Internal score increased from 62 to 78
Feedback on the system improved as teams started using it.
These results mattered because they showed that Poseidon was changing how the teams worked, not just how their Figma files looked.
The products were becoming more consistent, and teams had a shared starting point for new work.
A design system is only useful when people use it.
When I started Poseidon, I thought the main job was to build a library of reusable components.
I learned that the components were only part of the work.
The bigger challenge was helping different teams agree on how things should work, giving them a system they could understand, and making it easy to use in their daily work.
Four designers and five product teams had different needs and priorities. Poseidon gave them a shared starting point without asking every team to solve the same problems again.
It also taught me that a design system needs care after launch. Components need clear ownership, changes need to be shared, and new solutions need to make their way back into the system.
The biggest shift was in how we approached new work.
Before
How should we build this?
After
How does Hydrogen already solve this?
That change helped make Hydrogen easier to design, easier to build, and more consistent as it grew.
