By Kunal Rao, Chief Customer Officer, Applitools

Teams adopt Applitools to deliver results, not just run tests. That means faster releases, greater confidence in test results, and stronger engineering productivity.

Our responsibility is to ensure that value is realized consistently and without surprises.

To make that experience even stronger, we are evolving how we partner with our customers through Customer Success. The goal is simple: every customer should clearly understand what success looks like, how we are progressing toward it, and how our work together is driving meaningful outcomes for their business.

This evolution brings a more structured and proactive way of working together—built around joint planning, proactive engagement, and shared accountability.

Aligning Early on What Success Looks Like

Every good partnership starts with clarity.

Early in our relationship, we will work with you to define what success means in measurable terms. Together, we will identify your most important use cases, the outcomes you want to achieve, and the milestones that indicate progress.

These goals will be captured in a Joint Success Plan—a simple, shared framework that outlines priorities, stakeholders, timelines, and measurable outcomes. This ensures there is always a clear view of what we are working toward and how progress will be tracked.

Accelerating Time to Value

One of the most important goals of Customer Success is helping teams realize value quickly.

Rather than trying to implement everything at once, we will focus on the shortest path to meaningful impact. Our onboarding approach will prioritize your highest-value workflows and provide clear, prescriptive guidance to get them running smoothly.

This includes:

• Structured onboarding plans focused on your top use cases
• Practical enablement and proven templates based on real customer success stories
• Clear milestones that show progress toward measurable outcomes

The result is faster adoption, early wins, and a strong foundation for long-term success.

Proactive Engagement—Before Issues Become Blockers

Customer Success should not be reactive.

We are investing in better signals and monitoring to understand adoption patterns, product usage, and areas where teams might benefit from additional support.

This allows us to reach out proactively with insights, recommendations, and best practices—often before small issues become larger blockers.

Our goal is to ensure you always have the guidance you need to move forward confidently.

Clear Progress and Shared Accountability

Transparency is essential to a strong partnership.

Through our success plans and regular engagement cadence, you will always have visibility into:

• Your goals and milestones
• Current progress and upcoming priorities
• Action plans for any risks or blockers
  

We will also hold Executive Business Reviews (EBRs) to ensure alignment at the leadership level and maintain accountability on both sides. These conversations help us step back, evaluate progress, and ensure Applitools continues to support your evolving priorities. We will also share roadmap updates and gather your input as we shape the product around our customers’ needs.

Coordinated Support Across Teams

When additional expertise is needed, we will bring the right people to the table—whether from Support, Product, or Services.

Our goal is to provide a coordinated experience so you never feel like you are navigating the organization alone or repeating the same information across teams.

Instead, you will have a unified plan and a single partnership focused on your goals.

What Happens Next

Your Applitools team will work with you to confirm your success goals and establish a cadence for check-ins and value reviews tailored to your needs. Together, we will ensure that your priorities remain aligned with the outcomes you want to achieve with Applitools.

If there is a specific initiative you want to accelerate this quarter, we encourage you to share it with us. We will help you build a plan and move it forward.

Our Commitment

At Applitools, we are focused on one thing: helping you get measurable value from our product—consistently and predictably.

To support that commitment, we are building a new operating model that clarifies how we work together, how we measure progress, and how we continually improve the experience for our customers.

We will continue refining this approach based on what we learn from every engagement—your feedback, adoption patterns, support interactions, and renewal conversations.

Our promise is straightforward:
We will show up as a proactive partner, stay accountable to outcomes, and help your team realize the full value of your investment in Applitools.

Thank you for trusting us with that responsibility.

— Kunal

Kunal Rao

Chief Customer Officer, Applitools

Kunal Rao is a seasoned customer success and go-to-market executive with more than 20 years of global experience building, scaling, and transforming post-sales organizations at technology companies. Read more.

The post A New Chapter in Customer Success at Applitools appeared first on AI-Powered End-to-End Testing | Applitools.

The new Applitools Eyes 10.22 release brings Visual AI testing directly to the tools teams already use to design and develop digital experiences. This update strengthens how teams build, validate, and release with three major enhancements:

• Scale quality without slowing down delivery using the new Storybook Addon.
• Align development and design with the new Figma Plugin, bridging intent and implementation.
• Improve traceability and accountability with smarter Dashboard Optimizations for QA and leadership.

Together, these updates make visual testing faster, sharper, and more connected across the product pipeline, helping teams fully embrace shift-left testing and collaborate around a shared baseline for visual quality.

Scale Quality Without Slowing Down Delivery: Storybook Addon

Test Where You Build with the Storybook Addon

The new Storybook Addon for Applitools Eyes brings storybook visual testing directly into the development workflow. Developers can now validate UI components where they build them—no CI/CD wait times, no switching between tools.

Core Capabilities

