Qyrus Named a Leader in The Forrester Wave™: Autonomous Testing Platforms, Q4 2025 – Read More

APRIL Release Notes-Featured Image

Welcome to the April update!  

This month, we have delivered major upgrades focused on AI-driven testing, seamless CI/CD automation, and enterprise-scale performance. 

We’ve introduced Semantic LLM Evaluations in qAPI and Test Generator v2 with Memory for Web Testing. The platform can now understand the nuance of dynamic API responses and your application’s history better than ever before. 

Our new dedicated CLI and Azure DevOps plugins, combined with secure API Key authentication, make it effortless to trigger complex test suites directly from your deployment pipelines. 

We also implemented deep architectural upgrades—including Chrome DevTools Protocol (CDP) for web recording, a Java 17 Orchestrator migration, and a modernized Visual Testing v2 backend—ensure your testing is faster, highly secure, and exceptionally stable. 

Our new control features let you take command of your quality engineering with embedded Python scripting for SAP, new loop logic in web orchestrations, and consolidated summary reporting. 

Let’s explore the powerful new capabilities available on the platform this April! 

Web Testing

Context-Aware AI: Introducing Test Generator v2 with Memory! 

Web-Test Generator v2 with Memory

The Challenge:  

While our AI-powered Test Generator excels at translating user stories, Jira tickets, and ADO items into test scenarios, the resulting test steps were previously somewhat generic. Because the AI lacked specific knowledge of your application’s unique DOM and history, it had to “guess” locators and actions. This often meant testers had to spend valuable time manually tweaking the AI-generated steps to make them fully reliable and executable against their specific UI. 

The Fix:  

We are thrilled to launch the next-generation Test Generator v2 (TG V2), now fully integrated with our enhanced AI Memory! By simply providing your application URL, TG V2 taps directly into your project’s testing history. 

  • Smart Step Selection: Instead of guessing, the AI now pulls from previously executed, proven tests in your memory to construct highly accurate workflows (up to 50 steps). 
  • Streaming & Asynchronous UI: Because deep reasoning and memory retrieval take a bit more time, we’ve overhauled the UX. Scenarios stream onto your screen first, followed by sequential step generation. You can navigate away to other tasks, and a toast notification will alert you when generation is complete. You also have the power to stop the generation mid-flight. 
  • Clear Traceability: Each generated step now includes a direct reference back to the original memory step it was based on, ensuring complete transparency. 

How will it help?  

This major upgrade transforms the AI from a generic assistant into a specialized expert on your specific application. 

  • Unmatched Reliability: Tests are built using proven locators and real historical actions, drastically reducing false failures and the need for manual corrections. 
  • Multitasking Freedom: The asynchronous, background-generation design means you are never locked to a loading screen. 
  • Transparent Logic: By showing exactly which past execution the AI referenced, you can easily verify its reasoning and trust the generated scenarios. 

Rock-Solid Recording: CDP Integration for the Web Recorder! 

The Challenge:  

Recording web tests relying solely on standard DOM event listeners can sometimes be brittle. Modern, complex web applications—especially Single Page Applications (SPAs)—have intricate lifecycles, background network requests, and highly dynamic elements. Older recording methods often struggled to capture this underlying activity accurately, leading to flaky locators, missed events during page transitions, and ultimately, recorded tests that failed or stalled during replay. 

The Fix:  

We have fundamentally upgraded the engine behind our Web Recorder extension by integrating the Chrome DevTools Protocol (CDP). Instead of just monitoring the surface of the page, the recorder now communicates directly with the browser’s core architecture to capture events, inspect the DOM, and execute commands. 

How will it help?  

This deep browser integration makes your recorded tests significantly more stable and reliable from the moment you click stop. 

  • Unbreakable Locators: CDP-driven DOM inspection provides a deeper, more accurate understanding of the page structure, resulting in highly robust element identification that resists breaking when the UI changes. 
  • Flawless Event Capture: The recorder is now fully aware of the page’s lifecycle. It accurately captures network activity, reloads, and complex SPA transitions, ensuring your tests interact with the page exactly as a real user would. 
  • Reliable Replay: By utilizing CDP commands for execution, the playback of your recorded steps is incredibly consistent, eliminating the flakiness often associated with frontend-only automation. 
  • Smarter Test Generation: The integration captures richer metadata during your recording sessions, providing our engine with better context to generate and maintain your test scripts. 

Sharper Vision: Upgraded Visual Testing v2 Architecture! 

Web-Upgraded Visual Testing v2 Architecture

The Challenge:  

Visual validation is one of the most resource-intensive aspects of automated testing, requiring pixel-by-pixel comparisons and heavy image processing. As teams scale their visual test coverage across hundreds of pages and devices, legacy endpoints can sometimes become bottlenecks. Furthermore, maintaining enterprise-grade security means the underlying infrastructure must constantly evolve to stay ahead of potential vulnerabilities. 

The Fix:  

We have completely overhauled the engine powering our visual validations, officially upgrading to the Visual Testing v2 endpoint. This under-the-hood enhancement replaces our previous routing with a modernized, highly optimized, and secure backend framework that has been rigorously verified across our environments. 

How will it help?  

While you won’t see a massive change in the UI, you will experience the benefits of a much stronger foundation. 

  • Enhanced Security: The upgraded core architecture ensures that your application screenshots and visual test data are processed utilizing the latest, most stringent security standards. 
  • Rock-Solid Reliability: The v2 endpoint provides a highly stable infrastructure, significantly reducing the risk of processing bottlenecks or timeouts during massive visual regression suites. 
  • Future-Ready Performance: This modernized backend acts as a powerful launchpad, clearing the runway for faster image processing and more advanced visual AI capabilities in upcoming releases. 

Of course, here is the breakdown for this Web Testing automation update. 

Seamless Automation: API Key Authentication for CI/CD! 

The Challenge:  

Integrating automated testing into modern CI/CD pipelines (like Jenkins, GitHub Actions, or Azure Pipelines) requires robust, machine-to-machine communication. Previously, relying on UI-centric authentication models (like standard token exchanges designed for human users) for headless automation workflows often introduced unnecessary complexity. This could lead to brittle connections or token expiration headaches that might unexpectedly break your build pipelines. 

The Fix:  

We have introduced a dedicated, secure API Key architecture specifically designed for plugin executions and CI/CLI workflows. We have fundamentally decoupled machine authentication from user authentication. Moving forward, UI logins remain securely managed by Keycloak, while your automated CI systems will authenticate directly and securely with our backend microservices using robust, dedicated API keys. 

How will it help?  

