ReleaseGate
An AI evaluation SaaS that turns release-or-hold decisions into data - just before launch.
- SaaS
- AI
- FastAPI
- React
Setup
- Problem
In release meetings, "can we ship this?" is decided by gut feel and whoever speaks loudest. The defect list QA gathered sits in the tracker; the user-impact reads PM has live in Slack threads; the change-risk areas engineers know are scattered across PR comments. There's no place where the same information can be compared on the same screen at the same score, so the call falls onto whoever sounds most certain - and that person's mood and air-time creep into the decision. The real problem is that no two people in the room ever read the same one-line answer for "release confidence."
- Context
Fourteen years in QA showed me the same pattern in release meetings, repeatedly: long checklists, no single answer for "release confidence," so the call falls to whoever sounds most certain. The hypothesis behind starting this: the gap isn't that the tools are missing - it's that the decision itself has no tool. The same question keeps recurring in companies that already have JIRA, test reports, and code review.
- Users
PO/PM holding the release call, QA leads watching the risk, engineering managers locking the date.
- Hypothesis
Express release readiness as a single 0-100 confidence score plus a GO / HOLD recommendation, and the conversation shifts from debate to verification.
Build
- What I did
- Designed the Release Confidence Score (0-100) - weighted blend of coverage, open defects, and change-risk areas
- Report UI that shows the GO / HOLD recommendation alongside its reasoning
- AI-drafted test case starters so QA opens an editable draft rather than a blank screen
- PDF report export for stakeholder sharing
- Product decisions
- Single headline number on the score - so a meeting can begin with "what's the number?" instead of debate
- GO/HOLD shown as a recommendation only, never a verdict - acknowledging the limits of automation
- PDF export over integrations for the MVP - minimizing adoption friction
- QA considerations
- Score reproducibility - the same inputs (coverage, open defects, change-risk) yield the same confidence score (deterministic rubric)
- The GO/HOLD recommendation and the human final call stay clearly separated - so it isn't mistaken for an automated verdict
- Input boundaries - empty input and the 50,000-char overflow are safely rejected (TC-P0-001/002)
- Output structure splits consistently by blocker-present/absent (TC-P0-012~015 pinned as regression)
- The LLM response is pinned with a deterministic mock so score computation stays a regression target
- The risk register (docs/03) attaches a verification method and a Mitigated/Open status to most risks, so risk-based verification is traceable from the docs
- The places it falls short of its own gate are surfaced honestly - committed automation concentrates on the CLI rubric,
test_go_nogo.pyis an empty placeholder, and the web-app E2E and coverage targets (docs/05) are still only aspirational
Outcome
- Metrics
MVP stage. Early user interviews in progress; quantitative metrics not yet measured.
- Result / Learning
Confirmed how hard it is to fit "the weight of a release decision" onto one screen. Putting up a one-line score is easy, but for that score to land in a meeting, "how did this score come to be?" has to be visible on the same screen right next to it. If the score is the start of a decision, the reasoning view is the safety net behind it. The next round tests the hypothesis that adoption depends on how the reasoning is presented, not on the number itself.
- Retrospective
- Round one led with the single score as the headline, which pulled "do I trust the number?" forward too fast. Round two starts from the reasoning UI behind the score.
- Trading integrations for PDF export in the MVP - to minimize adoption friction - was the right move for first entry, but it left thin signal on how the report actually gets used in meetings.
Process (planning → build)
The same template from problem and hypothesis through scope, spec (SSOT), build, the QA gate, and release - how this was planned and driven.
Process (planning → build)
Problem & hypothesis
In release meetings, "can we ship this?" gets decided by the most confident voice while the defect list, user-impact, and change-risk areas sit scattered across the tracker, Slack, and PR comments. The hypothesis: compress release readiness into a single 0-100 confidence score plus a GO / CONDITIONAL / HOLDING / NO-GO recommendation, and the call moves from debate to verification (docs/00_context.md, docs/02_prd.md).
Skills · Problem framing · hypothesis
Scope & priority
docs/01_mvp_scope.md pins 13 In-Scope features (the score, the 4-level recommendation, testcase CSV analysis, AI-suggested testcases) against an Out-of-Scope list tiered P1/P2/P3, deferring Jira/Slack integration, prediction models, and auto regression-test suggestions. Features are gated by plan (PDF for Pro+, criteria customization for Max+, API keys for Team), though GitHub integration - listed as deferred P1 - was actually pulled in early as commit review (docs/10_changelog.md).
Skills · Scoping · prioritization
Spec-first (SSOT)
The README states plainly that "docs/ is the SSOT and every change updates docs first, then implements," and docs/02_prd.md carries FR-001 through FR-006 down to input/output tables, Given/When/Then acceptance criteria, and NFR-001 through NFR-006. The release exit criteria (docs/07) reference those same FR/NFR IDs and the API contract (docs/04) in a "related requirements" column, so the spec stays the single reference point for both build and verification.
Skills · Spec · documentation
Build & iteration
Grew from a CLI MVP (src/rubric.yaml, a 10-point rubric, plus go_nogo.py) into a full-stack web SaaS - a FastAPI evaluator module (evaluator, prompts, recommendations) over SQLAlchemy async, with Google/GitHub OAuth, Stripe, R2 storage, WeasyPrint PDF, and Sentry. The React 18 + Vite frontend splits the release input form into planning, risk, QA-status, and suggested-testcase sections and renders the result as a TriRadar chart (web/src/components/ReleaseForm, ResultBoard.tsx).
Skills · Execution · delivery
Verification (QA gate)
The QA background is baked in twice over - the product itself is a release gate, and the repo applies that same gate to its own release: docs/07_release_exit_criteria.md spells out GO conditions, NO-GO conditions, and rollback triggers (5XX over 10/min, login-failure rate over 50%), while docs/03_risk_register.md attaches a verification method and a Mitigated/Open status to most risks. Tests trace from the doc's TC IDs into code - test_input_validation locks the empty-input and 50,000-char boundary cases (TC-P0-001/002), test_output_format locks the blocker-present/absent output structure (TC-P0-012~015), and the OpenAI response is pinned with a deterministic mock in conftest so even the LLM output is a regression target. Honestly, the committed automated tests concentrate on the CLI rubric engine (test_go_nogo.py is an empty placeholder) and the web app's E2E and coverage targets in docs/05 remain aspirational, so the project openly falls short of its own gate in places.
Skills · Quality · risk
Release
Live in production - the frontend deploys to Cloudflare Pages via GitHub Actions (deploy-cloudflare.yml, main=production plus a separate staging branch) and the API runs on Railway (railway.toml, Procfile, nixpacks), observed through Sentry. Status is MVP in early user interviews, with a changelog kept from git commits rather than version tags (docs/10_changelog.md); the beta-end date stated in docs/00 (2026/01/31) has already passed, so the docs are behind.
Skills · Release
- Tech stack
- FastAPI
- React
- PostgreSQL
- OpenAI API
- Links