Visual diffing

Pixel perfect visual diff testing

Catch what standard tests
can’t “see”
Visual diffing catches pixel-level regressions that wouldn’t be noticed using standard selectors, without the time and cost of human review.
For those hard to reach test cases
Marketing & branding sites
Dashboards & data visualizations
CMS integrations
Cross-browser/device apps
VR and AR apps
News and media sites
Features that use Canvas API
Third-party embeds
Pixel-perfect requirements
Smart comparisons
AI that’s trained to identify intentional changes, and act accordingly so test runs finish faster and false-positives are eliminated.

No-noise change detection

If selector-based tests check the science, visual difference tests check the vibes — does a component or page look good and feel right? Visual diffing compares two screenshots of your application: one baseline that you know is correct, and a new one taken at the time of the test. Any difference at the pixel level is flagged.

And that’s the challenge with pixel-based comparisons: Since every little difference is detected, the tests can be extremely noisy. The inevitable single-pixel differences are usually unnoticeable and totally immaterial. They shouldn’t block a release.

With visual diffing, it’s not enough to look — you also have to understand.

Visual diffing without the noise

Other visual diffing tools flag intentional changes

An A/B test or an update from the marketing team shouldn’t block a release or waste precious dev time unless there’s really a bug.
A visual diff that's not a bug

AI with humans in the loop clears up the signal

Our AI-native test runner interprets a visual diff change before filing a bug report. If the change was intentional, the test is automatically updated by AI and a QA Wolf engineer approves it. Your developers only get real bug reports, reviewed by real humans.

How it's done

Set the scene

We capture the baseline UI

These images represent the "perfect state" of your application’s visual design.
Frame showing focus on a single element

The test target is configurable

Tests can validate whole pages or focus on individual components.

You choose an acceptable tolerance

One pixel might not be worth holding up a deployment, so each test gets an adjustable margin of error to pass.
pass (0%)
This is an interactive slider. Slide it.

Spot the difference

Capture and compare

A new screenshot is taken when the test runs, and compared to the baseline image. We calculate the percentage change, and fail the test if it's an unintentional change outside of the tolerance level.

Guaranteed accurate reports

Shifts in position, layout, and color beyond the accepted tolerance level are analyzed. The verified bug reports are shared with your team.
example bug report

Near instant AI test maintenance

Our AI knows the difference between bugs and intentional changes, and will update the baseline with approval from a human QA engineer.

Visualize the perfect app

Brand cohesion

Logos and art

Comply with usage guidelines across all applications and websites.

Colors and fonts

Ensure a consistent color scheme that matches brand specs and meets accessibility standards.

Layouts and type

Catch dangling orphans and improperly scaling containers.

Responsive layouts

Responsive layouts

Prevent changes from affecting responsive layouts on thousands of devices and OSes.

Chart and graphs

Check the whole rendered chart, or individual elements like labels and legends.

Widget positions

Verify that widgets are positioned correctly and maintain their layout.

CSS animations

Smooth animations

Ensure animations appear smoothly and consistently across different screens and states

Interactive element functionality

Check that interactive elements, such as buttons or games, function correctly and maintain visual integrity.

Complex graphics accuracy

Ensure complex graphics are displayed accurately, matching the baseline visual design.

Content-driven layout changes

Content display accuracy

Ensure all text and media content displays correctly, matching the baseline visual layout.

Plugin and widget rendering

Make sure plugins and widgets appear correctly without disrupting the visual design.

Embedded video consistency

Verify that embedded video layout matches the intended visual design.

Third-party ad placement

Ensure third-party ads are displayed correctly and do not overlap with other elements, maintaining a clean look.

iFrames

Correct content display

Ensure that content within iFrames displays correctly and works correctly with the surrounding layout.

Visual design consistency

Verify that the iFrame content matches the intended visual design without disrupting the overall site appearance.

Canvas API

Smooth animation rendering

Check that animations and graphics rendered using the Canvas API appear smoothly and consistently across different screens and states.

Interactive element functionality

Ensure that interactive elements, such as games or buttons rendered with the Canvas API, function correctly and maintain their visual integrity.

Complex graphics accuracy

Verify that complex graphics created with the Canvas API are displayed accurately, matching the baseline visual design without any distortions.

Videos

Embedded video display

Verify that embedded videos from platforms like YouTube or Vimeo appear correctly and match the intended visual design.

Layout compatibility

Ensure that videos do not interfere with the layout and maintain the site's overall look and feel.

Embedded content

Social media widget display

Check that social media widgets, such as Twitter feeds or Facebook posts, do not disrupt the site's layout and display correctly.

Third-party ad placement

Ensure third-party ads are positioned correctly and do not overlap with other site elements, maintaining a clean and professional appearance.

Plugin and widget rendering

Verify that all plugins and widgets, even those without easy DOM access, render correctly and integrate seamlessly into the site.

FAQs

Visual diffing, or visual difference testing, is a method of comparing screenshots of your web application at different stages to detect any unintended visual changes. This ensures that your application's visual appearance remains consistent across updates.

QA Wolf's visual diffing tool automatically captures screenshots of your application before and after changes are made. These screenshots are then compared pixel by pixel to identify any visual discrepancies. Testers write visual assertions to determine if the percentage of difference between the two images falls within a predefined acceptable range.

Just because something functions properly doesn’t mean it looks right, and those aesthetic regressions can be just as damaging as functional regressions. When you’re dealing with hundreds (or thousands) of pages, manual testing is impossible while a “wait and see” approach just means customers see it first.

Visual diffing is also necessary when testing apps that rely on third-party content that your team can’t control, complex graphics that have pixel-level interactions, and features that use the Canvas API.

Yes, QA Wolf's visual diffing integrates into your existing CI/CD pipeline. This allows visual tests to run automatically with each code change, providing continuous monitoring and immediate feedback on visual differences.

Almost any web application can benefit from visual diffing. It's particularly useful for branding sites, CMS integrations, data dashboards, sites with complex graphics, and third-party embeds. But it ensures visual consistency and catches issues that might be missed by manual testing, so really any site can use it.

QA Wolf uses Playwright’s visual assertions, which returns the percentage of difference between the baseline image and the actual image.  When writing the tests, testers set an acceptable range of difference for the image (typically below 1%) so any differences beyond that range result in a test failure. In addition, our testers have debugging tools at their disposal to help them create accurate tests.

When there’s a change to a webpage or component, our AI determines whether the change was intentional or not. If the AI isn’t sure, it’ll escalate to a QA engineer for additional investigation.

We recommend running visual diffing tests with every code change, pull request, or deployment. This ensures that any visual inconsistencies are caught early, maintaining the integrity of your application's visual design.

Add visual diffing to your QA process

Keep reading