• Run and review visual tests directly inside your component workspace.
• Approve or reject diffs inline and validate changes locally before merging.
• Leverage higher concurrency for faster feedback.
• Catch visual issues early and prevent CI failures that slow releases.

Use Case Example:
A frontend developer refactoring a shared button component runs Eyes tests directly in Storybook to verify that the update didn’t alter its appearance across the design system. By catching issues immediately, they avoid regressions on the main branch and prevent unnecessary rework later in the release cycle.

The Applitools Eyes Storybook Addon allows teams to scale quality by expanding coverage while maintaining release velocity. By embedding visual validation where developers work, organizations can expand test coverage and reduce release timelines without compromising accuracy.

See the newest features in action during the Platform Pulse webinar, coming October 22.

Align Development and Design: Figma Plugin

Bridge Design & Code with the Figma Plugin

The new Applitools Figma Plugin connects design intent with implementation through seamless Figma design testing and design-to-code comparison. Designers and developers can now validate visual consistency earlier—and with far less manual effort.

What You Can Do

• Export Figma frames directly into Eyes for automated design-to-code validation.
• Compare design-to-design versions to manage iteration cycles.
• Maintain shared baselines so designers and developers work from the same source of truth.
• Designers can validate implementations without writing code, while developers see exactly what “done” looks like.

Use Case Example:
A designer exports a component from Figma and compares it with the implemented version in Eyes to confirm that spacing, colors, and typography match the original design. Any differences appear immediately, allowing the designer and developer to resolve them early instead of during QA or after release.

This plugin bridges design and development, reducing handoff friction and review cycles. Teams gain a single source of truth for UI quality and deliver products that match design intent from concept to code.

Improve Traceability and Accountability: Dashboard Optimizations

Context-Rich Results with Dashboard Optimizations

Eyes 10.22 introduces dashboard enhancements that bring clarity and accountability to every test result. These updates help QA engineers, SDETs, and technical leaders focus on what matters most.

Key Highlights

• Commit SHA and branch info appear directly in batch details for instant traceability.
• “Required Attention First” sorting automatically surfaces unresolved and failed tests.
• Auto-grouping mirrors your Storybook structure, making results easier to navigate.
• Streamlined triage reduces noise from passed tests and accelerates review.

Use Case Example:
A QA engineer reviewing test results spots a visual regression and uses the Eyes dashboard to trace it back to the specific commit that introduced the change. With commit and branch details in context, the engineer can alert the right developer and close the feedback loop quickly.

These context-rich results strengthen accountability and compliance across teams. Organizations gain the visibility they need for auditability—particularly valuable for industries with governance or regulatory requirements.

Explore all the updates and improvements in the Eyes 10.22 Release Notes.

Broader Strategic Impact

Eyes 10.22 delivers improvements that go beyond new capabilities. Together, these updates create a foundation for stronger collaboration and faster releases across the organization:

• Align Development & Design Around a Single Source of Truth – With the Storybook addon and Figma plugin, teams collaborate around shared visual baselines.
• Scale Quality Without Slowing Delivery – Native testing inside development tools ensures visual coverage grows with velocity.
• Improve Traceability & Accountability – Git-linked context and prioritized review queues make it easier to understand, resolve, and communicate changes.
• Drive Shift-Left Adoption Across the Organization – With validation embedded where work happens, teams can catch issues earlier and release with confidence.

Quality That Scales: Visual AI for Every Team

With Applitools Eyes 10.22, teams can test where they build—bringing Visual AI testing directly into their design and development workflows. By embedding validation inside Storybook, Figma, and the Eyes dashboard, organizations can scale software quality without adding maintenance or slowing delivery. Developers, designers, and QA now share one intelligent workflow powered by Visual AI—delivering expanded test coverage, faster feedback, and less maintenance across every stage of the testing lifecycle. Learn more about Applitools Eyes.

The post Test Where You Build with Eyes 10.22: Visual AI for Storybook & Figma appeared first on AI-Powered End-to-End Testing | Applitools.

By Anand Sundaram, CEO of Applitools

I’m thrilled to share that I’ve joined Applitools as CEO.

For over a decade, I’ve admired this company for pioneering Visual AI and transforming how teams think about software quality. Applitools Eyes didn’t just make testing faster—it created an entirely new category that fundamentally changed how organizations approach quality at scale. Today, with the Applitools Intelligent Testing Platform and our Autonomous product evolving rapidly, we’re once again reshaping what’s possible.

Why I Joined Applitools

What drew me here is the rare combination of groundbreaking technology and exceptional people. Applitools has built a platform that sits at the heart of modern software delivery, helping teams validate quality at every stage—from design to deployment—and enabling them to ship with confidence.

We’re at another major inflection point. AI is transforming how software is built, tested, and delivered—at unprecedented speed and scale. Code is being generated faster than ever by both humans and machines, and quality can’t become the bottleneck. Applitools is uniquely positioned to help organizations navigate this transformation, delivering applications and services with speed, confidence, and uncompromising quality.