This architectural upgrade ensures your automation pipelines remain resilient, secure, and incredibly easy to manage. 

  • Rock-Solid Pipelines: Purpose-built API keys eliminate the flakiness of user-session tokens, ensuring your automated tests run continuously and reliably every time your pipeline triggers. 
  • Enhanced Security: Take full control of your automation security with a dedicated lifecycle for API keys—including secure creation, strict validation, easy revocation, and built-in rate limiting. 
  • Streamlined Integrations: Effortlessly connect the platform to Jenkins, GitHub Actions, Azure Pipelines, Bitrise, and other CLI tools with a clean, straightforward authentication method. 

Code Meets Canvas: Execute Python Scripts in Desktop & SAP Tests! 

Desktop-Execute Python Scripts in Desktop

The Challenge:  

Automating legacy desktop applications and complex ERP systems like SAP often requires more than just UI interactions. Sometimes, you need to perform heavy lifting behind the scenes before a test even begins—like querying a local database, decrypting a secure file, generating complex test data, or interacting with a backend API. Previously, bridging the gap between your automated UI steps and these required backend tasks was difficult and often required managing external scripts separately from your main test flow. 

The Fix:  

We have introduced a powerful new “Execute Python Script” action directly within the Desktop Testing workflow builder. This allows you to seamlessly embed custom Python code directly into your test sequence. Notably, this powerful action can now also be utilized as the very first step in your SAP Testing scenarios. 

How will it help?  

This update unlocks limitless flexibility by bringing the full power of the Python ecosystem right into your automation canvas. 

  • Limitless Customization: Leverage Python’s massive library ecosystem to manipulate local files, parse complex data, or communicate with local servers directly within your test flow. 
  • Seamless SAP Kick-Offs: Programmatically prepare your SAP environment—such as triggering a specific BAPI, logging in via secure protocols, or staging data—before the UI automation takes over. 
  • Robust Pre- and Post-Processing: Easily handle complex setup (pre-requisites) and teardown (clean-up) tasks that are too slow or brittle to perform purely through the graphical user interface. 

Automate the Automation: CLI Plugin for Desktop Testing! 

The Challenge:  

Integrating heavy desktop application tests into modern, fast-paced CI/CD pipelines has historically been a headache. Desktop automation often felt siloed, requiring manual triggers via the platform UI or complex, custom-written API scripts to orchestrate. If your team wanted to automatically kick off a desktop regression suite immediately after a new build was deployed, the lack of a native command-line tool created unnecessary friction and delayed feedback loops. 

The Fix:  

We have officially introduced a dedicated CLI Plugin for the Desktop Testing Service. This powerful tool allows you to trigger, manage, and monitor your desktop automated tests directly from your terminal or command line, bypassing the UI entirely. 

How will it help?  

This update bridges the gap between your local desktop environments and your enterprise automation pipelines. 

  • Native CI/CD Integration: Seamlessly bake your desktop tests directly into your Jenkins, GitHub Actions, GitLab, or Azure DevOps pipelines using simple command-line executions. 
  • Unified Workflows: Bring your desktop applications up to speed with your web and API testing, ensuring every part of your ecosystem is automatically tested on every deployment. 
  • Developer-Friendly Execution: Empower developers and SDETs to kick off complex desktop automation suites locally or remotely using the command-line tools they are already comfortable with. 

Streamlined Connections: Unified Integrations Ecosystem!

The Challenge:  

Managing the flow of test data between your API testing environment and your external project tools could often feel disjointed. Previously, configuring integrations for test management systems (like Xray and TestRail) and communication channels (like Slack and Teams) involved navigating entirely different setup flows and interfaces. This fragmented experience made administrative tasks tedious and could lead to inconsistent reporting or missed notifications when critical API pipelines failed. 

The Fix:  

We have completely redesigned and unified the integration architecture for API Testing. The configuration flows for Xray, TestRail, Microsoft Teams, and Slack have been consolidated into a single, cohesive, and highly intuitive user experience. Furthermore, we have built upon our recent Jira updates to enhance the overall Jira integration flow, ensuring a seamless bridge between your API results and your issue tracking. 

 

How will it help?  

This update creates a harmonious workflow between your API test executions and your broader enterprise toolchain. 

  • Effortless Configuration: A standardized user interface means setting up, managing, and troubleshooting your third-party connections is now fast, predictable, and simple across the board. 
  • Synchronized Reporting: Keep your systems of record (Xray, TestRail) perfectly aligned with your API execution results without jumping through administrative hoops. 
  • Instant Alerting: Ensure your development and QA teams are immediately notified in their preferred workspaces (Slack or Teams) the moment API validations fail, accelerating the feedback loop. 

A Modernized View: Refreshed API Enterprise Dashboard!

The Challenge:  

As a platform evolves, maintaining a consistent user experience across all modules is critical for user efficiency. Previously, the API Enterprise dashboard may have felt slightly disconnected from the newer, modernized areas of the platform. For enterprise teams relying on this dashboard to parse massive amounts of complex execution data and metrics, a dated or inconsistent interface could create visual friction and slow down decision-making. 

The Fix:  

We have completely refreshed the API Enterprise dashboard to fully align with our latest platform-wide UI/UX design guidelines. This comprehensive update introduces modernized data visualizations, cleaner typography, streamlined layouts, and a standardized design language. 

How will it help?  

This aesthetic and functional upgrade makes managing enterprise API quality a smoother experience. 

  • Unified Experience: Enjoy a seamless, consistent look and feel as you navigate between API Testing and all other testing services on the platform, reducing cognitive load. 
  • Enhanced Clarity: The modernized visual hierarchy and cleaner layouts make it significantly easier to digest high-level enterprise metrics, success rates, and coverage data at a single glance. 
  • Intuitive Navigation: A standardized, modern interface means less time hunting for specific charts or settings, allowing your team to focus faster on the insights that matter most. 

Future-Proof Foundation: Upgraded Integration & Reporting Frameworks!

The Challenge:  

As enterprise testing operations scale, older (“legacy”) backend frameworks handling third-party connections and massive data aggregation can start to show their age. They might become slower to process requests, harder to maintain, or struggle to handle the sheer volume of execution data generated by large teams, leading to delayed enterprise reports or brittle connections to your external tools. 

The Fix:  

We have executed a massive under-the-hood structural upgrade by completely migrating our legacy integration connections and Enterprise reports onto new, highly robust backend frameworks. This modernization effort replaces older architectural bottlenecks with streamlined, enterprise-grade technology. 

How will it help?  

While this is a behind-the-scenes upgrade, the impact on your daily operations is substantial. 

  • Unshakeable Reliability: Your connections to external project management and communication tools are now significantly more stable, resilient, and less prone to dropping or timing out. 
  • Lightning-Fast Insights: Generate heavy, data-dense enterprise reports much faster, without putting unnecessary strain on the backend system. 
  • Built for the Future: This modern architecture serves as a powerful new foundation, clearing the runway for us to deliver even more advanced analytics and deeper integration capabilities in upcoming releases. 

