Dependency-aware QA test management

Test what changed.
Know what it breaks.

QA TestFlow maps how your features depend on each other. Change one, and it shows every feature downstream that needs retesting, then runs that test pass with your whole team in one live session.

Test categories
6
Sign-off stages
6
User roles
4

// How it's organised

Every test case knows exactly what it covers.

Projects break down into modules, features and functions, and test cases hang off the function they check. That structure is what lets QA TestFlow work out what a change affects.

  1. 01ProjectYour product, its team and its releases
  2. 02ModuleA major area, like Checkout
  3. 03FeatureSomething users do, like Apply coupon
  4. 04FunctionThe behaviour being checked
  5. 05Test casePositive, negative, boundary, UI/UX, performance, responsive

// Dependency map

Pick a feature. See everything it touches.

Features link to the features that rely on them, and the map refuses links that would loop. When something changes, QA TestFlow walks the map so nothing downstream goes untested. Try it on an example shop.

Changed feature

Choose a feature on the map

Its dependents light up, all the way down.

0features to retest
0levels deep

    Example project

    // Test runs

    One test run. The whole team, live.

    Create a task and QA TestFlow pulls in the affected features and their test cases automatically. Everyone works the same session at once: each result syncs to the others the moment it's marked, and the pass, fail and pending counts update for everybody.

    • Mark each case Pass, Fail, Skip or N/A
    • Attach screenshots as proof on any result
    • Checklists per task for the steps that aren't test cases
    • Link to ClickUp: task IDs are checked against your ClickUp workspace

    // Releases

    Nothing ships until everyone signs.

    Group tasks into a release and test them in one combined session. Progress rolls up to the release, which then moves through a sign-off chain. Any stage can block it.

    1. Draft
    2. In testing
    3. QA
    4. Dev lead
    5. BA
    6. Team lead
    7. PM
    8. Released

    Blocked can be set at any stage, and every move is recorded in the release log.

    // Built-in assistant

    An assistant that already knows your test map.

    It works from your own features, dependencies and results. It's rule-based and runs inside QA TestFlow, so your data doesn't go to an outside AI service.

    Write

    Draft test cases

    Suggests cases for a function across every test category, ready to review.

    Find

    Coverage gaps

    Shows the features and categories that have no tests yet, and drafts cases to fill them.

    Predict

    Regression impact

    Estimates what a set of changed features puts at risk before you plan the run.

    Map

    Discover dependencies

    Proposes links between features you haven't connected yet. You approve before they apply.

    Repair

    Heal outdated tests

    Rewrites test cases when the function they check has changed.

    Decide

    Release readiness

    Sums up results and open failures into a go or no-go view for a release.

    Report

    Bug reports

    Turns a failed case into a drafted bug report with the steps filled in.

    Plan

    Tasks & standups

    Turns pasted notes into tasks, summarises a task, and writes the daily standup.

    // Work management

    Plan the work around the testing.

    Tasks, bugs, stories, epics and subtasks on sprints and milestones, with the extras teams expect.

    • Sprints
    • Milestones
    • Custom fields
    • Automation rules
    • Time tracking
    • Templates
    • Watchers
    • Comments & files
    • Linked tasks
    • Tags

    // Access & security

    The right people, provably.

    Project-level roles, two-factor sign-in and an audit trail of every change.

    • Viewer
    • Tester
    • Lead
    • Admin
    • Two-factor sign-in
    • Trusted devices
    • Email verification
    • Audit log

    // Setup

    Running on your own server in five minutes.

    QA TestFlow ships as two Docker images. One compose file starts them with PostgreSQL, Redis and a proxy that serves everything from a single address.

    1. 01 · Before you start

      Any Linux, macOS or Windows machine with Docker and Docker Compose v2.23 or newer (included in current Docker Desktop and Docker Engine).

    2. 02 · Download the two files
      mkdir qa-testflow && cd qa-testflow
      curl -fsSLO https://qulaxy.com/QA-TestFlow-Site/setup/docker-compose.yml
      curl -fsSL -o .env https://qulaxy.com/QA-TestFlow-Site/setup/env.example
    3. 03 · Set the two secrets

      Open .env and fill in POSTGRES_PASSWORD and JWT_SECRET with long random values. On Linux this does it for you:

      sed -i "s|^POSTGRES_PASSWORD=.*|POSTGRES_PASSWORD=$(openssl rand -hex 16)|" .env
      sed -i "s|^JWT_SECRET=.*|JWT_SECRET=$(openssl rand -hex 32)|" .env
    4. 04 · Start it
      docker compose up -d

      Open http://localhost:8080. The first visit asks you to create the admin account. The first start takes a minute while the database is prepared.

    // Your own domain

    Point a domain at the server, then set SITE_ADDRESS=qa.example.com, HTTP_PORT=80, HTTPS_PORT=443 and PUBLIC_URL=https://qa.example.com in .env. The built-in Caddy proxy gets a free HTTPS certificate automatically.

    // Updates

    docker compose pull
    docker compose up -d

    Pin a version with QA_TESTFLOW_VERSION in .env.

    // Backups

    docker compose exec postgres \
      pg_dump -U qatool qatool_db > backup.sql

    Email and ClickUp are optional and set in .env or later in the app's Settings.

    Built with

    Stop guessing what to retest.

    QA TestFlow is a KasunRocz Softwares project. The source code is private; the Docker images are public.