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!
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!
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.
Desktop Testing
Code Meets Canvas: Execute Python Scripts in Desktop & SAP Tests!
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.
API Testing
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.
Device Farm
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.
Test Orchestration
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!
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.
qAPI Product Release Update
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!
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?