Handle Heavyweight Apps: Reliable Multipart Uploads!

The Challenge:  

As mobile applications grow in complexity—packing in high-resolution assets, advanced SDKs, and intricate features—their build sizes (APKs, AABs, and IPAs) have skyrocketed. Previously, uploading these massive files in a single, continuous stream was risky. A minor network blip or a server timeout could cause a 2GB upload to fail at 99%, forcing you to start the agonizingly slow upload process all over again just to begin your mobile testing. 

The Fix:  

We have introduced multipart upload support for the Device Farm. This intelligent mechanism automatically breaks your large application files into smaller, manageable chunks. These chunks are uploaded efficiently and reliably to our servers, where they are seamlessly reassembled into the complete build. 

How will it help?  

This underlying infrastructure upgrade removes the friction of managing enterprise-scale mobile apps. 

  • Rock-Solid Reliability: If a network interruption occurs, only the affected chunk needs to be retried, not the entire file, guaranteeing your upload completes successfully. 
  • Support for Massive Builds: Easily bring your largest, most complex applications to the Device Farm without worrying about arbitrary file size limits or connection timeouts. 
  • Faster Time-to-Test: By eliminating the cycle of failed uploads and restarts, your mobile binaries reach the devices faster, allowing your automated and manual testing to begin sooner. 

Uninterrupted Testing: Smarter Session Management!

The Challenge:  

During extended manual testing or deep debugging sessions on real devices, testers often spend several minutes analyzing crash logs, inspecting complex DOM structures, or waiting for specific background events to trigger without actively clicking the screen. Previously, Device Farm’s idle detection could misinterpret these periods of focused analysis as inactivity. This resulted in premature session timeouts, severing the connection, wiping the device state, and forcing users to frustratingly restart their entire setup from scratch. 

The Fix:  

We have completely overhauled our idle session handling logic. The platform now accurately monitors a much broader and smarter array of user interactions—beyond just basic screen taps—to ensure your session stays alive exactly when you need it to, while still securely releasing devices that are genuinely abandoned. 

How will it help?  

This quality-of-life update removes the anxiety of sudden disconnects from your manual testing workflow. 

  • Focus Without Fear: Take the time you need to analyze logs or review network payloads without the system abruptly terminating your device connection. 
  • Preserve Test States: Avoid the massive time sink of having to constantly re-upload apps, re-authenticate, and navigate back to a specific screen state just because of a premature timeout. 
  • Smoother User Experience: Enjoy a more fluid, reliable, and frustration-free debugging environment that respects how testers actually work. 

Streamlined Workspace: Intuitive Navigation & Smart Visibility!

The Challenge:  

Previously, navigating the Device Farm during complex project setups could feel a bit cluttered. Users were often presented with a wide array of tabs, settings, and device lists all at once, some of which might not be relevant to their specific role or current task. This visual friction made configuring new projects, finding specific environments, and managing device allocations slower and less intuitive than it needed to be. 

The Fix:  

We have significantly enhanced the tab navigation and introduced intelligent visibility configurations across the Device Farm interface. The layout is now logically streamlined, providing a much smoother user experience that allows you to easily surface the exact tools, device lists, and project settings you need while keeping unnecessary elements out of the way. 

How will it help?  

This quality-of-life update makes managing your mobile testing infrastructure faster and easier on the eyes. 

  • Faster Project Setup: Spend significantly less time hunting through complex menus and more time quickly configuring your mobile test environments. 
  • Focused Workflows: Improved visibility settings mean your workspace remains clean and relevant to your immediate tasks, reducing cognitive load and administrative mistakes. 
  • Effortless Administration: A more intuitive navigation structure makes it incredibly simple to track, allocate, and manage your device inventory across multiple projects without feeling overwhelmed. 

The Big Picture: Consolidated Summary Reports!

The Challenge:  

When managing massive testing cycles across Mobility and Component services, reviewing the results of dozens of workflow and folder executions was incredibly tedious. Previously, selecting multiple reports for download resulted in a messy, heavy ZIP file containing multiple nested folders and individual report files. Testers and QA managers were forced to open each file separately, making it nearly impossible to quickly gauge aggregated KPIs, overall passing rates, or holistic quality trends across a large batch of executions. 

The Fix:  

We have introduced a powerful new “Download Summary Report” capability within the Reports section. You can now select up to 100 individual workflow and/or folder executions and seamlessly compile them into a single, unified HTML summary report. Furthermore, we’ve added a sleek, queue-style loader UI that tracks the background generation process, allowing you to queue up multiple parallel report requests without freezing your workspace. 

 

How will it help?  

This major reporting enhancement transforms scattered data into immediate, actionable intelligence. 

  • Unified KPIs: Instantly view aggregated quality metrics, filters used, and overall execution statuses compiled neatly into one single, easily shareable HTML document. 
  • Eliminate File Clutter: Say goodbye to extracting messy ZIP files and digging through dozens of individual folders just to find the data you need. 
  • Uninterrupted Workflow: The new queue-style UI allows you to trigger massive report aggregations and monitor their progress while you seamlessly continue working on other tasks within the platform. 

Under the Hood: A Faster, More Secure Orchestrator!

The Challenge:  

Managing test orchestration across massive, enterprise-scale platforms requires an incredibly robust backend infrastructure. As testing volumes grow and technology evolves, remaining on older software frameworks can introduce subtle performance bottlenecks, complicate scaling efforts during peak execution times, and delay access to the latest security protocols. 

The Fix:  

We have completed a comprehensive architectural overhaul of the core Orchestrator framework. This major modernization effort includes a full upgrade to Java 17 and Spring Boot 3.5.10, alongside a complete transition to AWS SDK v2. 

How will it help?  

While this is a strictly backend enhancement, it significantly boosts the reliability and speed of your entire testing operation. 

  • Blazing Performance: The migration to Java 17 and the latest Spring Boot architecture optimizes memory usage and processing speeds, resulting in faster test initializations and smoother orchestration logic. 
  • Enterprise-Grade Security: Running on modernized, actively supported frameworks ensures your orchestration layer is fortified with the most up-to-date security patches and compliance standards. 
  • Highly Scalable Architecture: The transition to AWS SDK v2 provides a highly efficient, non-blocking foundation, perfectly positioning the platform to effortlessly handle massive bursts of concurrent testing load as your organization continues to scale. 

Infinite Iterations: Loop Support & Optimized Canvas for Web Workflows!

TO-Loop Support-Optimized Canvas for Web Workflows

The Challenge:  

Testing complex web applications often requires executing the same sequence of actions multiple times using different sets of data—such as populating multiple rows in a data grid or verifying various user roles. Previously, orchestrating these repetitive iterations within your web workflows was cumbersome, often requiring you to duplicate nodes manually or rely on clunky workarounds. Furthermore, as these workflows grew in size and complexity, the orchestration canvas could occasionally experience performance drag, slowing down your test design process. 

