Latest / Software Testing with Fexingo: QA, Automation, and Reliable Software Engineering / How Figma Stopped Testing From Killing Velocity
Transcript
- Lucas: Let's talk about the moment when software testing stops being a safety net and starts becoming a speed bump. I've been digging into how Figma has handled its scaling challenges, specifically around October nineteen twenty six, when their platform supports millions of concurrent users collaborating on complex designs. The core problem wasn't just finding bugs; it was that their visual interface is so dense with variables—color spaces, layout constraints, font rendering—that traditional unit tests were missing ninety percent of the actual user experience. Luna: That makes sense because you can't really write a unit test for 'does this canvas look right?' without getting incredibly messy. How did they even start tackling that? Lucas: They shifted toward something called property-based testing combined with visual diffing. Instead of writing a test that says 'click button A and expect result B,' they wrote tests that describe the properties of the system. Like, 'no matter what combination of fonts and colors the user picks, the text must always be readable against the background.' It’s a fundamental shift from checking specific paths to checking invariant rules. Luna: So instead of testing one hundred specific scenarios, they're testing the mathematical relationship between elements? That sounds much more scalable but also harder to debug when it breaks. Lucas: Exactly. And that's where the real innovation happened. They integrated visual diffing directly into their continuous integration pipeline. Every time a developer pushes code, the system renders the UI in a headless browser and compares it pixel-by-pixel against a baseline. If there's a deviation—even a single pixel—the test fails. It catches things like accidental margin shifts or color palette drift that logic tests would completely miss. Luna: I bet that caused some initial panic though. Developers hate it when a merge is blocked because of a tiny visual glitch they didn't even see. Lucas: It did. The first few months were rough. But what's interesting is how they managed the false positives. They introduced a concept called 'acceptable variance zones.' So if a test fails because of a sub-pixel anti-aliasing difference that doesn't affect usability, the engineer can flag it as acceptable rather than rewriting the code. It turned a binary pass/fail system into a nuanced conversation about quality versus noise. Luna: That’s a smart way to handle it. It acknowledges that perfect visual consistency isn't always possible or necessary, especially with different display technologies. Lucas: Right. And here's the key metric that changed for them: their deployment frequency doubled while their production incident rate dropped by forty percent. Usually, those two things move in opposite directions. By automating the visual checks, they removed the manual QA bottleneck that used to take three days before a release. Now, the automated suite runs in under ten minutes. Luna: Ten minutes is a huge win compared to waiting days for a human to manually click through every screen. But does this work for smaller teams who don't have the infrastructure budget? Lucas: That's the million-dollar question. The good news is that the tools have become commodity. You don't need Figma's custom engine to do visual diffing anymore. There are open-source libraries and SaaS platforms that let you capture screenshots and compare them easily. The challenge isn't the tech; it's the discipline to treat visual regressions as critical bugs, not aesthetic preferences. Luna: Yeah, I think that's the cultural piece. Most companies still treat UI bugs as low priority until they hit production. Getting buy-in to block merges over styling issues is tough. Lucas: It is. And that's why the engineering leadership at places like Figma had to make it non-negotiable. They framed it as trust. If the user can't trust that the interface looks the same as yesterday, they won't trust the data they're saving. It became a product integrity issue, not just a coding issue. Luna: I like that framing. Trust is a tangible asset in SaaS. If the UI feels broken, the perception of data loss follows immediately. Lucas: Precisely. Another layer they added was chaos engineering for the UI layer. They intentionally inject random errors into the rendering engine during staging to see if the fallback states hold up. Does the app crash, or does it gracefully show an error message? It’s about resilience, not just correctness. Luna: Injecting random errors into the UI? That sounds terrifying for a staging environment. How do they ensure it doesn't corrupt user data during those tests? Lucas: They use isolated environments with synthetic data. No real user information is involved. It’s purely about the presentation layer. They want to know if the loading spinners appear correctly, if the empty states render properly, and if the error modals are accessible. It’s granular, but it prevents the kind of silent failures that frustrate users most. Luna: Silent failures are the worst. You know the ones where the page just freezes and nothing happens? That’s usually a rendering timeout. Lucas: Exactly. And visual testing catches those too. If a component hangs, the screenshot comparison will show a frozen state versus a dynamic one. It’s a simple heuristic that works surprisingly well at scale. Luna: So, if I’m running a small startup team, what’s the first step I should take tomorrow to implement this? Do I hire a dedicated QA person? Lucas: No, don’t hire a person yet. Start by picking your top five most critical user flows. Manually take screenshots of each state today. Then, automate those five flows using a tool like Cypress or Playwright. Compare the output weekly. Once you see the drift, you’ll understand the value. Don’t try to boil the ocean. Luna: Start small, prove the value, then scale. That’s practical advice. It avoids the paralysis of trying to test everything at once. Lucas: Right. And keep in mind that as of October nineteen twenty six, the expectation for software stability is higher than ever. Users have zero tolerance for glitches. The cost of fixing a bug in production is ten times higher than in development. Automating visual checks early pays dividends later. Luna: I agree. It’s cheaper to catch a pixel misalignment in staging than to explain it to a frustrated enterprise client in Q4. Lucas: Let’s pause here for a second. I want to mention something real about how this show operates. We don’t run ads, and we don’t take sponsorship money that influences our editorial direction. What keeps us going is a small group of listeners who chip in monthly through buy me a coffee dot com slash fexingo. It covers our hosting costs and lets us keep producing deep dives like this without chasing clicks. Luna: Yeah, it’s genuinely appreciated. It allows us to spend time researching these engineering cases instead of rushing out daily news updates. Lucas: If that resonates with you, consider joining that support network. It helps us maintain the independence and depth you’re hearing right now. Anyway, back to the testing strategy. Luna: One last thought on the implementation. Did Figma face any pushback from designers who felt the engineers were over-testing the creative aspects? Lucas: Actually, the designers loved it. Initially, they were worried about constraints, but once they saw that visual testing prevented them from having to manually verify every design tweak, they embraced it. It freed up their time to focus on new features rather than hunting for layout bugs. Luna: That’s the ultimate win. When QA aligns with design goals, everyone moves faster. It stops being a policing function and becomes a collaborative quality gate. Lucas: Exactly. The best testing infrastructure is invisible. It just works. If you’re building software in twenty twenty six, you can’t afford to ignore the visual layer. It’s the face of your product. Luna: And as AI tools generate more code, ensuring the output actually renders correctly will become even more critical. Automation is the only way to keep up. Lucas: Well said. I’d love to hear from listeners who’ve tried visual regression testing. Did it save you from a disaster, or did it create new headaches? Share your stories with us. Luna: Thanks for tuning in. Keep your pipelines green and your pixels aligned.