Looking Ahead

Over the next few weeks, I’ll be focused on listening and learning. I want to hear from our employees, customers, and partners—what excites you about Applitools, where you see opportunities, and what bold ideas we should explore together. Your insights will shape our path forward.

This is an incredible moment for Applitools. Together, we’ll build on our momentum, deepen our impact with customers, and define the future of AI-driven software quality.

Thank you to everyone who has already extended such a warm welcome. I’m honored to lead this team and excited about what we’ll accomplish together.

— Anand

Anand Sundaram

Chief Executive Officer, Applitools

Anand Sundaram is a seasoned product and technology executive with more than two decades of experience in software quality. He has held multiple senior leadership roles and founded three startups, including RSW Software, which was acquired by Teradyne and became the foundation of the Oracle Application Testing Suite. Read more.

The post A New Chapter for Applitools: CEO Anand Sundaram on Why He Joined appeared first on AI-Powered End-to-End Testing | Applitools.

Test automation is essential but often time-consuming. Writing and maintaining tests, generating reliable data, switching tools for API calls, and keeping everything aligned across environments can slow down even the best teams.

The latest updates to Applitools Autonomous, part of the broader Applitools Intelligent Testing Platform, introduce features that significantly reduce this overhead. From natural language test authoring to integrated API testing and deterministic execution, these additions help teams move faster with fewer manual steps. Alongside ongoing improvements to Applitools Eyes, the platform continues to evolve to support modern testing workflows at scale.

New Applitools Autonomous Highlights at a Glance:

• Natural language test creation powered by LLMs
• On-the-fly test data generation
• Enhanced API testing with visual builder
• Deterministic test execution (no LLMs at runtime)
• Upcoming support for mobile apps, IDE integration, and Storybook workflows

Natural Language Test Creation, Powered by LLMs

Instead of writing test steps manually or wrestling with locators, you can now describe your intent in plain English. Applitools Autonomous converts your input into executable test steps.

Autonomous interprets the instruction and adapts to your application’s context. Tests can be created by typing, recording interactions, or letting the system generate steps automatically. This approach makes test authoring more accessible, easier to maintain, and more readable across teams.

On-the-Fly Test Data Generation in Context

Need a specific persona, value range, or edge case? Autonomous now includes built-in test data generation. No external tools required.

Just describe what you need, a French fashion designer or a prime number over 1,000, and the platform generates valid, realistic data at runtime. Datasets are generated ahead of time, so test execution remains fast and predictable.

Enhanced API Testing in the Same Flow

You can now send and validate API requests directly within your test flow, using a Postman-style interface.

Author steps in several ways:

• Describe them in plain English
• Use raw HTTP or cURL
• Use the interactive UI builder

Once executed, responses can be inspected, variables extracted, and values asserted. UI, API, and visual checks all operate in a single environment—no tool switching needed.

Deterministic Execution Model for Reliable AI-Powered Tests

A standout feature of this release is the deterministic execution engine behind every test.

“You don’t need to be a prompt engineer or even a developer to scale automation. But when your test runs, it executes with the speed and reliability of code.”
— Adam Carmi, CTO and Co-founder of Applitools

Unlike some platforms that rely on live LLMs during execution—an approach that can be slow or unpredictable—Applitools separates test creation from test execution.

• LLMs assist during authoring and data generation.
• Test runs are powered by a proprietary deterministic model that ensures speed, stability, and consistent behavior.

This offers the flexibility of AI and the dependability of code, without trade-offs.

What’s Coming Next

Applitools continues to invest in both Autonomous and Eyes, with upcoming features focused on deepening cross-functional collaboration, improving performance, and expanding platform coverage.

For Applitools Autonomous:

• Native mobile app testing: Author and execute tests across devices and operating systems.
• Autonomous MCP server: Translate high-level test cases or BDD scenarios into full test flows.

For Applitools Eyes:

• Eyes MCP server: Move Visual AI directly into your workflow. Maintain, review, and run tests directly from your preferred IDE.
• Visual testing in Storybook: Approve changes directly where components are built.
• Performance improvements for component tests: Shorter pipelines and faster feedback loops.
• Figma collaboration enhancements: Sync designs and visual testing for consistent results.

Where Things Stand Now

Whether you’re building automation for the first time or looking to reduce the overhead of test maintenance, this release meets teams where they are. With natural language authoring, integrated data and API support, and a deterministic execution engine, Applitools helps teams reduce manual effort and work more confidently.

If you’re already using Applitools, now’s a great time to explore the latest features. If you’re just getting started, we invite you to see what’s possible with a free trial for you and your team.

The post Applitools Autonomous and Eyes: New AI Features, Better Execution, and What’s Next appeared first on AI-Powered End-to-End Testing | Applitools.