The Fix:  

We have officially implemented comprehensive loop support for web workflows, alongside significant optimizations to the Canvas loading performance. You can now define, execute, and easily manage looped steps directly within your Web nodes. This powerful enhancement includes full support for creating multiple loops, complex nested loops, and seamlessly attaching loop data tables to manage inputs and outputs for every single iteration. 

How will it help?  

This update brings true programming logic and speed directly into your visual workflow builder. 

  • Effortless Data-Driven Testing: Seamlessly create and select loop data tables to feed unique inputs into each iteration, automating repetitive test sequences without cluttering your canvas with duplicated steps. 
  • Handle Complex Logic: Confidently build sophisticated, nested loop structures to accurately mirror the intricate, multi-layered behaviors of your modern web applications. 
  • Clear Visual Tracking: The Test Orchestration (TO) View has been upgraded to accurately reflect your loop structures and execution paths, making it incredibly easy to understand and debug your iterations at a glance. 
  • Snappy Performance: Enjoy a fluid, highly responsive workflow builder that loads instantly and keeps pace with your thought process, even when mapping out massive, highly complex test journeys. 

Pipeline Power: CLI & Azure Plugins for Test Orchestration!

The Challenge:  

As teams mature their continuous integration and continuous deployment (CI/CD) practices, manual testing bottlenecks become a major roadblock. Previously, triggering complex Test Orchestration (TO) workflows often required logging into the platform to initiate runs manually or building out custom, cumbersome API scripts. This created friction for engineering teams trying to achieve true, end-to-end deployment automation where tests run seamlessly alongside code builds. 

The Fix:  

We have officially introduced dedicated CLI and Azure DevOps plugins specifically designed for the Test Orchestrator. These enhancements empower you to trigger, manage, and monitor your comprehensive Qyrus TO workflows directly via command-line interfaces (using our enhanced Node CLI) or natively within your Azure pipelines. 

How will it help?  

This update bridges the gap between your complex test orchestrations and your enterprise deployment pipelines. 

  • Seamless CI/CD Integration: Bake your orchestrated testing directly into your automated pipelines, ensuring your massive, multi-service test suites run automatically with every single code commit or build. 
  • Native Azure Support: For teams heavily utilizing the Microsoft ecosystem, the new Azure plugin provides a frictionless, out-of-the-box connection to execute orchestrated tests directly from Azure DevOps without custom scripting. 
  • Developer-Friendly Execution: Empower developers and automation engineers to kick off complex testing scenarios locally or remotely using the familiar command-line tools they already use every day. 

Secure Pipelines: Token-Based Authentication for qAPI! 

The Challenge:  

Integrating API testing platforms into automated CI/CD pipelines or external developer tools often presents a security and stability challenge. Relying on standard user login sessions for headless automation is brittle, as sessions frequently expire, causing builds to fail unexpectedly. Furthermore, sharing actual user credentials across external third-party tools creates significant security vulnerabilities. 

The Fix:  

We have officially introduced robust User Token and API Key-based authentication across the qAPI platform endpoints. This enterprise-grade security enhancement has been fully verified across all environments and is now successfully deployed to production, ready for immediate use. 

How will it help?  

This update provides a secure, reliable foundation for all your external integrations. 

  • Rock-Solid CI/CD: Utilize dedicated API keys for machine-to-machine communication, ensuring your automated API testing pipelines run flawlessly without breaking due to unexpected UI session timeouts. 
  • Enhanced Security: Safely integrate qAPI with your preferred external tools and scripts without ever exposing actual user passwords or compromising account integrity. 
  • Effortless Automation: Streamline the setup of headless testing workflows with simple, secure token generation, allowing your team to focus on building rather than troubleshooting connections. 

AI Meets API: Introducing Semantic LLM Evaluations!

The Challenge:  

Traditional API testing relies heavily on deterministic assertions—like exact string matching, regex, or static JSON paths. However, as more applications integrate GenAI and natural language processing, APIs are increasingly returning highly dynamic text. When the exact phrasing of a response changes but the underlying meaning remains correct, traditional strict assertions fail. This leads to brittle tests and a high volume of false negatives, forcing QA teams to waste time manually verifying outputs. 

The Fix:  

We have introduced a powerful new “Semantic Evaluation” (LLM-as-a-judge) test type directly within your API Test Cases. This feature allows you to validate API responses based on their actual meaning and context, rather than rigid syntax. You simply provide the context, the expected output, and any optional guardrails. The system then automatically extracts the live execution output (via JSON/XML paths or a manual override) and uses an LLM to evaluate the response against your expectations. 

How will it help?  

This update bridges the gap between traditional testing and modern, dynamic applications. 

  • Test the Untestable: Easily and reliably validate dynamic text, chatbot responses, or AI-generated content without relying on fragile, hard-coded keyword matching. 
  • Deep, Intelligent Feedback: Move beyond basic binary results. Your test executions and preview panels now feature a dedicated Semantic Evaluator tab that provides a nuanced semantic relevance score and a detailed judge summary highlighting the positive and negative aspects of the response. 
  • Customized Thresholds: Maintain strict quality standards by setting configurable thresholds that determine whether the AI judge marks the evaluation as a definitive Pass, Fail, or flags it for manual Review. 
  • Seamless Workflow Integration: Build sophisticated, AI-driven assertions with minimal configuration and save them directly to your existing API test suites. 

Clearer AI Insights: LLM Model Tracking in Reports!

The Challenge:  

With the introduction of Semantic Evaluations, you now have the power to let AI judge your dynamic API responses. However, if you are experimenting with different LLM providers or versions across your test suites, reviewing an execution report without knowing exactly which model evaluated each specific test creates a blind spot. It makes it difficult to audit the AI’s decisions, compare model accuracy, or troubleshoot inconsistent evaluations across large test runs. 

The Fix:  

We have enhanced the qAPI reporting engine to explicitly capture and display the selected LLM model directly within your execution reports. Additionally, we have refined the result output terminology to ensure the AI’s feedback and evaluation status are as clear and intuitive as possible. 

How will it help?  

This update brings essential transparency and clarity to your AI-driven testing. 

  • Complete Traceability: Always know exactly which AI model evaluated your API response, ensuring full transparency and confidence in your test results. 
  • Better Debugging: Easily track down whether a flaky semantic test is due to the prompt, the API’s actual response, or the specific LLM version being utilized as the judge. 
  • Actionable Clarity: The refined terminology means the AI’s evaluation summary, scoring, and pass/fail status are easier to digest at a glance, removing ambiguity from your reporting. 

Engine Upgrade: Smarter Scheduling, Previews, and Wallet Management!

