In high-velocity CI/CD environments, visual testing often exists as a “siloed” activity, disconnected from the primary test management workflow. While Applitools Autonomous delivers industry-leading AI visual validation, teams often struggle with the manual overhead of syncing these sophisticated results with a Test Management System (TMS) like PractiTest.
Without a unified workflow, teams face three critical bottlenecks:
- Data Fragmentation: Results live in separate worlds, depriving stakeholders of a single “source of truth.”
- Manual Friction: Managing hundreds of AI-driven visual tests manually invites human error and slows down release cycles.
- Information Latency: Developers lose time waiting for manual status updates instead of seeing real-time visual regression data directly within their test runs.
The Solution: A Scalable, Serverless Bridge
To eliminate these silos, we’ll walk you through an event-driven integration using AWS Lambda and DynamoDB. This architecture creates an automated “request-response” loop that scales with your enterprise’s needs by connecting Applitools and PractiTest into a unified powerhouse.
Why This Integration Elevates Your Workflow
- Asynchronous Efficiency: The bridge handles the heavy lifting. PractiTest triggers the run and moves on, while the bridge monitors the Applitools visual test until it completes its deep Visual AI analysis.
- Precise Filtering: A custom “Visual” flag in PractiTest ensures you only trigger the bridge when necessary, optimizing cloud resource consumption.
- Persistent Mapping: A DynamoDB layer tracks Applitools Run IDs against PractiTest Instance IDs, ensuring every result finds its way back to the correct test record—even during massive parallel runs.
- Unified Visibility: View visual, non-visual, and functional test results in one dashboard to enable smarter sprint planning and faster sign-offs.
The Architecture: A High-Level Look
This integration acts as a sophisticated translator between your test management strategy and your AI engine.
| Key Component | Role |
|---|---|
| PractiTest | The Command Center: Triggers test and displays the final quality verdict |
| AWS Lambda | The Orchestrator: Manages the handshake between APIs and monitors test progress |
| AWS DynamoDB | The Memory: Securely maps long-running AI sessions to their original test instances |
| Applitools Autonomous | The Brain: Performs high-fidelity AI visual validation against your baselines |
The 4-Step Execution Loop
The integration follows a seamless “request-response” loop:
- The Trigger: You click “Run” in PractiTest. If the test is flagged as visual, PractiTest fires a webhook to the AWS Lambda.
- The Handshake: Lambda records the session data in DynamoDB and instructs Applitools Autonomous to launch the specific visual scenario via REST API.
- The AI Analysis: Applitools executes the visual validation. While the Visual AI analyzes complex UI changes, a monitor function tracks the progress, ensuring the system captures the result the moment it is ready.
- The Resolution: Once the visual validation is complete, the bridge fetches the result, looks up the mapping in DynamoDB, and updates PractiTest. It even attaches a direct link to the Applitools Dashboard for deep-dive inspections.
Setup & Requirements
To implement this robust workflow, you simply need to configure a few standard components:
Infrastructure Needs
- PractiTest: Enable API-sourced tests within your project settings.
- Secure Credentials: Use your PractiTest PTToken and your Applitools API Key (we recommend storing these in AWS Secrets Manager).
- Custom Fields: Add two specific fields to PractiTest:
is_visual_test(Checkbox) andApplitools_Test_ID(Text).
Pro Tip: The
Applitools_Test_IDtells the bridge exactly which Autonomous scenario to run. You can grab this unique ID instantly from the Applitools platform with a single click.
The Result: Total Quality Confidence
By deploying this serverless bridge, you transform visual testing from a manual chore into a strategic asset. Your team gains real-time visual regression data without lifting a finger, allowing your QA experts to focus on strategy and exploration rather than status updates.
Ready to automate your visual testing workflow? Reach out to kunal.rao@applitools.com to learn more about building your serverless bridge today.
Quick Answers
The integration is achieved by building a serverless bridge using AWS Lambda and DynamoDB. PractiTest triggers a webhook that prompts the Lambda function to initiate a visual test in Applitools via API. Results are then automatically synced back to PractiTest once the AI analysis is complete.
Yes. While the deep Visual AI analysis happens within Applitools, the serverless bridge pushes the final pass/fail status and a direct URL link to the Applitools batch result into the specific PractiTest Step or Run Instance.
Yes. Because the architecture is serverless (AWS Lambda), it can scale to handle hundreds of concurrent webhooks. Each execution is independent, and the DynamoDB layer ensures no data cross-over between parallel test runs.
You can optimize cloud costs and execution speed by creating a custom checkbox field in PractiTest (e.g., is_visual_test). The AWS Lambda bridge is configured to only execute the Applitools logic if this specific flag is set to true.
It eliminates information latency. Instead of QA teams manually checking the Applitools dashboard and updating PractiTest, the status is updated automatically. This allows developers to see visual regression results instantly within the primary “Source of Truth” (the TMS).
