// Agentic Test Automation for VoIP: 67% Less Regression Execution Time with Playwright and GitHub Copilot

A leading India-based VoIP technology provider partnered with JigNect Technologies to overcome the challenges of repetitive regression testing across 20+ client-specific servers. With frequent feature enhancements, UI changes, complex Admin-Agent workflows, and tight release timelines, manual validation was creating significant pressure on the QA team. We implemented an AI-assisted test automation framework combining Playwright (JavaScript), custom GitHub Copilot agents, API testing, and Allure reporting. By introducing an instruction-driven agentic workflow and human-in-the-loop validation, we accelerated script development while maintaining code quality and execution stability. The result was a 67% reduction in regression execution time, bringing validation for a single server down from approximately 60 minutes to 20 minutes, simplifying cross-portal end-to-end testing, and eliminating the release-cycle overtime previously required by the team.

Industry
VoIP / Telecommunications
Target Audience
Call Centers, Collection Agencies & Customer Support Operations
Client HQ
India
Tools & Tech
Playwright (JavaScript), API Testing, GitHub Copilot Custom Agents (Agentic AI Workflow), Markdown Instruction Files, Allure Reports
67%
Regression execution time cut
~80%
Accurate scripts from AI agent
2 Portals
Portals automated end to end
Non-flaky
Human-in-the-loop AI testing

Client Overview

The client is an India-based VoIP technology provider delivering communication and contact center solutions to call centers, collection agencies, and businesses with customer interaction requirements. 

Its platform supports administrative operations, agent workflows, campaign management, calling functionality, and configurable communication processes. As a product-based company, the client serves multiple customers, each potentially operating on a separate server with client-specific configurations and functional requirements. 

With more than 20 servers to maintain, ensuring consistent application quality across different customer environments was critical. Every release needed to preserve existing functionality while validating new features, UI changes, and configuration-specific behavior across the relevant servers

Business Challenge 

Managing quality across a growing number of client-specific environments introduced significant regression testing challenges. Every release required the team to verify that existing workflows still worked, new features behaved as expected, and UI changes did not disrupt established operations. 

The primary challenges included: 

1. Multi-Server Regression Testing: The platform operates across 20+ client-specific servers. Testing had to account for different configurations and customer requirements rather than relying on a single, uniform environment. 

2. Release-Cycle Workload: Regression testing and smoke testing of the production environment created substantial pressure on the internal team. During releases, team members frequently worked overtime until validation was completed. 

3. Continuous Feature and UI Validation: New functionality, enhancements, and UI changes needed to be validated alongside existing workflows to identify regressions before they affected customers. 

4. Complex Admin-Agent Integration: Several scenarios required actions in the admin portal to be verified in the Agent portal, involving multiple role switches and interconnected workflows. 

5. Tight Release Timelines: The client needed a repeatable testing approach that could deliver faster feedback without compromising functional coverage or delaying releases.

Our Strategic QA Approach 

Jignect Technologies built an AI-assisted test automation framework using Playwright (JavaScript), API testing, custom GitHub Copilot agents, and Allure reporting to streamline regression validation. 


1. Module-Wise Planning and Delivery 

We assessed the functional test cases provided by the client, conducted knowledge-transfer sessions, estimated automation effort, and finalized the scope and delivery commitments for each module. 

Completed modules were demonstrated to the client, and feedback was incorporated to align the automation with expected application behavior and business requirements.

2. Agentic AI Test Automation with Custom GitHub Copilot Agents and Human-Led Validation 

To speed up script creation without losing consistency and code quality, we built an agentic workflow on GitHub Copilot: a custom agent guided by predefined project standards (context engineering) instead of ad-hoc prompting. 

Instruction-Driven Agent Architecture 

We configured a custom GitHub Copilot AI agent to read a central agent.md file holding project-level rules and pointers to task-specific instruction files. Instead of loading every rule into every prompt, the agent pulled in only the file relevant to the task, a modular approach to context management like agent skills. This kept output consistent and reduced repetitive prompting. 

The instruction folder contained Markdown files for: 

  • Bootstrap Rules: The default framework structure created when a new project starts 

  • Framework Rules: Coding conventions, architecture and reusable standards 

  • DTO Instructions: Test data models and data handling 

  • Page Object Instructions: Page Object Model structure, locators and reusable interactions 

  • Test Instructions: Script generation, execution flow and assertions 

  • Review Instructions: Code review checkpoints against these standards 