Have you ever encountered a situation where you try to take a screenshot, but instead of the beautifully well-crafted UI, all you’ve got is an image of a spinner/skeleton/loading screen? Handling animations and loading artifacts in visual testing can be daunting.

Don’t worry – it can happen to anyone, and we’re not here to judge you

One of the SDK engineers here at Applitools, Noam, breaks this down into a hands-on tutorial, hoping it will help you get a better understanding of the industry’s best practices around visual testing of rich and dynamic UI experiences.

Let’s dive right in!

Framework Native Solutions

Most frameworks already have different mechanisms to handle animations and loading artifacts. Keeping things simple is often the best way to achieve code stability and maintainability. Using your framework’s built-in tools would most often be the best approach.

For example:

Playwright JS

// Playwright: wait for spinner to be removed
await page.waitForSelector('.spinner', { state: 'detached' });
await eyes.check()

Cypress

// Cypress: wait for spinner to not exist
cy.get('.spinner').should('not.exist'); 
cy.eyesCheck()

Selenium JS

// Selenium: wait for spinner to be invisible
const spinnerElements = await driver.findElements(By.css('.spinner'));
if (spinnerElements.length) {
  await driver.wait(until.elementIsNotVisible(spinnerElements[0]), 5000);
}
await eyes.check()

A Common Pitfall

Even if the UI appears visually unchanged, frontend frameworks like React, Vue, and Angular may re-render elements under the hood. This can lead to stale element references, especially when capturing regions right after a DOM change.

Consider the following example:

cy.get('.main').then($el => {
  cy.get('.spinner').should('not.exist'); // spinner disappears after main was located

  cy.eyesCheckWindow({
    tag: 'main',
    target: 'region',
    element: $el, // stale reference if .main was replaced
  });
});

1. First, Cypress locates .main
2. Then, Cypress waits for the spinner to disappear
3. This example would fail (even if the new element has the exact same properties) if the main element is replaced by another element

How to avoid that?

When possible (e.g., Playwright), it’s preferred that you use locators instead of selectors. If you can’t, it’s better if you use selectors instead of DOM references (element: ‘.main’).

Videos, CSS Animations, GIFs

There are many techniques to eliminate other types of dynamic behaviour in web pages. Playwright, for example, provides a Clock API that allows pausing JavaScript time-related events (including JS-driven animations). It’s also possible to install custom CSS snippets to pause and reset CSS-related animations. Other JS specialized crafted snippets would be required for resetting GIFs, videos, and so on – you get the idea.

This never-ending cat-and-mouse game can be prevented by using Applitools Ultrafast Grid (UFG). Instead of rendering web pages on locally executed browsers, the UFG team maintains specialized logics and fine-tuned commands that ensure a stable and consistent rendering experience. While UFG offers more than just rendering stability, it’s worth noting that classic screenshots can still achieve stable results. UFG just makes it easier!

Algo-Based Solutions

If you intentionally want to capture dynamic content (e.g., animations, changes), a smarter strategy is to embrace that variability and use smart matching algorithms to compare just what you need, like those found in Applitools Eyes.

Any match level can be used for the entire screenshot or specific regions of the screen. Read more in the Match Level Best Practices tutorial. For example, algorithms like the Layout match level can drastically improve your experience with localization testing.

The waitBeforeCapture Setting

Performing wait operations can become more complicated when:

1. Testing with no-code visual testing SDKs (e.g eyes-storybook)
2. Testing with advanced Eyes features like lazyLoading and layoutBreakpoints

The waitBeforeCapture setting was invented for these types of use cases (and a few others).

This setting can receive three types of arguments:

1. Milliseconds – the simplest approach. While it’s not always the most innovative or sophisticated pattern, in many cases, it “does the trick.” In general, waiting for explicit timeouts during tests is not recommended. However, when compared to clock manipulations and code injections, sometimes the simplicity and stability is worth the longer run-time.
2. Selector – when we’re waiting for something to appear, most SDKs support passing a selector, and Applitools Eyes will automatically wait for an element that matches this selector to appear in the web page.
3. Custom function – see code example

// eyes-storybook
  waitBeforeCapture: async () => {
    while (document.querySelector('.spinner')) {
      await new Promise((resolve) => setTimeout(resolve, 100))
    }
    return true;
  }

// eyes-playwright
await eyes.check({
  name: 'my-step',
  async waitBeforeCapture() {
    await page.locator('.spinner').waitFor({state: 'hidden'})
  },
})

The waitBeforeCapture setting can be defined in your applitools.config file, in your eyes.check settings, using the Target settings builder, and in other similar places. Please refer to the documentation of the specific SDK you’re using for concrete examples.

Storybook Play Functions

A nice eyes-storybook-specific trick to achieve a desired rendering state would be a Storybook Play Function.

Applitools Eyes will run your play functions and wait for them to finish before capturing anything on the screen. Use Play Functions to navigate the story to an interesting state and wait for the story to be stable inside the play function to help Eyes understand what the best time is to capture the screenshot.

