DEV Community: Dhanashri Ugalmugale

PassionQA: Turning My Passion for Software Quality into AI-Powered Test Intelligence

Dhanashri Ugalmugale — Sat, 11 Jul 2026 18:20:32 +0000

This is a submission for Weekend Challenge: Passion Edition

What I Built

As a QA engineer, I spend a lot of time reading requirements,
questioning unclear business rules, and thinking about what could break before a feature reaches users. That part of quality engineering is something I genuinely enjoy, and it inspired me to build PassionQA.

PassionQA is an AI-powered quality intelligence platform that turns product requirements into practical QA insights and executable test cases.

The workflow is simple:

Upload or paste a BRD (Excel or text)
Run AI-assisted quality analysis
Review the complete QA output in one dashboard:
- Requirement health and release readiness
- Missing rules and ambiguous requirements
- Positive, negative, boundary, security, and accessibility test cases
- Bug-risk insights and heatmap
- Requirements Traceability Matrix (RTM)
- Excel and PDF exports

My goal was to reduce the repetitive part of requirement analysis so testers can spend more time thinking critically about product risk and quality.

Demo

Try it quickly

Live app: https://passion-qa.vercel.app

Click Explore Demo Preset to analyze the built-in insurance example. The application uses Gemini when available and automatically falls back to the local analysis engine if Gemini is unavailable.
Or click Launch Platform (Free), upload your own BRD, and select Run Quality Analysis.

For my demo, I used an insurance Policy BRD. PassionQA analyzed the requirements, highlighted quality gaps, and generated executable positive, negative, boundary, security, and accessibility test scenarios across the policy workflow.

Video Demo

The demo shows the complete flow from Policy BRD upload to AI analysis, test-case generation, risk insights, RTM, and report export.

Demo video: https://drive.google.com/file/d/1sAoOauTGCk66xAzY46zF8_lWBQbVM8Gr/view?usp=sharing

Code

GitHub repository: https://github.com/DhanashriQAEngineer/PassionQA/

Some of the key parts of the project are:

src/lib/gemini.ts --- Gemini analysis and local fallback engine
src/app/api/analyze-requirement/route.ts --- server-side analysis API
src/app/dashboard/page.tsx --- QA intelligence dashboard
src/lib/excelExport.ts --- multi-sheet Excel export
scripts/record-demo.mjs --- Playwright demo recorder

How I Built It

Why I built PassionQA

I didn't want to create another chatbot that simply summarizes a
document.

In QA, a summary is not enough.

We need to know what is missing, which requirements are unclear, what business rules could fail, and whether our test coverage is strong enough.

That is why I designed PassionQA more like a QA workspace or tester's cockpit. The dashboard focuses on test coverage, requirement health, risk, traceability, and executable test scenarios.

AI-powered requirement analysis with Google Gemini

Google Gemini is used as the AI analysis engine.

The BRD content is sent through a server-side API route with a QA-focused prompt. Gemini analyzes the requirements and returns structured information including product domain and modules, requirement quality metrics, missing or unclear business rules, executable test cases, risk areas, RTM data, and QA recommendations.

One important decision was to keep the Gemini API key on the server instead of exposing it in the browser.

The application also tracks whether the result was generated using Gemini or the local analysis engine, so the UI clearly shows the actual analysis source.

Reliable demo and fallback mode

PassionQA supports two analysis modes:

Gemini mode for live AI-assisted requirement analysis
Local mode as a fallback when Gemini is unavailable or times out

The Explore Demo Preset follows the same analysis flow. If Gemini is configured and available, Gemini performs the analysis. If the request fails or Gemini is unavailable, PassionQA automatically uses the local analysis engine.

The local mode still generates a complete QA dashboard, which keeps the application usable and makes the demo reliable.

Tech stack

I built PassionQA using Next.js App Router, React, TypeScript,
Tailwind CSS, Google Gemini, Recharts, Framer Motion, xlsx-js-style, jsPDF, and Playwright.

Decisions that mattered to me

The most important part of PassionQA is the generated test suite.
Dashboard metrics and test counts are based on the generated test cases rather than fixed demo numbers.

I also focused on keeping the AI experience transparent. If Gemini generates the result, the UI says so. If the application uses local fallback, that is clearly shown to the user.

Finally, I created a Playwright-based demo flow using a real insurance Policy BRD. This helped me validate the same experience a QA engineer would follow: upload requirements, analyze quality, review risks, inspect test cases, check traceability, and export the results.

Prize Categories

I am submitting PassionQA for Best Use of Google AI.

