Taking ownership of a platform's design identity

How it started

We inherited a platform that wasn't designed for us

When I joined Ververica, the product we were working on had been built by our parent company, based in another continent. The UI carried their design decisions, their conventions, their patterns, the way their culture thought about hierarchy and density and interaction. It worked. It shipped and functioned. But it didn't feel like Ververica, because it wasn't built for Ververica.

As the company started targeting broader markets and building its own customer relationships, it stopped making sense to depend on a design foundation that someone else owned and that had been built for a different context. The product needed to feel like it came from us.

That realisation triggered a conversation between product design and engineering about what it would actually take to build something of our own.

The decision

Build on Ant Design, but make it entirely our own

The constraint coming in was that we needed to stay connected to Ant Design. The parent company used it and there were practical reasons to maintain some continuity. But within that constraint, we had significant room to work. The goal wasn't to skin Ant Design. It was to take it as a structural foundation and rebuild from the inside out to fit Ververica's identity, what the product actually needed, and where the company was heading.

This was a design and engineering conversation from the start. The FE team weren't handed a brief to implement. We sat down together and worked out what we actually needed, what was worth keeping from what existed, and what had to be rebuilt. That joint ownership of the decision made everything that followed easier.

How we built it

Regular sessions, shared decisions, real collaboration

The way we worked wasn't typical. Design and FE had regular sessions throughout the build, not just at handoff. I'd bring a component direction, we'd talk through the implementation, and we'd often end up somewhere neither of us had started. Some of the better decisions in the system came out of those conversations.

Getting design tokens into the production codebase was one of the more technically involved parts. Aligning on naming conventions, agreeing on how tokens would map to code, building a structure engineers could work with rather than translate from. I didn't get this right first time. Early on, the Figma token names didn't match the code conventions the FE team already had. We caught it and fixed it, but a proper working session at the start would have saved the back-and-forth.

Light and dark theme support was built into the token structure from the beginning rather than added later. That was a deliberate decision we made together early, and it paid off as the product evolved toward a cloud offering where theming became a real product requirement.

Outcome

Reflection