Latest / The CTO Podcast with Fexingo: Technical Leadership, Architecture, and Engineering Org / How Figma Scaled Design Systems Without Losing Creativity
Transcript
- Lucas: If you’ve ever tried to scale a design system in a rapidly growing tech company, you know the exact moment it stops being a toolkit and starts becoming a bottleneck. It usually happens when the team size triples, but the processes stay the same. That’s where most companies break, or they double down on control until creativity dies. Luna: Right, and Figma seems to have avoided that trap entirely. Their platform is built on real-time collaboration, which inherently resists rigid structures, yet they’ve managed to keep their codebase coherent as they’ve grown into a massive enterprise. Lucas: Exactly. And I want to focus specifically on how they handled the transition from a flat, experimental startup environment to a more structured, global operation. Most CTOs would lean into strict architecture contracts here, but Figma did something different. They leaned into what they call 'structured flexibility.' It’s not just a buzzword; it’s a specific operational model that dictates how design tokens are defined versus how components are implemented. Luna: I’ve read about that. The idea that designers own the visual language while engineers own the implementation logic, but they meet in a shared semantic layer? Lucas: Yes. Let’s unpack that semantic layer because it’s the technical heart of their approach. In many organizations, there’s a disconnect between what a designer calls a 'primary button' in Figma and what an engineer codes as 'btn-primary-v2' in React. Figma solved this by establishing a shared token system early on. These aren’t just color hex codes; they’re named variables like 'color action primary' that exist in both the design tool and the code repository. Luna: So it’s less about enforcing a style guide and more about creating a common vocabulary that both disciplines can edit? Lucas: Precisely. And the key insight is who gets to change those tokens. In traditional setups, only senior architects or lead designers might have write access. At Figma, they opened up the ability to propose changes to any contributor, but they gated the merge process behind automated checks. If a designer changes a spacing token, the CI pipeline runs visual regression tests to ensure nothing broke across three hundred other screens. Luna: That’s interesting because it shifts the burden of trust from people checking each other’s work to systems verifying consistency. It feels much more scalable. Lucas: It is, but it requires a level of discipline that many teams skip. You have to treat your design tokens like production code. That means versioning, documentation, and deprecation warnings. When Figma introduced a new dark mode, they didn’t just paint things black. They updated the underlying token definitions, and the automated suite flagged every instance where a component hadn’t adopted the new contrast ratios. Luna: So the system catches the human error before it reaches the user. That must save a huge amount of QA time. Lucas: Huge amounts. But here’s where it gets tricky for leadership. If you automate too much, you risk making the system feel like a cage. Engineers might stop experimenting because they’re afraid of breaking the pipeline. Designers might stop iterating because they don’t understand the technical constraints. Figma had to find a balance point where the guardrails were visible but not restrictive. Luna: How do you measure if the guardrails are working? Is it just about bug reports, or is there a metric for developer satisfaction? Lucas: They actually track something called 'design to dev handoff latency.' It’s the time it takes for a design spec to become a usable, tested component in the staging environment. By keeping this number low, they ensure that the design system isn’t slowing down feature development. If the latency spikes, it usually means the component library has become too complex or poorly documented. Luna: That’s a really practical metric. It ties the abstract concept of 'quality' directly to speed of delivery. Lucas: It does. And speaking of speed, let’s talk about the organizational structure that supports this. Figma doesn’t have a centralized design system team that hoards all the power. Instead, they use a federated model. There are core maintainers who set the standards, but individual product squads contribute back to the main library. Luna: Like open source? So the features team builds a widget, and then decides whether to push it upstream? Lucas: Exactly. And the incentive structure is critical here. If an engineer spends two weeks building a perfect data table component, but nobody else uses it, that’s wasted effort. Figma rewards contributions to the shared library through internal recognition and performance metrics. It signals that maintaining the commons is just as valuable as shipping new features. Luna: That’s a cultural shift. Usually, promotion is tied to what you ship, not what you maintain. Getting people to care about the plumbing requires a deliberate change in how you evaluate success. Lucas: It does. And I think that’s the hardest part for CTOs to grasp. You can buy the best tools, you can hire the smartest engineers, but if your reward system encourages siloed work, the design system will fragment. You’ll end up with five different ways to build a modal dialog across four different departments. Luna: Yeah, and then the maintenance cost explodes. Who fixes the bug in the one nobody knows about? Lucas: No one. Until it breaks in production. Which brings me to the donation segment, because this topic of maintaining infrastructure vs. building new features is exactly why we’re here. If these conversations about engineering culture and scalable architecture are useful for what you're building or running, consider supporting the show. It helps us keep producing ad-free episodes that dive deep into these operational details. You can find us at buy me a coffee dot com slash fexingo — that's F. E. X. I. N. G. O. Luna: Yeah, and honestly, keeping this network going allows us to cover cases like Figma’s federated model without rushing through them. It’s appreciated. Lucas: Thanks for listening. Now, back to the friction points. Even with a federated model, conflicts happen. What happens when a product squad needs a component urgently, but the core maintainers haven’t reviewed it yet? Luna: Do they bypass the system? Or do they wait? Lucas: They have a triage process. Critical bugs get fast-tracked, obviously. But for new features, they allow temporary forks. An engineer can branch the design system, build their component, and use it immediately. However, if that component stays in their private fork for more than a month, it triggers a review. The expectation is that if it’s good enough for one team, it should be good enough for everyone. Luna: That’s a clever soft constraint. It forces the team to justify why their solution shouldn’t be shared. Lucas: It forces them to think about reuse. And it prevents the 'not invented here' syndrome from creeping into the codebase. If you can’t explain why your widget is unique, you probably owe it to the rest of the company to contribute it back. Luna: I like that. It turns potential competition between teams into collaboration. Though, I imagine there’s still ego involved. Lucas: Always. But the data helps. When a component gets used by ten different teams, the original author gets visibility. That social capital is a powerful motivator. It’s better than any bonus program for encouraging contribution. Luna: So the system leverages vanity in a productive way. It’s basically reputation management baked into the CI/CD pipeline. Lucas: In a sense, yes. And it scales beautifully. As Figma grew, they didn’t need to hire fifty more managers to enforce quality. They just needed better tooling and clearer incentives. The tooling caught the errors, and the incentives caught the attention. Luna: It makes me wonder if other industries could apply this. Healthcare IT, maybe? Or government software? Lucas: Absolutely. Those sectors suffer even more from fragmentation. If they adopted a similar federated design system approach, even for administrative workflows, they could reduce costs and improve user experience significantly. The principles are universal. Luna: Standards enable freedom, rather than restricting it. That’s the core lesson here. Lucas: Exactly. Good boundaries create the space for creativity. Without them, you just get chaos disguised as agility. Luna: And that’s probably why so many startups fail when they try to scale too quickly. They mistake growth for progress. Lucas: Right. You can grow without getting bigger in the wrong ways. It’s about intentionality. Did you notice how Figma’s recent updates emphasize accessibility? That’s not an afterthought; it’s baked into those same token systems. Luna: Yes, the contrast ratios and font sizes are part of the same variable structure. So fixing accessibility becomes a systemic update, not a manual patch job. Lucas: Exactly. One change, everywhere. That’s the power of a well-maintained design system. It’s not just about looking consistent; it’s about acting consistently. Luna: Consistency builds trust with the user, obviously. But also with the developers who don’t have to reinvent the wheel every sprint. Lucas: Which frees them up to solve the hard problems. The ones that actually matter. I think that’s the ultimate goal for any CTO. Building infrastructure that disappears, so the team can focus on the product. Luna: Or at least, infrastructure that works so quietly you forget it’s there. Until it breaks, hopefully never. Lucas: Here’s to hoping. For now, let’s leave it there. Next week, we’re looking at how data teams are handling the rise of synthetic datasets. Stay curious.