By Jean-Philippe Jacquet
The Spark: A New Path for Manual Testers
A few months ago, some of my senior manual testers at Edulog—the team behind a leading school transportation management system—expressed interest in contributing to automated testing. They saw it as a natural progression in their careers, but the learning curve for traditional automation tools like Selenium or Cypress was steep. That’s when I realized: What if we could leverage AI to let them focus on their strengths—designing comprehensive test scenarios—while removing the coding barrier?
I started exploring generative AI in QA, and what I discovered was transformative. This isn’t just about efficiency or scalability. It’s about inclusivity—giving senior manual testers, who often have deep domain knowledge, a way to contribute to automation without needing to become developers.
The Problem: The Automation Gap
Senior manual testers are invaluable. They excel at:
- Exploratory testing: Uncovering edge cases in complex systems like school transportation routing.
- User-centric thinking: Anticipating how school administrators or bus drivers will interact with the software.
- Domain expertise: Understanding the nuances of school district requirements, student safety protocols, or bus scheduling logic.
Yet, in many organizations, they’re limited in their ability to contribute to automation because traditional tools require coding skills. This creates a skills gap that leaves their expertise underutilized in automated testing efforts.
For example, a senior tester at Edulog might have years of experience testing the intricacies of bus route optimization algorithms. But without coding knowledge, their ability to automate these tests is limited. That’s a loss for the team—and for the quality of the product.
The Solution: AI as the Bridge
Generative AI is changing this dynamic. It’s not about replacing manual testers or coders. It’s about removing the barriers that prevent great testers from contributing to automation. Here’s how AI makes this possible:
1. No-Code/Low-Code Test Creation
AI-powered tools like Mabl, Test.ai, and Rainforest QA allow testers to create automated tests using:
- Plain English: Describe a test scenario in natural language, and AI generates the script.
- Visual Interfaces: Drag-and-drop or record-and-replay features that don’t require coding.
- Existing Artifacts: AI can turn user stories, acceptance criteria, or even JIRA tickets into executable test scripts.
2. Self-Healing Tests
One of the biggest challenges in automation is maintenance. UI elements change, locators break, and suddenly, your test suite is full of failing scripts. AI tools can automatically update tests when the application changes, so manual testers don’t have to spend hours debugging broken scripts.
3. Seamless CI/CD Integration
AI doesn’t just help create tests—it helps run them at the right time. Tools can:
- Trigger tests automatically on every code commit or pull request.
- Prioritize tests based on what’s changed in the code, so you’re not running irrelevant tests.
- Provide instant feedback to developers, catching bugs earlier in the pipeline.
For someone like me, who’s passionate about CI/CD and DevOps, this is a game-changer. It means manual testers can contribute to automation without becoming bottlenecks or requiring constant support from developers.
Tools in Action: A Comparison
Not all AI-powered QA tools are created equal. Here’s how three of the leading platforms stack up, based on their ability to empower manual testers and integrate with CI/CD:
| Tool | No-Code Test Creation | Self-Healing Tests | CI/CD Integration | Best For |
|---|---|---|---|---|
| Rainforest QA | Plain English test scripts | ✅ Yes | ✅ Deep integration | Crowdsourced + AI testing |
| Mabl | Record-and-replay + visual editing | ✅ Yes | ✅ Native integrations | Low-code customization |
| Test.ai | Natural language + visual testing | ✅ Yes | ✅ Smart execution | Cross-browser/device testing |
Rainforest QA: Testing in Plain English with Crowdsourced Support
Rainforest QA stands out for its simplicity and scalability. Testers can write tests in plain English, like:
“Log in as a school administrator, navigate to the ‘Bus Routes’ tab, select ‘Route #45’, and verify that the assigned driver is ‘John Smith’ and the bus number is ‘BUS-2024’.”
- Crowdsourced Testing: Rainforest QA combines AI with a network of human testers who execute the tests on demand. This is particularly useful for:
- Scaling test execution across multiple environments or devices without maintaining your own infrastructure.
- Handling edge cases that might be difficult to automate, such as testing how the system behaves on a slow school district network.
- Augmenting your team during peak times (e.g., before a major release of the transportation management system).
- Pros:
- No coding required. Ideal for senior manual testers who want to contribute to automation immediately.
- Integrates with CI/CD pipelines to run tests on every commit.
- Crowdsourced testers can provide real-world feedback on usability and edge cases.
- Cons:
- Less flexibility for complex test logic (e.g., loops, conditions).
- Crowdsourced testing may introduce variability in execution (e.g., timing, environment differences).
Example: A senior tester could use Rainforest QA to write a plain English test for validating that a new bus route assignment algorithm correctly updates the driver and bus information in the UI. This test could then be automatically executed by Rainforest’s crowdsourced testers as part of the CI pipeline, ensuring the feature works as expected across different browsers and devices.
Mabl: Record, Replay, and Let AI Do the Rest
Mabl’s record-and-replay feature is perfect for senior testers who want to automate their manual test cases without coding. Here’s how it works:
- A tester manually performs a series of actions in the Edulog system (e.g., creating a new student pickup location, assigning it to a bus route, and verifying the route updates correctly).
- Mabl records these actions and turns them into an automated test script.
- The script can then be edited visually (e.g., adding assertions or logic) without writing code.
- Pros:
- Zero coding required for basic tests. More advanced users can add custom JavaScript if needed.
- Self-healing: Mabl’s AI automatically updates tests when UI elements change (e.g., if a button ID changes in the Edulog dashboard).
- CI/CD ready: Integrates with GitHub, GitLab, Jenkins, and more to run tests on every pull request.
- Cons:
- Record-and-replay can be brittle if the app’s UI changes frequently.
- Customizations may require some technical knowledge.
Example: A senior tester could use Mabl to record a test for validating that a new student’s pickup location is correctly assigned to the nearest bus route. When the UI for the student assignment screen is updated in a later sprint, Mabl’s AI automatically updates the test to account for the new button IDs or layout changes—saving the tester hours of manual updates.
Test.ai: AI-Powered Visual Testing
Test.ai focuses on visual and AI-driven testing, which is ideal for ensuring consistency across the Edulog system’s UI:
- Natural Language Test Cases: Write tests in English, and Test.ai generates the scripts.
- Visual Testing: AI detects UI changes (e.g., a button moved, a color changed) and flags them as potential issues.
- Smart Execution: Only runs tests that are relevant to the code changes in a commit.
- Pros:
- Great for cross-browser/device testing: AI ensures tests run consistently across environments (e.g., Chrome, Firefox, or mobile devices used by school districts).
- Low maintenance: Visual testing reduces the need for manual script updates.
- CI/CD integration: Works with most CI tools to trigger tests automatically.
- Cons:
- Visual testing can be resource-intensive.
- May require more setup for complex applications.
Example: For school transportation dashboard, which is frequently updated to improve usability for school administrators, Test.ai’s visual testing could automatically detect and flag UI changes (e.g., a misaligned bus route map or a missing student pickup location field). This ensures that the UI remains consistent and functional across all devices, without requiring manual testers to update scripts for every minor change.
The Bigger Picture: AI in CI/CD
One of the most exciting aspects of AI in QA is its integration with CI/CD pipelines. Here’s why this matters for complex systems:
- Automated Test Generation: AI can analyze code changes and generate relevant test scripts for each commit. For example:
- A developer updates the student pickup location assignment algorithm → AI generates a test to verify that students are correctly assigned to the nearest bus route.
- A UI designer changes the layout of the bus route dashboard → AI updates the visual tests for that dashboard.
- Smart Test Execution: Not all tests need to run on every commit. AI can prioritize tests based on:
- Which parts of the code were changed (e.g., only run tests related to bus route assignments if the assignment logic was updated).
- The risk level of the changes (e.g., critical updates to student safety features vs. minor UI tweaks).
- Historical data (e.g., which tests fail most often in the system).
- Faster Feedback Loops: With AI-driven tests running in CI/CD, bugs are caught earlier and faster. Developers get instant feedback, and senior manual testers can focus on exploratory testing and edge cases (e.g., testing how the system handles a last-minute change to a bus route due to a driver calling in sick).
Challenges and Realities
While AI in QA is powerful, it’s not without its challenges. Here’s what to keep in mind:
- AI-Generated Tests Aren’t Perfect: They still need human review, especially for complex systems. For example:
- AI might miss edge cases in bus route optimization that a senior tester with domain expertise would catch.
- False positives/negatives can occur, particularly in systems with many interdependencies (e.g., student assignments, bus schedules, driver availability).
- Tool Maturity Varies: Some AI features (e.g., self-healing tests) are more mature than others. It’s worth piloting tools to see what works best for your team and system.
- Best for Senior Testers: AI-powered no-code tools are particularly effective for senior manual testers who have:
- Deep domain knowledge (e.g., understanding the nuances of school transportation systems).
- Strong critical thinking skills to design comprehensive test scenarios.
- The experience to identify edge cases that AI might miss.
- Initial Setup: While no-code tools reduce the barrier to entry, they still require setup and training. Pairing senior testers with automation experts can help them get up to speed quickly.
The Future: AI as a Team Multiplier
I believe the future of QA isn’t about automation vs. manual testing. It’s about collaboration. AI won’t replace manual testers—it will amplify their strengths, especially for those with deep domain expertise.
Here’s what I envision:
- Senior manual testers focus on exploratory testing, edge cases, and user-centric scenarios—the things AI can’t do well (yet). For example, they might design tests for complex scenarios like:
- What happens if a bus breaks down mid-route, and the system needs to reassign students to new buses in real time?
- How does the system handle a last-minute change to a student’s pickup location due to a parent’s request?
- AI handles the repetitive work: generating scripts, running regression tests, and maintaining test suites.
- Developers can focus on complex test scenarios and architecture, knowing that AI and manual testers have the basics covered.
In this world, everyone wins:
- Senior testers feel valued and upskilled, with new ways to contribute to the team’s success.
- Developers get faster feedback and fewer interruptions from test maintenance.
- The business benefits from higher quality software and faster, more reliable releases.
Final Thought: AI for the People
At its core, AI in QA isn’t about technology. It’s about people. It’s about giving senior manual testers—the ones with years of experience and deep domain knowledge—the tools they need to stay relevant, grow their skills, and contribute in new ways.
The best testers aren’t defined by whether they can code. They’re defined by their ability to think critically, design comprehensive test scenarios, and advocate for quality. AI is simply the tool that lets them do that at scale.
So, to my fellow QA leaders: The future of testing is here, and it’s more accessible than you think. Give your senior manual testers a chance to shine with AI. You—and they—might be surprised by what they can achieve.