Gemini is not used as a simple chat feature. It is the core requirement-analysis engine that transforms BRD content into structured QA artifacts: requirement insights, executable test cases, risk areas, RTM mappings, and recommendations.

For me, this project combines two things I am genuinely passionate about: software quality and AI.

PassionQA started from a simple thought I often have while testing a product:

"What are we missing before this reaches production?"

This project is my attempt to help QA teams answer that question earlier and faster.

Captain Cool AI: A Multi-Agent IPL Tactical Strategist Built Powered by Google Gemini

Dhanashri Ugalmugale — Sun, 17 May 2026 13:04:07 +0000

Cricket is often called a batter’s game, but in T20 cricket, it is equally a captain’s game. One tactical mistake—bowling spin into heavy dew, using your best death bowler too early, or making the wrong substitution—can completely change the outcome of a match. That is exactly what made this Google Gemini Hackathon problem statement so interesting to me.

The challenge was to build an agentic AI system that behaves like a virtual IPL captain, capable of making live tactical decisions in high-pressure match situations. Instead of building a simple chatbot that produces generic cricket advice, I wanted to create something that actually thinks through decisions the way a real dugout might. That idea became Captain Cool AI.

Captain Cool AI is a multi-agent tactical cricket strategist built entirely on Google’s AI ecosystem using the google-genai Python SDK, Gemini 2.5 Flash, Streamlit, and Python orchestration. The goal was to simulate how a captain, analyst, and tactical advisor might collectively arrive at the next big decision during a live match.

What made this project especially exciting was the multi-agent design. A single AI prompt might simply say, “Use your best bowler now,” but cricket strategy is rarely that straightforward. Real decision-making involves competing perspectives. One person looks at the numbers, another thinks aggressively, someone else challenges the logic, and only then does the final call emerge. I wanted to recreate that process.

To achieve this, I designed four specialized Gemini-powered agents. The Stats Analyst focuses entirely on match intelligence such as venue conditions, batter vs bowler matchups, chase pressure, and dew factor. The Strategist acts like the captain, making the first tactical recommendation. The Devil’s Advocate exists to challenge that decision, forcing the system to consider risks and alternative scenarios. Finally, the Commentator transforms the outcome into cricket-style explainability so the reasoning feels intuitive and engaging rather than technical.

To make the system more grounded, I added supporting tools instead of relying only on prompting. A cricket tactical engine provides matchup heuristics and venue intelligence, a win probability engine adds confidence scoring and counterfactual analysis, and a live weather API helps factor in environmental conditions like dew, which can dramatically affect death-over planning. This combination made the recommendations feel much more realistic and trustworthy.

For the interface, I built a Streamlit dashboard where users can enter the current match state—innings, score, wickets, over, batting and bowling teams, target, required run rate, striker, venue, dew factor, and Impact Player availability. Once submitted, the system runs the multi-agent debate and produces a tactical recommendation along with reasoning, confidence, and alternative scenario analysis.

One of my favorite simulations involved CSK chasing 195 at Wankhede, with 154/4 on the board, MS Dhoni on strike, and heavy dew expected. The Stats Analyst highlighted historical Bumrah vs Dhoni matchups and the impact of weather conditions. The Strategist initially recommended attacking with Bumrah immediately. The Devil’s Advocate pushed back, arguing that using Bumrah too early could create greater risk later in the innings. The Strategist then revised the decision, saving Bumrah for a more decisive over and adjusting the tactical approach. That visible shift in reasoning was exactly the kind of behavior I wanted this system to demonstrate.

Building this project also came with practical lessons. Multi-agent systems produce much richer reasoning than single-shot prompting, but they also introduce latency and quota challenges because each decision involves multiple model calls. Prompt control became critical because early outputs were too verbose for a live demo. Adding deterministic tools significantly improved trust, since recommendations were grounded in actual logic instead of pure language generation.

This project gave me a much better understanding of agentic AI design—not just how to generate responses, but how to orchestrate structured reasoning between specialized agents. That was the most exciting part of the entire build.

Architecture Diagram

graph TD
UI[Streamlit UI] --> O[Orchestrator]
O --> A[Stats Analyst]
A --> S[Strategist]
S --> D[Devil's Advocate]
D --> R[Strategist Revision]
R --> C[Commentator]
C --> UI

The full source code is available here:
GitHub Repository: https://github.com/DhanashriQAEngineer/captain-cool-ai

This was a genuinely fun hackathon build, and watching AI agents debate how to bowl to MS Dhoni in a death-over chase was far more entertaining than I expected.

Special tag: @antrixsh_gupta