qAPI-Smarter Scheduling-Previews-and Wallet Management

The Challenge:  

As API testing operations scale into the millions of calls, the backend systems that manage execution credits, schedules, and live previews can come under immense pressure. Previously, users might have experienced slight delays when generating live API execution previews for massive payloads, minor latency when automated schedules were triggered during peak hours, or administrative friction when managing their qToken wallets across large teams. 

The Fix:  

We have completely overhauled the core backend logic for three critical qAPI components: qToken wallet management, the execution scheduler, and API execution previews. This massive architectural upgrade replaces older processing methods with highly optimized, modern infrastructure designed specifically for enterprise-grade performance and reliability. 

How will it help?  

This behind-the-scenes upgrade significantly accelerates your day-to-day testing rhythm. 

  • Instant Previews: Experience lightning-fast API execution previews. You can now validate complex payloads, headers, and AI evaluations immediately without waiting on frustrating UI loading screens. 
  • Precision Scheduling: The upgraded scheduler guarantees that your automated API suites trigger exactly on time, every time, completely eliminating backend queuing delays even during the highest volume periods. 
  • Reliable Resource Management: qToken balances and wallet allocations now sync flawlessly and securely in real-time across your entire organization, making administrative oversight completely frictionless. 

Ready to Leverage April’s Innovations? 

We are committed to providing a unified platform that not only adapts to your evolving needs but also streamlines your critical processes, empowering you to release high-quality software with greater speed and confidence. 

Eager to explore how these advancements can transform your testing efforts? The best way to appreciate the Qyrus difference is to experience these new capabilities directly. 

Ready to dive deeper or get started? 

March Release Notes

Welcome to our March update!  

As we move forward into the last month of the fiscal year, our focus at Qyrus is on creating a more connected, insightful, and responsive testing ecosystem. This month, we are breaking down silos between your tests, enhancing your visibility across projects, and giving you absolute control over your test executions. 

In Test Orchestration, we are thrilled to introduce the ability to seamlessly extract and pass data across different platforms—like moving a dynamic variable from a mobile app straight into a web script—unlocking true, uninterrupted end-to-end workflows. We’ve also revamped our Reports page, resolving stability issues and bringing you multi-project filtering for a unified view of your quality metrics. 

For our API Testing users, we’ve fortified the foundation with highly reliable JSON Path extraction for pre-request variables, turbocharged the workflow canvas performance, and added an essential “stop” mechanism to halt live performance tests on demand. Furthermore, we’ve closed the collaboration loop by enabling automated execution report attachments directly within our Jira integration. 

Alongside these major enhancements, we have also deployed a variety of bug fixes and minor improvements across Mobile Testing, Desktop Testing, Device Farm, QloudBridge, our AI algorithms, and other core services to keep your entire testing operation running smoothly. 

Let’s explore the powerful new capabilities available on the Qyrus platform this March! 

Test Orchestration

Bridge the Gap: Seamlessly Pass Extracted Data Across Workflows! 

Extract Word

The Challenge:  

Previously, if you extracted a specific piece of text during a test—like grabbing an order ID or a dynamic OTP from a mobile app screen—that valuable data was trapped within that individual script. If the next step in your Test Orchestration workflow was a web script that needed to input that exact ID for validation, the data couldn’t make the jump. This limitation broke the chain in cross-platform end-to-end testing, forcing users to rely on static data or complicated external workarounds. 

 The Fix:  

We have introduced the ability to extract words from one script and pass them dynamically as inputs to the next node in Test Orchestration. Now, when you use the “Extract word” feature and assign it to a variable (for instance, in a mobile script), you can configure that variable as an Output. You can then seamlessly map it directly to the Input of a dependent node (like a web script) downstream. 

How will it help?  

This update unlocks true, uninterrupted end-to-end testing across different platforms and script types. 

  • True Cross-Platform Flows: Easily create workflows that span platforms, such as generating a code on a mobile device and automatically verifying it on a web portal. 
  • Dynamic Validation: Your tests can now react to and utilize real-time, dynamically generated data on the fly, making your validations much more robust and realistic. 
  • Simplified Orchestration: Eliminate the need for messy API workarounds or external databases just to pass a simple string of text between your testing steps. 

Unified Insights & Stability: Multi-Project Filtering and Smoother Reporting! 

project filter

The Challenge:  

Previously, the Reports page presented two distinct usability hurdles. First, analyzing test results across different projects was a disjointed experience because you could only select one project at a time in the filters, forcing managers to stitch data together manually. Second, managing bulk executions caused platform instability; if you triggered multiple workflows and then attempted to abort them from the Reports page, the UI would continuously fluctuate and refresh erratically, making it incredibly difficult to interact with the system. 

The Fix:  

We have implemented a comprehensive UI/UX overhaul for the Reports page. We added full support for Multi-Project Selection in the filters section, allowing you to view and aggregate data across various projects simultaneously. Furthermore, we completely resolved the UI fluctuation bug, ensuring the page remains rock-solid and responsive even when processing abort commands for massive, multi-workflow executions. 

 How will it help?  

This update transforms how you track, analyze, and manage quality across your organization. 

  • Holistic Visibility: Instantly view aggregated test execution metrics, passing rates, and statuses across your entire portfolio in a single, unified dashboard. 
  • Seamless Interaction: Enjoy a stable, glitch-free reporting interface, allowing you to confidently manage and abort bulk runs without frustrating UI disruptions. 
  • Eliminate Manual Work: Stop wasting time toggling between individual project dashboards or fighting with a jumpy screen to get the insights you need. 

Halt the Load: On-Demand Stop for Performance Tests! 

stop execution
The Challenge:  

Previously, once an API performance test was initiated, it had to run its predetermined course. If you realized moments after clicking “Run” that you were targeting the wrong environment, or if the system under test began failing immediately, you were locked in. The test would continue generating massive, unnecessary load, wasting your execution resources and potentially causing severe disruptions or accidental outages on your backend services. 

The Fix:  

We have introduced a dedicated “STOP Execution” option specifically for active API performance tests, complete with precise state tracking. 

  • Targeted Visibility: The stop option is exclusively visible when the test is actively in the “Running” status. It is hidden during the “Run Initiated” or “Generating Reports” phases to prevent interrupting essential setup or teardown processes. 
  • Clear State Transitions: The moment you click “STOP Execution,” the report status immediately transitions to ABORTING. Once the underlying framework successfully spins down the virtual users and fully halts the process, the final status officially updates to Aborted. 
How will it help?  

This update gives you an essential, transparent emergency brake for your high-volume testing. 

  • Protect Your Systems: Instantly cut off the load if a test starts negatively impacting shared environments, databases, or third-party services. 
  • Save Resources: Stop wasting valuable execution minutes and concurrency slots on tests that are already known to be failing or misconfigured. 
  • Confident Control: The clear UI state changes eliminate guesswork, providing immediate visual confirmation that your stop command was received and successfully executed. 

