Treat behavior as part of the API
Components defined interaction and state—not only appearance—so product teams could depend on the same behavior across applications.
Epsilon / Design system
A shared foundation teams could extend.
I was one of Epsilon’s founding UX engineers, helping establish the discipline and grow Core UI from a side-project component library into a company-wide system for building more consistent, accessible interfaces.
- Role
- Founding UX engineer / Lead engineer
- Contribution
- System direction, component architecture, accessibility and adoption
- Status
- Company-wide design system
0→1
one of the founding UX engineers who helped establish the discipline and system foundation
Accessible
defaults for interaction, semantics and quality in shared component work
Company-wide
grew from a side project into a system used across Epsilon
The problem
Teams were solving the same interface problems alone.
Product teams needed common controls, layout patterns and accessible behavior, but the answers lived in separate applications and local decisions. That meant duplicated effort for engineers and inconsistent experiences for the people using the software.
A component library could reduce repetition. A useful system had to do more: make the intended behavior clear, connect design decisions to production code and give teams a practical way to improve the shared work.
The system
One source of shared decisions.
Core UI brought the recurring parts of product design and front-end implementation into a common foundation. Teams could start with known behavior, then spend more time on the problem that made their product distinct.
Product teams
Designers and engineers bring recurring needs, edge cases and feedback.
Core UI
A maintained source of shared design and implementation decisions.
- Design tokens
- Component APIs
- Accessible behavior
- Patterns and guidance
- Live examples
- Shared review
Product interfaces
More consistent, maintainable experiences with less duplicated work.
Key decisions
Make the right path easier to reuse.
Build accessibility into the default
Keyboard behavior, focus, semantics and contrast belonged in the shared implementation instead of becoming work every product team had to rediscover.
Keep design and code connected
Tokens, documentation and live component examples gave designers and engineers a common reference for what should ship.
Make review a shared responsibility
Contribution and review practices brought product knowledge back into the system while protecting consistency and maintainability.
My contribution
I helped make design engineering a shared capability.
I helped create the foundation, practices and shared understanding that let more people produce better interface work.
Established
Epsilon’s UX Engineering discipline and a clearer place for work that joined interaction design with production implementation.
Shaped
The system direction, component patterns and technical boundaries that helped Core UI grow beyond its side-project beginnings.
Embedded
Accessible defaults and shared review practices so consistent behavior could travel with the components.
Enabled
Designers and engineers to use, discuss and extend the system instead of depending on a small group for every interface decision.
What changed
A side project became product infrastructure.
Core UI grew into a company-wide system that gives teams shared components, design tokens, accessible patterns, documentation and live implementation examples. It reduced repeated decisions while giving teams a clearer foundation for their own product work.
Core UI lasted because people could understand the decisions, use the parts in real work and help improve the foundation.