Applitools is Here to Help

We hope you’ve found this article interesting, and maybe it solved some of the most common visual testing issues you may have encountered. Go ahead and try these examples out for free with Applitools Eyes.

However, if something isn’t clear or if you’d like advice regarding the best way to incorporate visual testing into your organization, please don’t hesitate to reach out to our experts! Testing is our passion, and we’re here to help.

Quick Answers

The post Handling Animations and Loading Artifacts in Visual Testing appeared first on AI-Powered End-to-End Testing | Applitools.

Building and maintaining automated tests has always been a challenge, especially when it comes to speed, coverage, and collaboration across technical and non-technical roles.

The release of Autonomous 2.2 helps teams reduce the time and effort needed to build and maintain reliable end-to-end tests. It combines LLM-generated test steps, automatic test data generation, built-in API validation, and visual comparisons across environments so that teams can find bugs earlier and release with more confidence.

API Step Builder: Visual API Testing, No Context Switching

Applitools Autonomous has always supported API testing, but with Autonomous 2.2, creating API tests is easier and more accessible than ever.

The new API Step Builder lets you build, run, debug, and update API calls with the UI, directly in your workflow—no code or external tools required.

• Paste in raw cURL or HTTP
• Translate into readable test steps
• Add headers, cookies, auth, body, and parameters visually
• Chain responses into UI steps via variables

Supported Features:

• Full HTTP method support: GET, POST, PUT, PATCH, DELETE, etc.
• Built-in request fields for headers, cookies, authorization, body, and URL params
• Dynamic variables: Ex. use {response.body.token} or {response.body.name} like variables in downstream steps
• Support for raw cURL or HTTP input with automatic translation to English-readable steps

Whether you’re preparing state, validating backend responses, or asserting API behavior, you can now do it all in one place—with a clean, intuitive UI that works just like the rest of Autonomous.

LLM Generated Test Steps: From Business Logic to Automation in Seconds

Write test steps the way you think—in plain English. With LLM Generated Test Steps, you can simply describe your business logic (e.g., “Select Ohio from the state dropdown menu”) and Autonomous will convert it into executable steps.

Let’s say you’re testing a job application page. Instead of clicking through each form field manually, you simply type:

Submit the form as an obscure Tolkien character

Autonomous analyzes the rendered page in real-time, understands the structure and semantics, and breaks down that one line into multiple actionable steps, such as:

• Typing the name and email address
• Selecting an appropriate option from dropdown menus
• Clicking the “Submit” button

The result? A complete, readable, and editable test created in seconds—no coding, no selectors, no extra UI to learn.

Perfect for:

• Speeding up test creation during sprints
• Empowering manual testers to create automated tests
• Eliminating writer’s block in test authoring

Join our Platform Pulse webinar on July 24 to see Autonomous 2.2 in action

Test Data Generation: Realistic Input with Zero Effort

Test coverage is only as good as the data behind it. Autonomous 2.2 introduces natural language–based test data generation that instantly produces realistic data at runtime, helping with edge case coverage and state variability.

Just say what you need:

Submit the form using random data for 90’s TV dads

Autonomous parses your request, uses LLMs to create diverse, high-quality data, and injects it directly into your test. Each run can generate fresh values—so no two executions are the same.

Cross-Environment Visual Comparisons: One Baseline, Many Environments

Ensuring parity across environments—staging vs. prod, dev vs. QA—or locales is critical. Parameterized visual baselines allow test engineers to define and run tests using variable data while still maintaining deterministic baseline comparison.

For example, you can run the same test in different plans—one with {env}=integration, another with {env}=staging—and compare visual differences across each environment without changing a single line of test logic.

• Parameters and datasets handled automatically
• Custom flows and URL List tests supported
• Visual baselines set per unique parameter set
• Abort prevention and value prompts to ensure test validity

Parameter handling is enforced at both test and plan levels—tests abort cleanly if required values are missing, ensuring reliable execution outcomes.

Tunneling Enhancements: Instant Feedback, Zero Guesswork

Tunneling just got easier and more reliable. With tunneling enhancements, Applitools Autonomous now includes improved diagnostics, real-time tunnel status, actionable error codes, and visibility for team admins—not just account owners

Users now get real-time diagnostics:

• Is the tunnel connected?
• Which hosts is it routing?
• Are there errors, and what do they mean?

Admins now get access to error codes, logs, host mapping, and verification checks—all without reaching out to support.

The Bottom Line

Applitools Autonomous 2.2 turns plain English into production-grade automation. Whether you’re testing UI, APIs, internal systems, or staging vs. production, it removes friction that slows QA teams down.

Explore the new features in the product documentation or dive into Autonomous with a free trial.

Quick Answers

