Latest / The CTO Podcast with Fexingo: Technical Leadership, Architecture, and Engineering Org / How Figma Solved the Merge Conflict Crisis
Transcript
- Lucas: The hardest part of scaling a design tool isn't the graphics engine or the browser compatibility—it's getting ten thousand designers and developers to edit the same codebase without stepping on each other's toes. Luna: Right, because usually when you have that kind of concurrency in software, you get merge hell. So how did Figma actually solve that? Lucas: They didn't just solve it with better git practices. They re-architected their entire deployment pipeline around what they call atomic commits. Instead of merging large batches of changes into main, every individual change is treated as an immutable unit that can be deployed independently. Luna: That sounds like a massive shift from traditional trunk-based development. Did that slow down their initial releases? Lucas: It initially felt slower, but once they built the internal platform layer to automate the validation, it became faster than ever. The key was decoupling the build process from the merge process. Luna: So the code merges are happening constantly, but the builds are isolated? That must require some serious infrastructure investment. Lucas: Exactly. And that brings us to the donation segment. If these conversations about building resilient systems are useful for what you're running, a small group of listeners supports us monthly through buy me a coffee dot com slash fexingo, and that's literally what funds making these deep dives possible. Luna: Yeah, it’s great to see ad-free content sustained by people who actually care about the craft. It keeps the focus tight. Lucas: Let's get back into the weeds of that infrastructure. Because the atomic commit model only works if your CI system can handle thousands of parallel builds per hour. Luna: I imagine the cost of those parallel builds would spiral out of control quickly if they weren't careful about resource allocation. Lucas: They were. Their platform team built a dynamic scheduler that predicts build duration based on historical data and allocates compute accordingly. It’s basically a self-healing cluster. Luna: That’s impressive. But does that level of automation introduce new risks? Like, if the scheduler fails, do deployments stall? Lucas: They designed fallbacks for that. If the intelligent scheduler detects anomalies, it reverts to a baseline capacity pool. It’s not perfect, but it prevents total gridlock. Luna: So reliability is baked into the tooling, not just hoped for. What about the developer workflow? Do engineers still feel like they’re pushing code? Lucas: They do. In fact, Figma reports that their average time from commit to production has dropped significantly since implementing this model. Developers get instant feedback on their changes. Luna: Instant feedback is everything. It reduces the cognitive load of waiting. But how do they handle versioning across different client devices? Lucas: That’s the tricky part. They use a feature flagging system that allows them to roll out new atomic units to specific percentages of users without deploying new binaries. Luna: Ah, so the binary stays stable, but the behavior changes dynamically. That’s a classic microservices pattern applied to a desktop app. Lucas: Precisely. It blurs the line between web and native delivery models. And it requires strict contract testing between the frontend and backend services. Luna: Contract testing is often overlooked until things break in production. How rigorous is their test suite for these contracts? Lucas: They run it on every single commit. If a contract test fails, the entire pipeline stops. No exceptions. It’s non-negotiable. Luna: That’s bold. Most companies tolerate flaky tests because stopping the pipeline feels too disruptive. Lucas: Figma treats test stability as a product feature. They invest heavily in fixing flakes rather than ignoring them. It pays off in trust. Luna: Trust is currency in engineering. When devs trust the pipeline, they move faster. But what happens when they need to rollback a bad atomic commit? Lucas: Rollbacks are trivial because every commit is immutable and versioned. They just point the traffic to the previous known good state. It takes seconds. Luna: That’s a huge advantage over traditional monolithic deployments where rollbacks can take hours. Does this scale to their global infrastructure? Lucas: Yes. Their edge network handles the routing, while the core logic remains consistent. It’s a distributed system problem solved with centralized controls. Luna: Centralized controls in a distributed world. That’s a delicate balance. How do they manage permissions across all these atomic units? Lucas: They use a policy engine that evaluates access rights in real-time. It’s integrated directly into the IDE, so developers know instantly if they have permission to modify a module. Luna: That prevents accidental changes before they happen. Preventative security vs reactive auditing. I like that approach. Lucas: It shifts security left. Which is exactly what modern platforms aim for. But it requires close collaboration between security and engineering teams. Luna: Collaboration is easier when the tools align. Do they share metrics with leadership to show the value of this architecture? Lucas: They track deployment frequency and lead time for changes. These metrics are public dashboards within the company. Transparency drives accountability. Luna: Public dashboards for engineering metrics. That’s rare. Usually, that data stays hidden in Jira tickets. Lucas: Hiding data creates silos. Visibility creates alignment. Figma’s culture rewards open metrics. Luna: It seems like their technical choices are deeply tied to their cultural values. You can’t separate the two. Lucas: Absolutely. Technology amplifies culture. If you want fast, safe deployments, you need a culture that values precision and collaboration. Luna: So the lesson isn't just about tools, it's about mindset. How do other companies replicate that mindset without the resources? Lucas: Start small. Pick one service. Implement atomic commits there. Measure the impact. Then expand. It’s iterative. Luna: Iterative improvement over big-bang transformations. That’s practical advice for most teams listening right now. Lucas: Exactly. You don't need Figma’s budget to start thinking atomically. You just need discipline. Luna: Discipline and the right tools. It’s a combination that’s worth pursuing. Lucas: As we look toward Q4 of 2026, will more companies adopt this atomic approach, or will legacy constraints hold them back? Luna: I suspect the pressure to ship faster will force the issue. Legacy might become the bigger risk than complexity. Lucas: A compelling thought. The future belongs to those who can iterate safely at scale.