Closing the Loop: Automated Report Attachments for Jira! 

The Challenge:  

Previously, when an API test failed and a bug was logged in Jira, the resulting ticket often lacked immediate, actionable context. Developers would see that a test failed, but to understand why, they had to leave Jira, log into Qyrus, navigate to the specific project, and dig up the execution report to view the payloads, headers, and error messages. This constant context-switching slowed down the debugging process and created friction between QA and Development teams. 

The Fix:  

We have significantly enhanced our Jira integration to support the automatic attachment of execution reports. Now, when a Jira issue is created directly from a failed API test in Qyrus, the comprehensive test report is automatically generated and attached directly to the Jira ticket. 

How will it help?  

This update centralizes your debugging information where your developers already work. 

  • Context-Rich Tickets: Developers instantly receive all the necessary technical details—requests, responses, and validation failures—attached right to the bug report. 
  • Faster Bug Resolution: By eliminating the need to switch platforms and hunt for test data, your team can start fixing issues immediately. 
  • Streamlined Collaboration: It creates a single, undeniable source of truth within Jira, making communication between testers and developers much more efficient. 

Flawless Data Prep: Reliable JSON Path Extraction for Pre-Requests!

JSON Path Extractor
The Challenge:

Setting up dynamic API tests often requires fetching and defining data before the main request even runs. Previously, when users tried to use the JSON Path extractor to pull specific values into Pre-Request variables, the system would sometimes fail to parse the payload correctly, resulting in an “undefined” value. This broken extraction caused subsequent API calls to fail unexpectedly—such as missing an authentication token or a critical ID—forcing users to spend time debugging test setups instead of the APIs themselves. 

 The Fix:  

We have fully resolved the bug and enhanced the capabilities of the JSON path extractor specifically for Pre-Request variables. The parsing engine has been upgraded to accurately evaluate your JSON paths and correctly capture the intended data, completely eliminating the “undefined” variable issue. 

 How will it help?  

This update ensures your API tests are built on a solid foundation from the very first step. 

  • Reliable Test Setup: Guarantee that your API requests always have the correct prerequisite data before they execute, eliminating false negatives. 
  • Dynamic Workflows: Confidently chain processes together, knowing that data extracted in the pre-request phase will be passed accurately to the main request. 
  • Reduced Troubleshooting: Stop wasting time investigating “undefined” variable errors and focus your energy on actual API validations. 

Ready to Leverage March’s Innovations? 

We are committed to providing a unified platform that not only adapts to your evolving needs but also streamlines your critical processes, empowering you to release high-quality software with greater speed and confidence. 

Eager to explore how these advancements can transform your testing efforts? The best way to appreciate the Qyrus difference is to experience these new capabilities directly. 

Ready to dive deeper or get started? 
Book a personalized demo 

Welcome to our November update! As we approach the end of the year, our mission to simplify and supercharge your testing lifecycle continues with renewed vigor. In November, we’ve focused on removing the friction between your tools and your goals, delivering enhancements that offer greater visibility, deeper ecosystem integration, and a more personalized AI experience.

In November, we are bridging critical gaps in your workflow. We’ve made reporting clearer with context-rich screenshots, streamlined test creation with instant cURL imports, and empowered enterprise teams by unlocking full Test Suite executions directly within Xray. Plus, our AI algorithms are now smarter than ever, capable of leveraging memory to adapt to your specific context. These updates are all about giving you the clarity and control you need to test with confidence.

Let’s dive into the powerful new features available on the Qyrus platform in November!

Web Testing

Context is King: Step Descriptions Now Label Your Screenshots!

The Challenge:

Previously, screenshots in execution reports were labeled with a generic “Screen Shot” tag. This forced users to constantly cross-reference the image with the test log to understand exactly what action was being captured in that specific frame, making the review process slower and less intuitive.

The Fix:

We have updated the reporting engine to replace the generic “Screen Shot” label. Now, the specific step description (e.g., “go to url”) is automatically displayed directly on the top left of every screenshot in the report.

How will it help?

This enhancement provides immediate context for every visual in your report. You can now browse through screenshots and instantly understand the specific test action being depicted without needing to look elsewhere. This significantly improves report readability, reduces cognitive load, and speeds up the debugging and review process.

No More Toggling: View Recorded Locators Instantly on the Step Page!

The Challenge:

Previously, after using the Qyrus Recorder to capture a test flow, the specific locator values (like XPaths or CSS selectors) were not immediately visible on the main test step page. To view or verify these locators, functional testers found it cumbersome to have to re-enter “record mode” via the Encapsulate Chrome extension, disrupting their workflow just to check technical details.

The Fix:

We have updated the Qyrus Recorder with improved locator detection and data handling. Now, after recording a session, all captured locator values are immediately populated and visible directly on the step page within the Qyrus platform.

How will it help?

This update significantly streamlines the script review and validation process. You no longer need to switch back and forth between the platform and the recorder extension just to see how an element is being identified. This gives functional testers and automation engineers instant visibility into their test logic, making it faster and easier to verify scripts and ensure the correct elements are being targeted.

Scale Your Xray Testing: Suite Execution Now Supported!

The Challenge:

Previously, our integration with Xray was limited to triggering single test scripts. This created a workflow bottleneck for teams who needed to execute larger batches of tests or full regression sets, as there was no capability to launch a complete Test Suite directly from the Xray interface.

The Fix:

We have upgraded our Xray integration to fully support Test Suite execution. Users can now trigger the execution of entire suites from within Xray with the same ease and simplicity as running a single script.

How will it help?

This update allows you to significantly scale your testing efforts directly from your test management tool. You are no longer restricted to triggering scripts one by one; instead, you can launch comprehensive test suites in a single action. This streamlines your execution workflow, ensuring that your Xray-driven testing is as efficient and powerful as your needs demand.

Copy, Paste, Done: Import APIs Instantly with cURL!

The Challenge:

Creating API tests manually can be a tedious process of copy-pasting individual components—headers, bodies, URLs, and methods—from your documentation or browser developer tools into the test platform. This manual reconstruction is not only slow but also increases the risk of transcription errors, leading to frustrated testers and broken initial tests.

The Fix:

We have introduced a new “Import via cURL” option in the API creation workflow. You can now simply paste a raw cURL command directly into Qyrus. The system will automatically parse the command and instantly create a fully configured API test with all the correct parameters, headers, and body content mapped for you.

How will it help?

This feature is a massive time-saver that bridges the gap between development and testing. Developers and testers often have cURL commands readily available (from API docs or network logs). By allowing direct import, we eliminate the manual data entry, ensuring your API tests are set up instantly and accurately, exactly as they were defined in your cURL command.