The post Applitools Autonomous 2.2: AI-Driven Testing That Thinks Like You appeared first on AI-Powered End-to-End Testing | Applitools.

For many QA teams, automation presents a challenge: how do you scale efficiently when team members have different levels of coding expertise?

Eric Terry, Senior Director of Quality Control at EVERSANA INTOUCH, shared how his team successfully adopted a hybrid automation approach—leveraging both coded and no-code automation to bridge skill gaps, improve test efficiency, and enhance collaboration.

For teams considering Applitools Autonomous, Eric’s journey offers a real-world example of how AI-powered, no-code automation can accelerate testing while making automation accessible to a broader team.

The Challenge: Skill Gaps in Testing Teams

QA teams often include a mix of experienced developers and manual testers with limited coding experience. This gap can create inefficiencies and limit test coverage.

Common challenges QA managers face:

• Manual testers want to contribute to automation but lack programming skills.
• Automation engineers spend too much time maintaining scripts rather than innovating test strategies.

Inconsistent automation practices lead to knowledge silos and increased maintenance overhead.

The Solution: An AI-Powered Hybrid Approach to Coded and No-Code Automation

Eric’s team adopted a hybrid strategy that leverages both coded and no-code automation tools, ensuring that:

• AI-powered no-code tools (like Applitools Autonomous) allow manual testers to create automated tests with minimal coding.
• Coded automation remains essential for complex test scenarios requiring deep customization.
• Teams focus on collaboration, mentorship, and upskilling rather than forcing a single approach.

Eric’s team reduced test maintenance by 40% by integrating AI-driven no-code automation while keeping developers focused on high-value coding tasks.

The Benefits of an Autonomous-First Approach

One of the biggest breakthroughs for Eric’s team was prioritizing Autonomous-first testing for repetitive and UI-driven test cases. This led to:

• Faster onboarding for manual testers wanting to contribute to automation.
• Significant reduction in test maintenance, as AI-driven automation adapted to UI changes.
• More streamlined workflows, with non-developers actively participating in automation.

Key benefits of AI-powered no-code tools:

• Faster test creation for repetitive workflows.
• Reduction in script maintenance by up to 60%.
• Empowering manual testers to contribute without coding expertise.
• Accelerated test cycles by running automated tests in parallel.

Real-World Example: EVERSANA’s No-Code Automation Success

• Challenge: The team had a mix of highly technical engineers and manual testers who wanted to contribute to automation but lacked coding skills.
• Solution: They implemented a no-code-first strategy, using Applitools Autonomous to allow non-coders to automate repetitive UI tests.
• Results: Faster test execution, reduced manual effort, and a more collaborative approach to QA.

Want to see how Applitools Autonomous can help your team bridge your skill gaps to scale test automation? Try a free trial today.

How to Get Started: Lessons from Eric Terry’s Team

For QA teams considering Applitools Autonomous, Eric’s experience provides a clear roadmap for success in scaling coded and no-code automation to boost test efficiency. His key recommendations include:

1. Encourage cross-functional collaboration – Build mentorship programs where automation engineers support manual testers.
2. Adopt an Autonomous-first mindset – Automate simple workflows first before investing time in complex scripting.
3. Leverage AI-powered tools – Use visual testing and self-healing automation to minimize maintenance effort.
4. Align automation efforts with business goals – Ensure test automation supports faster releases and higher product quality.

Learn more by watching Code or No-Code Tests? Why Top Teams Choose Both

The post How an Applitools Customer Scaled QA Automation by Bridging the Skill Gap appeared first on AI-Powered End-to-End Testing | Applitools.

Testing workflows just got an upgrade! Autonomous 2.1 simplifies end-to-end testing by offering faster test creation and maintenance while expanding mobile support. This release focuses on improving the efficiency and flexibility of your testing processes with features designed to simplify workflows, enhance modularity, and provide greater control.

Let’s explore the highlights of this release and how they can benefit your end-to-end testing. 

Key Features in Autonomous 2.1

Modular Test Design

Create a test once and reuse it across multiple workflows, eliminating the need to duplicate steps. This not only saves time but also ensures consistency and reduces the risk of errors. By enhancing reusability, this feature significantly accelerates test creation and simplifies maintenance, particularly for workflows shared across teams.

Use case example: Faster test authoring in Banking

For financial institutions, reusing a shared “User Login” test across workflows like “Fund Transfer,” “Loan Application,” and “Account Overview” simplifies test maintenance and ensures consistency. Autonomous 2.1 empowers teams to avoid recreating login steps for each flow, saving time and enhancing reliability.

Simplify Test Maintenance

Easily modularize your testing process by extracting repeated steps into standalone tests. This feature simplifies maintenance and improves by allowing your team to maintain one test and apply those updates to wherever you may be reusing extracted test flows. With fewer errors and a more streamlined test design, your team can focus on delivering quality faster.

