A founder’s intern tale of integrating AI for Quality Assurance

Hi, I’m Shreya Lakhera, a founder’s office intern at Refrens. 

In a series of automating our workflows for different teams, I was tasked with a wild one: “See if we can use AI to improve our QA process.” 

As someone obsessed with AI, I was thrilled. The QA team? Not so much.

“If it doesn’t reduce our workload, it’s not worth it.” – Shivam, our QA lead, day one of the project.

The Problem: QA Was Becoming the Bottleneck

As our product scaled, so did our bugs. Regression cycles stretched into weekends. Sanity checks turned into repetitive manual loops, and the team was buried under test reruns and flaky scripts. 

QA wasn’t broken; it was exhausted.

So, I dug deep into the world of AI QA automation tools, and along with Shivam, dove headfirst into a two-month long game of AI-hunt.

The Exploration: 40+ AI Tools, 2 Months, 1 Spreadsheet

We tested over 40 tools: demos, trials, waitlists, crashes, you name it.

Some tools were brilliant (@DevAssure, @Kusho.ai, @Reflect.run). Some were heavy, overpriced, or just mislabeled automation as AI. Some didn’t work in India. And many looked great until you actually tried using them. 

“We didn’t need another fancy dashboard; we needed time back.”

Here’s the how-to that worked for me (and might for you):

Step 1: Make the Team Part of the Process

I made sure to involve the QA team in demos. Let them crash the tools. Let them veto bad ones. Ownership builds buy-in.

Step 2: Drowning in Tools 

We built a monster spreadsheet. Every tool that claimed “AI-powered QA” made the list.

We tested:

Tool	Why It’s Good
Kusho.ai	Generates Cypress scripts, strong UI/API testing
Qodex	Great for API testing, lightweight alternative to Postman
Keploy	GitHub-integrated backend API testing with low entry cost
LambdaTest	UI testing + basic AI script generation
Perfecto	Mobile + web testing, codeless AI-based test creation
Reflect.run	Accurate no-code UI test creation with AI steps

Some tools were genuinely smart. Others just slapped “AI” on basic record-and-playback features. A few were beautiful but broke in India. Some charged over $20,000 a year for “enterprise” features we’d never use.

We crashed more tools than I care to admit. 

But every demo, every failed integration, every frustrated Slack message added to our learning. 

Step 3: Acknowledge the Resistance

Don’t force the change. Our QA team wasn’t anti-AI; they were anti-wasted-effort. 

They had valid concerns:

• New tools take time to learn
  
• Early-stage AI still needs guardrails
  
• The last thing they wanted was another flaky system

So we picked just one workflow – sanity checks, and automated that first.

Step 4: Evaluate with Real-World Criteria

Before we even opened the first demo, we defined what “success” would look like. 

Our north star wasn’t just AI for AI’s sake, we needed tools that could make our testers less frustrated.

Here’s what we were really hoping a tool could do:

• Run a pre-configured test 
• Generate test cases 
• Run new test cases 
• Check for visual change. – from previous version 
• Check for visual bugs and inconsistency 
• API testing 

To keep things grounded, we created a scoring checklist that helped us objectively assess each tool:

• Does it integrate smoothly with our pipelines and work?
• Can it auto-generate or self-heal test cases as things evolve?
• Is the onboarding process fast enough for a dev sprint?
• Do the results make sense to both devs and testers?
• Is the pricing realistic for an early-stage startup?

Spoiler: most tools failed on more than one front.

The Hardest Part: Convincing the Team

“Once we had our tool shortlist, the next challenge was bigger, how do we actually get the team to trust them?”

Our QA team was sharp, overworked, and justifiably skeptical. The mood was clear:

 “Why fix what isn’t broken?”
“This will only slow us down.”

And at first, they were right.

Early tests were flaky. Onboarding felt like onboarding a new team member. Instead of saving time, we were analyzing more documentation just to understand the tool.

I had moments where I questioned the entire idea.

But we didn’t give up.

What We Did Differently –

Instead of replacing existing processes, we made AI a quiet assistant:

• Automated repetitive sanity checks
• Let QA engineers focus on exploratory and edge cases
• Started with one reliable suite, not the whole test pyramid
• Avoided pushing AI into unstable flows

The final choice: Devassure.

After weeks of experimentation, DevAssure stood out, not for being flashy, but for being practical:

• Balanced UI + API testing
• Stable test generation, didn’t break on complex flows
• Friendly pricing for startups
• Incremental adoption with an amazing online support team

The team trusts the results. That’s the win.

Results (So Far)

• We adopted DevAssure for regression and sanity checks.
• Fewer manual QA hours
• Faster sanity checks
• Happier testers and no more weekend regressions
• And yes, I earned a few more “crazy project” credits 

TL;DR

• QA was becoming a bottleneck due to growing bugs and lengthy regression cycles.
• Over 40 AI tools were evaluated, including @DevAssure, @Kusho.ai, and @Reflect.run.
  
• Process:
  
  • Involved the QA team from the start through demos and hands-on testing.
    
  • Created a spreadsheet to track and compare features, pricing, and performance.
    
  • Focused on automating a single workflow (sanity checks) before scaling.
    
• After rigorous testing, DevAssure was chosen for its practical features and stable test generation.
  
• Outcome: Reduced manual QA hours, faster sanity checks, and increased trust in the automated results.

For me, this wasn’t just a crash course in tools, it was a masterclass in patience, persuasion, and the power of small wins.

If you’re in the middle of your own QA transformation or just starting out,  feel free to reach out. I’ll happily share our notes, lessons, and probably a rant or two about tools that almost made it.