Latest / Software Testing with Fexingo: QA, Automation, and Reliable Software Engineering / How Figma Prevented UI Collapse
Transcript
- Lucas: There is a specific kind of silence that happens in software companies right before a product launch, and it usually has nothing to do with technical bugs. It is the silence of assumptions. Today we are looking at a case from mid-September where a large consumer-facing platform almost launched a new checkout flow that looked perfect in the design tool but functioned completely differently in the browser. Luna: So the design was accurate, but the implementation drifted? That sounds like a classic handoff problem rather than a code defect. Lucas: Exactly. The engineering team had built the components using the correct variable names from the design system, but they ignored the spacing tokens. On desktop, the extra margin didn't matter. On mobile, it pushed the primary action button off-screen on half the devices. They caught it three hours before go-live, but the cost was roughly two hundred thousand dollars in delayed revenue and an emergency patch cycle. Luna: Two hundred thousand for a margin error seems steep, but if it blocks conversion, it is real money. Did they blame the designers or the engineers? Lucas: They blamed the QA process. And honestly, the QA process was flawed. Their testers were validating against static PNG exports of the Figma file. They were checking pixels against a screenshot taken on a MacBook Pro screen size, which does not match the viewport constraints of an iPhone SE or a Samsung Galaxy A-series device. Luna: Right, so they were testing for visual fidelity in a vacuum, not functional responsiveness in context. That is like checking a car's paint job while it is parked, then driving it off a cliff. Lucas: That is a very accurate analogy. The core issue here is that most organizations still treat design files as the source of truth for aesthetics, but they treat the codebase as the source of truth for behavior. These two things diverge constantly because developers make micro-decisions about layout that designers never intended, simply to make the build compile faster. Luna: So the solution isn't just better communication between teams. It requires a structural change in how we verify the software before it hits users. Lucas: It requires what we call shadow testing. Instead of waiting for the staging environment to be approved by QA, you route a small percentage of live traffic through a parallel version of the interface that mirrors the design spec exactly, and you compare the outputs in real time. If the live code deviates from the design token values by more than a few pixels, the system flags it immediately. Luna: But doesn't running a parallel version of the UI double your infrastructure costs? Most engineering leaders would balk at that expense. Lucas: Only if you think you need to duplicate the entire backend logic. In this specific case, the shadow test only needed to render the frontend components. The data came from the same API calls, but the presentation layer was isolated. It was essentially a canary deployment for style, not for functionality. The compute cost was negligible compared to the risk of a broken checkout. Luna: I see. So you are treating the design system as a living contract that must be enforced in production, not just a static document reviewed during sprint planning. Lucas: Precisely. And this brings us to a broader point about how we measure quality. We tend to focus on whether the software works—does the button click, does the payment process? We rarely measure whether the software feels right. But in consumer tech, feeling right is often what drives retention. If the spacing feels cramped, users perceive the brand as cheap or careless, even if the transaction succeeds. Luna: That perception gap is dangerous. It means you can have a technically stable product that is commercially failing because of subtle UX friction. Have you seen other industries adopt this kind of continuous visual validation? Lucas: Financial services actually pioneered a similar approach with their trading dashboards. They realized that latency wasn't the only risk; misaligned data grids could cause traders to enter orders incorrectly. They started overlaying wireframes onto the live terminal feeds to catch any rendering glitches that might distort numbers. It turned out that font anti-aliasing differences across operating systems were causing digits to merge visually. Luna: Font anti-aliasing. That is such a tiny detail. It reminds me of how a single pixel shift in a logo can ruin a billboard campaign. Why do we accept this level of fragility in digital products? Lucas: Because we assume browsers handle rendering consistently. They don't. Every browser engine interprets CSS flexbox and grid layouts slightly differently, especially when dealing with dynamic content heights. When you add native mobile views into the mix, the variance multiplies. Without automated visual regression testing that runs on every commit, you are flying blind. Luna: So the fix is automation, but not just for unit tests. We need visual regression tests that run against the actual design tokens in a live-ish environment. Lucas: Yes. And the key is that these tests must be tied to the component library, not to individual pages. If you test a page, you are testing a specific combination of components. If you test the components themselves, you are testing the building blocks. When the e-commerce company I mentioned earlier switched to component-level shadow testing, their false positive rate dropped by eighty percent because they stopped flagging layout shifts caused by different data lengths. Luna: That makes sense. Data length variations are noise. Actual token violations are signal. Separating those two is critical for maintaining developer trust in the QA pipeline. Lucas: Trust is everything. If your QA system flags too many non-issues, engineers start ignoring it. They develop alert fatigue. By filtering for actual design token violations, you keep the signal to noise ratio high. Engineers see a red flag and know it means something substantive, like a missing padding value or a wrong color hex code. Luna: It turns QA from a gatekeeper into a guide. Instead of saying no, it says here is where you drifted from the standard. That is a much healthier dynamic for a collaborative team. Lucas: It also forces designers and engineers to speak the same language. When the test fails, it doesn't say 'the button looks wrong.' It says 'primary-button-padding-left is set to sixteen pixels instead of twenty-four.' That is objective. It removes the subjective argument about whether the space feels sufficient. Luna: Objective metrics for subjective design choices. That is the holy grail of product management. But implementing this requires buy-in from both sides. How do you convince a CTO to invest in this? Lucas: You frame it as risk mitigation for the brand. You show them the cost of the last outage. You explain that visual drift is a leading indicator of deeper architectural decay. When teams stop caring about the fine-grained details of their components, they usually stop caring about the underlying logic too. It is a symptom, not just a sign. Luna: A symptom of cultural decay masked as a cosmetic issue. I like that framing. It elevates the conversation from pixels to principles. Lucas: Exactly. And finally, I want to mention that this approach requires discipline. You cannot let the component library rot. If the design system itself is inconsistent, the shadow tests will just tell you that everything is broken. You need a dedicated design ops role whose sole job is to maintain the integrity of those tokens and ensure they match the visual output. Luna: Design ops. That role is becoming essential as our digital interfaces grow more complex. It is the bridge between the creative vision and the engineering reality. Lucas: It is. And without it, we are just guessing. We are hoping that the person who wrote the CSS read the same brief as the person who designed the mockup. Hope is not a strategy. Automation is. Luna: So the takeaway is clear: stop testing screenshots, start testing components, and let the machine handle the pixels so humans can handle the experience. Lucas: That sums it up well. Before we wrap up, I want to mention that this show is entirely listener-supported. We deliberately do not run ads on these episodes because we believe your attention deserves respect. If you want to support that choice, the link is buy me a coffee dot com slash fexingo. Luna: Yeah, your direct support keeps the lights on and the audio clean, so thank you for being part of this community. Lucas: It really does make a difference. And it allows us to dive deep into topics like this without worrying about advertiser pushback on sensitive technical details. Luna: Agreed. It gives us the freedom to talk about the messy realities of software delivery that traditional media ignores. Lucas: Back to the topic, though, I am curious if your organization has a design ops role yet, or if that responsibility is still floating somewhere between marketing and engineering. Luna: Ours is currently floating, which explains why our last release felt so disjointed. I think we need to formalize that bridge soon. Lucas: Formalizing it will save you months of rework. It is better to pay a salary now than to pay for emergency patches later. Luna: Definitely. I will bring this up in the next sprint planning meeting. Thanks for the push, Lucas. Lucas: Anytime. Let us see if we can turn that floating responsibility into a solid foundation. Until next time.