Learn how to build no-code, autonomous end-to-end tests and explore some of these new features in our upcoming webinar, Building No-Code Autonomous End-End Tests

Record Assertions

Record assertions directly within your tests to ensure critical content is displayed accurately, without requiring manual scripting. This capability is especially valuable for localization efforts, enabling teams to validate translated content on multilingual websites. By reducing setup complexity, testers can achieve faster and more accurate validations.

Use case example: Maintain compliance with localization

On multilingual websites, recording assertions ensures translated content (e.g., terms and conditions, error messages) is displayed correctly. This is crucial for maintaining legal compliance and providing a seamless user experience in different languages.

Make Responsive Testing Easier

Ensure cross-device compatibility by configuring display viewport sizes—such as mobile, tablet, or even a custom size—directly in your custom flow tests. This ensures accurate validations across devices, making it ideal for e-commerce businesses and other industries prioritizing multi-device compatibility. Streamlining these configurations reduces setup time and ensures your users have a seamless experience across platforms and devices.

Pro tip: While Applitools Ultrafast Grid lets you run the same test across multiple browsers and devices, we recommend creating separate tests for specific screen sizes when unique screen elements, like a hamburger menu, appear only on certain viewports.

Flexibility in Test Configuration

We’ve decoupled the application and plan from individual tests, offering greater flexibility and a more intuitive workflow for configuring tests independently. You can now run tests ad-hoc—even trigger test execution via the REST API—and configure run properties like parameters, browsers, devices, and concurrency limits. This change not only enhances the user experience but also lays the groundwork for advanced capabilities in future releases, ensuring a scalable and adaptable testing environment.

And There’s More…

Autonomous 2.1 lets you navigate more intuitively with an updated interface reflecting application hierarchy and copy tests across applications while preserving reusable flows. For added security, sensitive test data like passwords is now encrypted and masked, and TOTP support for 2FA enables secure workflows with Time-Based One-Time Passwords.

Try Autonomous 2.1 for Free With Your Team

With Autonomous 2.1, you’ll experience faster test creation and simplified maintenance, particularly for workflows reused across multiple teams or applications. This release represents a significant step toward more efficient, scalable, and user-friendly testing processes.

Try out Autonomous 2.1 for free with your team and see how it can revolutionize your testing efforts.

The post Introducing Autonomous 2.1: Speed Up Testing with Modular Test Design appeared first on AI-Powered End-to-End Testing | Applitools.

Efficient, reliable visual testing is essential for teams working with Playwright. Applitools’ updated Playwright SDK simplifies integration, reduces setup time, and offers more powerful reporting. Let’s check out the new features and how they streamline your testing.

What’s New in Applitools Playwright SDK?

The updated SDK introduces improvements that let you set up and run visual tests more efficiently:

• Test Fixtures: Minimizes repetitive setup code
• CLI Onboarding: A new CLI that speeds up initial setup, and an example Visual AI test
• Config Object Setup: Auto-inserts Eyes configuration in playwright.config.js/ts
• Custom HTML Reporter: Extends Playwright’s report to include Eyes checkpoint images

Join the Playwright Visual Testing Best Practices webinar led by software architect and international speaker Cory House. Discover best practices for visual testing in Playwright to enhance UI consistency, swiftly resolve issues, and ensure seamless user experiences across platforms.

Using Test Fixtures for Simplified Visual Testing

Test fixtures streamline visual testing by automating many of the functions necessary for setup. The SDK now automatically handles Eyes.open() and Eyes.close() functions as well as the collection of all test results. With these automatic integrations, you can focus directly on creating test cases without the need for redundant code.

Enhanced Reporting with the Custom HTML Reporter

The HTML reporter is designed to make analyzing test results more intuitive. It integrates Eyes checkpoint images directly into Playwright’s report. You can approve or reject baselines all within the report without having to navigate to the Eyes dashboard. This enhanced reporting setup provides clear visual insights that make it easy to understand test outcomes without extra steps.

Advanced API Usage for Custom Testing

The SDK also supports advanced API usage for complex testing needs. This lets you create custom configurations and expand test cases for specific UI components. As your project grows, this flexibility enables you to scale visual tests seamlessly and ensure thorough visual validation across different scenarios.

Backward Compatibility and Migration Tips

The SDK also maintains backward compatibility, making it easy to transition from the previous SDK while retaining existing configurations. You are welcome to start running a few tests in both SDKs to verify functionality and gradually implement the new SDK on simpler tests before migrating critical ones.

Getting Started with the Playwright SDK

Getting started with the SDK is straightforward. First, install the SDK with npm install @applitools/eyes-playwright. Next, use the CLI tool to enter your API key with npx eyes-playwright setup, automatically updating the environment. The SDK sets up configurations and imports for you, even adding a Visual AI demo test in Applitools Eyes that you can execute right away.

