Quorra

Quorra tells PMs if it’s safe to release in 60 seconds, using UiPath Test Cloud, Claude Code self-healing, and Slack. One question. One answer. Ship confidently.

Comment

💡 Inspiration

Shipping software safely is one of the most nerve-wracking parts of product development. Every team faces the same stressful question on release day: "Are we safe to ship?"

Today, answering that question is a slow, manual, and subjective slog. QA leads spend days reading Process Design Documents (PDDs) to hand-write test cases. When automated pipelines fail, developers waste hours triaging logs, only to discover that 70% of failures are caused by flaky selectors or environment blips, not real bugs. Ultimately, release decisions are made on gut feel, fragmented spreadsheets, and long sync meetings.

We built Quorra to turn release quality from a game of "vibes" into an autonomous, data-driven, and high-trust loop—running end-to-end on the UiPath platform in under 60 seconds.

🚀 What it does

Quorra is an autonomous quality intelligence agent that manages the entire test-and-release lifecycle. Here’s how it works:

  1. AI Test Generation (Multimodal): Users upload a Process Design Document (PDD/TDD) or simply a screen recording of the application. Quorra parses the inputs (utilizing a Gemini-powered video extraction workflow) and generates a structured test suite.
  2. Risk-Based Prioritization: Every test case is assigned a dynamic 0–100 risk score, sorting the execution list critical-first.
  3. UiPath Test Manager Integration: With one click, the generated test cases and detailed steps are pushed directly into UiPath Test Manager via the v2 API.
  4. Serverless Robot Runs: Users trigger the test set directly from the portal, running it on serverless Orchestrator robots.
  5. AI Failure Triage: If tests fail, Quorra automatically triages the failures into three buckets: Real Product Bugs, Broken Tests (Flakes), and Environment Issues.
  6. Autonomous Downstream Actions: Real bugs are auto-filed in Jira; broken selectors trigger self-healing GitHub pull requests; and environment issues alert DevOps on Slack.
  7. Release Readiness & Chatbot Gate: Quorra calculates a transparent, weighted Release Readiness Score (0–100). Product Managers can ask the conversational agent, "Are we safe to ship?" and receive a clear, evidence-backed GO / NO-GO verdict.

🛠️ How we built it

Quorra is built entirely on the UiPath Automation Cloud stack, integrated with a React/TypeScript SPA frontend:

  • Frontend Coded App: A React 19 + TypeScript + Vite SPA styled with Tailwind CSS, utilizing glassmorphism themes for a premium visual aesthetic.
  • UiPath TypeScript SDK: Integrated via @uipath/uipath-typescript to handle interactive OAuth PKCE logins, trigger serverless Orchestrator processes, upload assets to Storage Buckets, and read jobs.
  • Conversational Agent: A low-code UiPath agent running GPT-4o, acting as the Q&A router and triage brain.
  • Serverless RPA Tool-Processes: Six cross-platform Orchestrator processes created in Studio:
    • Quorra.VideoExtract (Gemini 2.5 Flash video extraction)
    • Quorra Run Test Set (Executes test sets and parses results)
    • Quorra.ComputeReadiness (Weighted scoring process)
    • Quorra.FileJiraBug (Server-side Jira API filing)
    • Quorra.NotifyStakeholder (Slack webhook notification)
    • Quorra.SelfHealPR (GitHub PR automation)
  • Durable State (Data Fabric): Cross-device and team release history is synchronized to the UiPath Data Service utilizing the QuorraHistory entity.

📐 The Release Readiness Formula

We mathematically compute release readiness using the following LaTeX-supported formula:

$$ReleaseReadiness = PassRate - (45 \times P_1 + 18 \times P_2) + \min(2 \times Healed, 6) - 4 \times Gaps - 6 \times EnvFailures$$

A verdict of **GO* is only achieved if the score is $\ge 80$ and there are zero open P1 defects; otherwise, a NO-GO block is enforced.*

🚧 Challenges we ran into

  • CORS Restrictions with Jira API: Browsers prevent direct calls to Jira APIs due to Cross-Origin Resource Sharing. We overcame this by routing the API call server-side through a dedicated UiPath RPA process (FileJiraBug) running on a serverless robot.
  • Video Extraction Pipelines: Processing screen recordings required uploading large media files to UiPath Storage Buckets, triggering an async job, and polling for the Gemini JSON extraction output without blocking the React client UI.
  • Durable State Sync: Merging local-first data (localStorage) with a shared tenant-level persistence layer was tricky. We designed a best-effort sync service (dataFabricService.ts) against UiPath Data Service that resolves offline/online states gracefully.

🎉 Accomplishments that we're proud of

  • The AI Has "Hands": We created a solution where AI doesn't just write reports—it initiates real executions, modifies test cases, files tickets, and opens PRs on external platforms.
  • Video-to-Test Pipeline: Generating high-quality, step-by-step test cases directly from a simple screen recording using Gemini 2.5 Flash integration.
  • Stunning Dashboard Analytics: Designed and coded beautiful custom SVG charts (donut charts, trend bars, reliability heatmaps) showing quality analytics over time.

📖 What we learned

We gained deep expertise in integrating the new @uipath/uipath-typescript SDK, managing serverless robot execution lifecycles, and formatting context-injected multi-turn chatbot conversations. We also learned how valuable UiPath’s serverless architecture is for running resource-intensive test triages and API synchronizations immediately, without paying for running virtual machines.

🔮 What's next for Quorra

  • Self-Healing PRs in Production: Fully productizing the Claude Code workflow to edit selenium/playwright code repos and auto-merge green runs.
  • UiPath Action Center Gates: Deploying BPMN orchestration processes in Maestro to lock CI/CD pipelines until a QA Lead completes a physical approval task.
  • Granular Data Fabric Models: Expanding our Data Service entity schemas to support multiplayer collaborative testing hubs.

What we learned

What's next for Quorra

Built With

Share this project:

Updates

Submission history