How the Agent Worked 

  1. Input: test steps with expected results, page screenshots and the existing framework 

  1. Agent action: selects the relevant instruction file, then generates DTOs, page objects and test scripts 

  1. AI review: checks its output against the Review Instructions 

  1. Human validation: QA engineers fix locators and waits, and verify assertions 

Screenshot-Based Test Script Generation 

Because of confidentiality restrictions, the application DOM could not be shared with AI tools. Our QA engineers instead gave the agent functional test steps with expected results, screenshots of the relevant pages, and the existing framework structure. Using these multimodal inputs, the agent generated about 80% of each script correctly. 

Human-Led Script Review and Refinement 

AI-generated scripts were never treated as production-ready. Human-in-the-loop guardrails ensured every script was validated by a QA engineer:  

  • Correcting and optimizing element locators. 

  • Adding appropriate waits where required. 

  • Verifying that assertions validated the expected application behavior. 

  • Confirmed assertions failed when given incorrect data or unexpected behavior (negative validation) 

  • Ensuring scripts followed the established framework and coding standards

Repeated Execution and Flaky Test Prevention 
We ran each script across multiple cycles to confirm it stayed stable, not just passing once. 

 Validation covered: 

  • Randomized test data 

  • Data creation and deletion 

  • Recovery from half-failed runs, so an interrupted test never leaves residual data or state that breaks the next run 

This surfaced flaky behavior, data dependencies, and cleanup issues before any script was marked complete.

 

3. Multi-Portal End-to-End Automation 

We used Playwright browser contexts to maintain separate authenticated sessions for the Admin and Agent portals. Each portal ran in its own window, and tests switched between them to confirm that an action in one portal showed correctly in the other, without repeated login and logout. 

4. Regression Validation Across Client Environments 

The framework supported repeatable regression execution on individual servers, helping validate existing functionality alongside new features and UI changes.

5. Clear Execution Reporting 

Tests print descriptive step-by-step logs, and Allure Reports make results readable for non-technical stakeholders, showing what the automation is doing and exactly where a failure occurred.  

 

 

Delivery & Business Impact

The automation shortened regression cycles and removed release-time pressure across 20+ client-specific servers. 

 

Business Impact 

Description

67% Reduction in Regression Execution Time 

Regression testing for a single server was reduced from approximately 60 minutes to 20 minutes, accelerating release validation and enabling faster feedback. 

Reduced Release-Cycle Workload 

Automation removed the extended overtime previously needed during release weeks and production environment smoke testing. 

Faster Feedback on Deployment Defects 

Repeatable automated execution helped identify unexpected behavior introduced by new code deployments, enabling the team to investigate potential regressions earlier in the release validation process. 

Improved Multi-Server and Functional Validation 

The framework supported regression validation across client-specific environments, helping verify existing functionality alongside newly introduced features, enhancements, and UI changes. 

Efficient Cross-Portal E2E Testing 

Persistent Admin and Agent authentication enabled automated validation of interconnected workflows without repeated login and logout operations, simplifying complex end-to-end scenarios. 

Greater Reporting Transparency 

Descriptive execution steps and Allure Reports made test results easier to understand, helping technical and non-technical stakeholders identify the actions performed, validation outcomes, and exact failure points. 

Faster, Controlled Script Development 

The agentic, instruction-driven model speeds up script creation while engineers keep control of code quality, assertion accuracy, test data handling, and execution stability. 

Structured Delivery and Client Collaboration 

Module-wise estimation, regular client demonstrations, continuous feedback, and daily local execution helped maintain alignment with requirements and delivery commitments, even under tight timelines. 

Conclusion 

By combining instruction-driven GitHub Copilot agents, human-led QA validation, and Playwright’s multi-context automation, Jignect Technologies transformed a repetitive VoIP regression process into a faster, more structured validation workflow. Regression time per server fell by 67%, from approximately 60 minutes to 20 minutes, while persistent Admin and Agent sessions made complex end-to-end scenarios reliable across 20+ client-specific servers. The team also gained earlier defect visibility and no longer needed overtime during release cycles. 

The engagement shows that a well-structured automation strategy works best when AI handles the repetitive scripting and experienced QA engineers own validation. 

Other Case Study

// Similar Case Studies