Latest / The CTO Podcast with Fexingo: Technical Leadership, Architecture, and Engineering Org / How Figma Prevented Feature Bloat Through Design Tokens
Transcript
- Lucas: So we were looking at the numbers from Figma’s recent engineering retrospective, and one stat really jumped out. They managed to reduce code redundancy across their entire canvas component library by forty percent in just two quarters. Luna: Forty percent is massive. That usually means they had duplicate logic scattered everywhere, right? Like, same function written ten different ways because different teams didn’t talk to each other. Lucas: Exactly. And it wasn’t just about saving disk space or memory. It was about build times. Every time a developer changed a single color value in the theme, it used to trigger a full rebuild of the application bundle. That slowed down iteration cycles significantly. Luna: Right, so they weren’t just fixing bugs; they were fixing the speed at which engineers could ship features. That’s a direct productivity multiplier. Lucas: Precisely. The solution they implemented was a rigorous design token system. Instead of hard-coding hex values or spacing units into individual components, they created a single source of truth for all visual properties. Luna: I’ve seen this work in smaller startups, but at Figma’s scale, doesn’t that create a bottleneck? Who decides when a token changes? Lucas: That’s the key question. They didn’t put it in the hands of one architect. They created a cross-functional council with representatives from design, frontend engineering, and even accessibility specialists. Any change to a core token required consensus. Luna: So it’s not just a technical fix; it’s a governance model. That sounds like it would slow down decision-making initially. Lucas: It did, for the first month. But once the pipeline was set, the velocity actually increased. Engineers stopped arguing about whether a button should be slightly darker or lighter. They just used the token, and if it needed changing, the council updated it globally. Luna: Okay, so let’s dig into the mechanics. How did they handle legacy components that were already built with hardcoded styles? Lucas: They ran an automated migration script. It scanned the existing codebase, identified hardcoded style properties, and flagged them for manual review. It wasn’t a complete rewrite overnight. It was a phased rollout over six months. Luna: Six months is a long time to keep two systems running in parallel. Did they face pushback from product managers who wanted new features instead of refactoring? Lucas: They did. And this is where the CTO office had to step in. They framed it not as cleanup, but as risk reduction. Every hardcoded style was a potential bug waiting to happen during a future redesign. Luna: So they sold it as insurance. I can buy that. But what about performance? Did the abstraction layer introduce any overhead? Lucas: Actually, it improved performance. Because the tokens are resolved at compile time rather than runtime, the browser renders the UI faster. There’s less JavaScript execution involved in styling decisions. Luna: That’s interesting. So the abstraction layer is actually stripped away before the code hits the user’s device. It’s a build-time optimization. Lucas: Correct. And it made theming easier. When they launched dark mode, they didn’t have to update thousands of individual components. They just defined a new set of token values, and everything updated automatically. Luna: That’s a huge win for consistency. No more accidental light-mode text on a dark background because someone forgot to update one component. Lucas: Exactly. Visual consistency is maintained automatically. But there’s a trade-off. The council meetings became longer. People got protective of their specific design choices. Luna: Of course. Designers fight for pixels. Engineers fight for abstractions. Getting them to agree on a shared vocabulary must have been tense. Lucas: It was. They solved it by introducing data-driven metrics. If a designer proposed a new spacing unit, they had to show why it improved usability or accessibility compared to the existing standard. Luna: So it moved the debate from opinion to evidence. That’s a much healthier dynamic for a technical organization. Lucas: It is. And it prevented feature creep. Without tokens, every new feature often brought its own custom styles. With tokens, you’re forced to reuse existing patterns, which keeps the interface clean. Luna: So it acted as a guardrail against bloat. Not by blocking features, but by making it harder to introduce inconsistency. Lucas: Right. It’s a subtle distinction. You’re not saying no to innovation; you’re saying yes to scalability. The infrastructure supports growth without collapsing under its own weight. Luna: I’m curious about the onboarding aspect. Do new hires struggle to understand the token system, or does it make them faster? Lucas: Onboarding became faster. New developers don’t have to memorize fifty different spacing rules. They learn the token map, and they know exactly how to apply it. It’s a standardized language from day one. Luna: That reduces cognitive load. Less time figuring out why things look different, more time building functionality. Lucas: Yes. And it made code reviews quicker. Reviewers don’t have to nitpick style choices anymore. They focus on logic and architecture. The visual details are handled by the system. Luna: So it freed up senior engineers to do higher-level thinking. That’s a significant ROI for the initial investment. Lucas: Absolutely. The forty percent reduction in redundancy isn’t just a vanity metric. It translates to hours saved per sprint, per engineer, across the entire org. Luna: If I’m running an engineering team, what’s the first step I should take if I suspect I have this problem? Lucas: Start small. Pick one area, like buttons or form inputs. Define a strict set of tokens for those. Migrate only those components. Prove the value internally before rolling it out globally. Luna: Don’t boil the ocean. Just fix the most painful leak first. Lucas: Exactly. Get a quick win. Show the team that builds are faster and styles are consistent. Then expand from there. Luna: Makes sense. It’s about momentum. Once they see the benefit, adoption becomes easier. Lucas: Right. And you’ll find that once the foundation is solid, you can move faster on actual features because the underlying structure isn’t holding you back. Luna: So it’s not just maintenance. It’s an enabler for future growth. Lucas: Definitely. Architecture isn’t just about keeping the lights on. It’s about giving your team the runway to fly. Luna: Well said. It’s easy to ignore until it breaks, but investing early pays dividends. Lucas: Before we wrap up, if these conversations about operational efficiency and tech strategy are useful to you, the way these stay ad-free is listener support — buy me a coffee dot com slash fexingo. That's F. E. X. I. N. G. O. Luna: Yeah, we appreciate it. It helps us keep digging into these deep dives without compromising on quality. Lucas: Back to the topic though. One last thought on the token system. What happens when a business pivot requires a completely new visual identity? Luna: Does the rigid structure break, or does it adapt? Lucas: It adapts beautifully. Since everything is mapped to tokens, you can swap out the entire palette and typography set in one configuration file. The components themselves remain untouched. Luna: So the structure is decoupled from the skin. That’s true flexibility. Lucas: Exactly. You can evolve your brand without rewriting your codebase. It’s the ultimate balance of stability and agility. Luna: I wonder if other industries are starting to adopt similar tokenization strategies beyond just UI design. Lucas: Probably. Any complex system with repeated patterns benefits from a single source of truth. It’s a fundamental principle of good engineering. Luna: True. Standardization is always a win, even if it feels restrictive at first. Lucas: It is. And in the end, it’s what allows companies like Figma to scale without losing their soul.