The latest Applitools Playwright SDK provides a faster, simpler, and more insightful visual testing experience. Download the SDK, try the demo test, and see firsthand how it can enhance your Playwright testing workflow.

The post How to Use the Updated Applitools’ Playwright SDK for Efficient Visual Testing appeared first on AI-Powered End-to-End Testing | Applitools.

Applitools knows that you know how crucial it is to deliver flawless user experiences without spending time managing unnecessary test failures or constant updates. 

The latest Applitools Eyes release introduces new features designed to make your visual testing more efficient and faster. These features will make it easier to manage your tests, reduce manual intervention, and improve your test coverage–whether you’re part of a QA team, a developer, or a test engineer. 

Let’s dive into the top three features of Applitools Eyes 10.20.

Dynamic Match Level

Smart Handling of Variations

With Applitools Eyes 10.20, managing visual test results just got easier thanks to the new dynamic match level. This feature allows users to specify certain patterns—like dates, numbers, or email addresses—that can change without triggering test failures. It identifies specific text patterns that commonly vary, such as timestamps or transaction IDs, and ignores them during test execution.

By default, the system provides patterns like dates, phone numbers, and currency values, but users can also create custom patterns using RegEx. This level of flexibility is especially beneficial for those of you dealing with extremely dynamic content, such as real-time stock market data or dynamic ad targeting, where some elements should not cause a test to fail.

Example Use Case: Insurance policy numbers often follow specific formats but vary between users or transactions. During visual testing, these dynamically generated numbers can trigger false positives. With the new dynamic match level, you can now ignore the variability in policy numbers while still validating the rest of the content and UI.

For instance, a health insurance company has an online portal where customers can view their policies. Each policy is identified by a unique policy number formatted as “POL-XX-YYY” where “XX” and “YYY” are randomly generated for each customer. Testing tools that cannot handle identifying content patterns would cause visual tests to fail unnecessarily every time the policy number changes. However, using Dynamic Match Level lets this health insurance company’s visual testing ignore the “POL-XX-YYY” format in tests ensuring the system validates only significant UI changes.

Dynamic Region Selection

Precision with Less Effort

In addition to manually drawing regions, visual validation can now be anchored directly to DOM elements. As the page content changes now, Applitools Eyes adapts the validation region, ensuring tests don’t break due to layout shifts or content variations. Dynamic region selection allows you to set visual test regions by simply selecting elements on a web page instead of manually drawing regions, saving you time and improving accuracy.

The new dynamic method uses the underlying DOM structure, allowing for automatic region adjustments as the page content changes. If the layout or size of the elements shift, Applitools Eyes automatically adapts to the change without breaking the tests.

Why it matters: This feature is particularly useful for those of you who have apps with extremely dynamic content, where visual elements often change. Enterprise SaaS to media outlets will see the benefits of using dynamic region selection since they no longer have to worry about small shifts in UI elements, reducing the need for constant manual updates and cutting down test maintenance time significantly.

Insights Dashboards

Quantify Your Testing Success

One of the more analytical features added to Applitools Eyes 10.20 is the new Insights Dashboards for testing ROI, which provide insights into the effectiveness of your automated maintenance efforts. These dashboards display critical data on how much time you’ve saved using Applitools’ automated visual testing and maintenance tools.

The dashboards break down the number of visual validation results automatically accepted by Applitools and track the time saved through automated maintenance. This is based on the assumption that manually reviewing a page takes about two and a half minutes. By quantifying this, the dashboard helps you understand the real-world impact of automating your visual testing workflow.

Pro tip: With Insights Dashboards, you can highlight specific wins, such as reducing manual test reviews or cutting test maintenance time. If you notice test maintenance time decreasing steadily, it’s a good sign your visual testing strategy is becoming more efficient. This data can be shared during quarterly business reviews with leadership or when advocating for further automation resources.

Additional Improvements

The 10.20 release also introduces faster load times on the “Tests Requiring Attention” page—especially beneficial for teams working with large test suites. The enhanced GitHub integration means you can track baseline merges directly within the baseline history page, minimizing manual effort and improving workflow efficiency. Visit the Applitools Eyes 10.20 release notes to see everything that’s included.

To Wrap Up…

One of the biggest hurdles in the day-to-day work for anyone involved in QA is dealing with flaky tests caused by constantly changing text, like dates or order numbers, and shifting UI elements, like buttons that move slightly depending on screen size. Your users expect flawless experiences. 

The Applitools Eyes 10.20 release is packed with features that simplify and streamline the visual testing process, from dynamic region selection to enhanced match levels and improved performance. These updates will help your team reduce manual test maintenance, increase test coverage, and measure the ROI of your testing efforts more effectively. Whether you’re managing complex web applications or handling high volumes of test data, these features are designed to make your workflow faster and more efficient.

The post Easier Test Maintenance for Dynamic Content with Applitools Eyes 10.20 appeared first on AI-Powered End-to-End Testing | Applitools.