AI That Remembers: Enhanced Algorithms Now Access User Memory!

The Challenge:

Previously, while our AI algorithms were powerful, they often operated in isolation for each interaction. Without access to a persistent memory of past preferences, specific project contexts, or user-defined constraints, the AI could sometimes provide generic suggestions or require users to repeatedly provide the same background information, slowing down the workflow.

The Fix:

We have rolled out significant enhancements to all our AI algorithms. For users who have opted into the memory feature, these algorithms can now securely access and utilize stored context and preferences.

How will it help?

This upgrade makes your AI interactions significantly smarter and more personalized.

  • Reduced Repetition: The AI remembers your specific constraints and preferences, so you don’t have to repeat them.
  • Better Suggestions: Whether generating test data or building scenarios, the AI now understands your unique context, leading to more relevant and accurate results.
  • Seamless Workflow: Experience a more continuous and intelligent partnership with the platform, as the AI learns and adapts to your specific way of working over time.

Ready to Accelerate Your Testing with November Upgrades?

We are dedicated to evolving Qyrus into a platform that not only anticipates your needs but also provides practical, powerful solutions that help you release top-quality software with greater speed and confidence.

Curious to see how these October enhancements can benefit your team? There’s no better way to understand the impact of Qyrus than to see it for yourself.

Ready to dive deeper or get started?

Welcome to our October update! As we move into the final quarter of the year, our focus sharpens on refining the details that make a world of difference in your daily workflows. At Qyrus, we are continually committed to evolving our platform not just with big new features, but with smart enhancements that make your testing processes faster, simpler, and more powerful.

This month, we are excited to roll out a series of updates centered on intelligent workflow automation, enhanced user control, and advanced mobile testing capabilities. We’ve streamlined how you import, export, and manage test assets, unlocked a powerful new way to simulate offline conditions for iOS, and expanded our AI-driven analytics to cover your core API test suites. These improvements are all designed to give you more time back in your day and greater confidence in your results.

Let’s explore the latest enhancements now available on the Qyrus platform!






New Feature

Test Smarter, Not Harder: Impact Analyzer Now Supports Your qAPI Suites!

The Challenge:

Previously, our powerful Java and Python Impact Analyzers were limited in scope and could only analyze tests generated through DeepAPITesting. This meant that users could not leverage this smart, targeted testing capability for their primary, user-created functional test suites within the qAPI Workspace, missing out on the opportunity to optimize their regression cycles.

The Fix:

We have now fully integrated our Impact Analyzers (both Java and Python) with the tests you create and manage in the qAPI Workspace and Test Suites. The analyzer can now scan your codebase for changes and intelligently map those changes to the specific qAPI tests that cover the affected areas.

How will it help?

This integration unlocks a much smarter and more efficient way to run your regression tests. Instead of executing an entire qAPI test suite after every small code change, the Impact Analyzer will now tell you exactly which specific tests you need to run. This enables:

  • Targeted Test Execution: Dramatically reduce the scope of your regression runs.
  • Massive Time & Resource Savings: Get faster feedback by running only the necessary tests.
  • Smarter Regression Analysis: Confidently validate your changes without the overhead of a full regression cycle.

 

Ready to Accelerate Your Testing with October’s Upgrades?

We are dedicated to evolving Qyrus into a platform that not only anticipates your needs but also provides practical, powerful solutions that help you release top-quality software with greater speed and confidence.

Curious to see how these October enhancements can benefit your team? There’s no better way to understand the impact of Qyrus than to see it for yourself.

Ready to dive deeper or get started?


The world of software testing moves fast, and staying ahead requires tools that not only keep pace but actively drive innovation. At Qyrus, we’re relentlessly focused on evolving our platform to empower your teams, streamline your workflows, and make achieving quality more intuitive than ever before. May was a busy month behind the scenes, packed with exciting new features and significant enhancements designed to give you even more power and flexibility in your testing journey.
Get ready to explore the latest advancements we’ve rolled out across the Qyrus platform!

Complex Web Tests, Now Powered by AI Genius!

Manual coding for complex calculations in web tests? Consider it a thing of the past! We’re thrilled to introduce a game-changing AI feature that lets you generate custom Java and JS code using simple, natural language descriptions. Just tell Qyrus what you need the code to do, and our AI gets to work, even understanding the variables you’ve already set up in your test. This AI Text-to-Code conversion is seamlessly integrated with our Execute JS, Execute JavaScript, and Execute Java actions, designed to produce accurate, executable snippets right when you need them. You maintain control, of course – easily review, modify, or copy the generated code before using it.
A quick note: This powerful AI code generation is currently a Beta feature, and we’re actively refining it based on your feedback!

Enhanced Run Visibility for Web Tests

But that’s not all for Web Testing this month. For our valued enterprise clients, managing your test runs just got clearer. You now have enhanced visibility into your test execution queues, allowing you to see detailed information, including the exact position of your test run in the queue. Gain better insight, plan more effectively, and stay informed every step of the way.

Sharper Focus for Your Mobile Visuals

Visual testing on mobile is crucial, but sometimes you need to tell your comparison tools to look past dynamic elements or irrelevant areas. This month, we’ve enhanced our Mobile Testing Mobile Testing capabilities to give you more granular control. You can now easily ignore specific areas within your mobile application screens, excluding those regions entirely from visual comparisons.
Additionally, you can ignore the header or footer of the screen meaning that you can easily compare different execution results and not run into issues due to differences in the notification bar or in a footer.
This means cleaner, more relevant results and less noise when you’re ensuring your app looks exactly as it should across devices. Focus on what truly matters for your app’s user interface integrity.

Device Farm: Smoother Streaming, Better Guidance

We know your time on the Device Farm Device Farm streaming screen is valuable, and a smooth experience is key. This month, we’ve rolled out several user experience improvements to make your interactions even more intuitive. The tour guide text has been refined to be more informative, guiding you clearly through the features.
We’ve also added a Global Navbar directly inside the device streaming page, providing consistent navigation right where you need it. Plus, for those times you’re working with a higher zoom percentage, we’ve included a handy scroll bar to make navigating the page much easier. Small changes, big impact on your workflow!

Desktop Testing: Schedule Your Success

We’re excited to announce that test scheduling is now available in Qyrus Desktop Testing. This highly requested feature, already familiar from other modules, brings a new level of automation to your desktop workflows. It’s particularly powerful for those complex end-to-end test cases that span across different modules, perhaps starting in a web portal, moving through a back office, and ending in servicing.
Now, you can schedule these crucial test flows, ensuring your regression suites run automatically, even aligning with deployment schedules. This means no more worrying about desktop availability at the exact moment of execution – Qyrus handles it for you. With this feature, efficiently managing tests for workflows impacting dozens of test cases becomes significantly simpler.

Smarter AI for Broader Test Coverage

Our commitment to leveraging AI to make testing more intelligent continues this month with key improvements to both TestGenerator and TestGenerator+. We’ve been refining these powerful features under the hood, and the result is simple but significant: you should now see more tests built by the AI compared to previous versions.
Remember, TestGenerator is designed to transform your JIRA tickets directly into actionable test scenarios, bridging the gap between development tasks and testing needs. TestGenerator+ takes it a step further, actively exploring untested areas of your application, intelligently identifying gaps, and helping you increase your overall test coverage. These enhancements mean our AI is working even harder to help you achieve comprehensive and efficient testing with less manual effort.

Ready to Experience the May Power-Ups?

This month’s Qyrus updates are all about putting more power, intelligence, and efficiency directly into your hands. From harnessing AI to generate complex web code to gaining sharper insights from mobile visual tests, scheduling your desktop workflows, and boosting the output of our AI test generators – every enhancement is designed with your success in mind. We’re dedicated to providing a platform that adapts to your needs, streamlines your processes, and helps you deliver quality software faster than ever before.
Excited to see these May power-ups in action? There’s no better way to understand the impact Qyrus can have on your testing journey than by experiencing it firsthand.
Ready to learn more or get started?
And don’t forget to explore our documentation for more details on these new features!

We’re constantly building, innovating, and looking for ways to make your testing life easier. Stay tuned for more exciting updates from Qyrus!

Welcome to our September update! As we continue to evolve the Qyrus platform, our focus remains squarely on enhancing your productivity and empowering your team to achieve more, faster. We believe in removing friction from the testing lifecycle, and this month’s updates are a direct reflection of that commitment.

We are excited to introduce powerful new capabilities centered around dramatic workflow acceleration, intelligent AI-driven assistance, and seamless CI/CD integration. From features that eliminate repetitive tasks to an AI co-pilot that can fix your scripts on the fly, every enhancement is designed to save you valuable time and make your testing efforts more intuitive and powerful.





Ready to Accelerate Your Testing with August’s Upgrades?

We are dedicated to evolving Qyrus into a platform that not only anticipates your needs but also provides practical, powerful solutions that help you release top-quality software with greater speed and confidence.

Curious to see how these August enhancements can benefit your team? There’s no better way to understand the impact of Qyrus than to see it for yourself.

Ready to dive deeper or get started?


Welcome to our August update! At Qyrus, we are driven by the goal of making every aspect of your testing journey more efficient, powerful, and intuitive. This August, we’ve delivered a host of significant upgrades with a special focus on overhauling the entire API testing experience, creating more powerful and resilient test automation, and enhancing overall platform reliability. From simplifying how you create and preview APIs to making your automated tests smarter and more robust, these updates are designed to remove friction and accelerate your path to delivering quality.


Ready to Accelerate Your Testing with August’s Upgrades?

We are dedicated to evolving Qyrus into a platform that not only anticipates your needs but also provides practical, powerful solutions that help you release top-quality software with greater speed and confidence.

Curious to see how these August enhancements can benefit your team? There’s no better way to understand the impact of Qyrus than to see it for yourself.

Ready to dive deeper or get started?

Welcome to the July edition of our platform updates! At Qyrus, our mission is to constantly evolve our platform, providing your teams with powerful, intuitive tools that streamline every phase of the quality lifecycle. This July, we’ve been laser-focused on delivering enhancements that bring you deeper workflow integrations, next-level AI automation, and foundational improvements to security and performance. These updates are designed to connect your existing tools seamlessly, accelerate test creation like never before, and give you even greater confidence in your testing environment.

 Let’s explore the powerful new features we’ve rolled out across the Qyrus platform this July! 


Ready to Accelerate Your Testing with July’s Upgrades?

This July, we’re bringing you deeper workflow integrations, more powerful AI automation, and significant security and performance enhancements designed to streamline your entire testing process. From automatically generating detailed manual test steps with TestGenerator and enabling seamless end-to-end tests with session persistence, to connecting directly with Azure Data Lake and integrating with Azure DevOps and Rally, these updates are built to boost your team’s productivity. We are dedicated to evolving Qyrus into a platform that not only anticipates your needs but also provides practical, powerful solutions that help you release top-quality software with greater speed and confidence.

Curious to see how these July enhancements can benefit your team? There’s no better way to understand the impact of Qyrus than to see it for yourself.

Ready to dive deeper or get started?

 

At Qyrus, our commitment is to continuously advance our platform, equipping your teams with cutting-edge tools, simplifying complex testing processes, and making the path to quality clearer and more accessible. June has been another month of dedicated development, bringing forth a wave of innovative features and critical enhancements designed to offer you expanded data connectivity, deeper AI-driven insights, and more refined control across your entire testing journey. These updates are crafted to significantly boost your efficiency and provide unparalleled visibility into your applications.

Let’s dive into the latest capabilities we’ve integrated into the Qyrus platform this June!

 

 


Ready to Leverage June’s Innovations?

 

This June, Qyrus is putting enhanced connectivity, deeper AI intelligence, refined user control, and greater operational efficiency directly at your fingertips. From seamlessly integrating with NoSQL databases like MongoDB and generating complex test code from natural language with our advanced AI, to gaining precise control over visual comparisons with new ignore-region capabilities, every new feature is engineered to elevate your testing strategy. We are committed to providing a unified platform that not only adapts to your evolving needs but also streamlines your critical processes, empowering you to release high-quality software with greater speed and confidence.

Eager to explore how these June advancements can transform your testing efforts? The best way to appreciate the Qyrus difference is to experience these new capabilities directly.

 

 

Ready to dive deeper or get started?

 

At Qyrus, we’re relentlessly focused on evolving our platform to empower your teams, streamline your workflows, and make achieving quality more intuitive than ever before. May was a busy month behind the scenes, packed with exciting new features and significant enhancements designed to give you even more power and flexibility in your testing journey. Here’ re the latest advancements we’ve rolled out across the Qyrus platform!

Excited to see these May power-ups in action? There’s no better way to understand the impact Qyrus can have on your testing journey than by experiencing it firsthand.

 


Ready to Experience the May Power-Ups?

 

This month’s Qyrus updates are all about putting more power, intelligence, and efficiency directly into your hands. From harnessing AI to generate complex web code to gaining sharper insights from mobile visual tests, scheduling your desktop workflows, and boosting the output of our AI test generators – every enhancement is designed with your success in mind. We’re dedicated to providing a platform that adapts to your needs, streamlines your processes, and helps you deliver quality software faster than ever before.

Excited to see these May power-ups in action? There’s no better way to understand the impact Qyrus can have on your testing journey than by experiencing it firsthand.

 

 

Ready to learn more or get started?