← Blog

What a knowledge graph of your app gives a QA team

16 Nov 2026 · 6 min read · QEvin team

An application knowledge graph for testing is a structured, versioned map of your app: its pages, controls, locators, the transitions between screens, the journeys users take, the test cases that cover them, and the evidence behind each of those. Because it is structured, you can query it, compare two versions of it, and see what is out of date. A chat transcript or a pile of embeddings cannot do those three things.

What does an application knowledge graph hold?

Think of it as a few kinds of nodes joined by typed edges.

Every node and edge also records a status, where it came from and which app version it was seen on. That last part is what makes the graph trustworthy. For the reasoning behind it, see why AI-generated tests need evidence.

What does a graph look like for a small demo shop?

Take a demo shop with five screens: a products list, a product page, a cart, a login prompt and checkout. A graph of the checkout journey holds something like this.

FromActionToStatus
ProductsClick "View product"ProductValidated
ProductClick "Add to cart", then "View cart"CartValidated
CartClick "Proceed to checkout"Login promptObserved
Login promptSubmit valid credentialsCheckoutInferred

Each row is an edge. The last one is only a guess, because nobody has logged in yet. The graph says so, and it does not let that guess pass as fact. One edge, written out, looks like this. The values are illustrative.

{
  "from": "Cart",
  "action": "click",
  "locator": "getByRole('button', { name: 'Proceed to checkout' })",
  "to": "Login prompt",
  "status": "observed",
  "evidence": ["screenshot", "dom-snapshot"],
  "seenOn": { "appVersion": "2.4.0-staging", "run": "run-17" }
}

A test case then sits on top of the journey. Each step links to a page and a locator the graph has seen work. Each expected result links to something observed, a requirement, or an assumption that is marked as one.

Why is a chat transcript or a vector store not enough?

A transcript is a record of a conversation. A vector store is a way to find text that looks similar to a question. Both are useful. Neither is a model of your app.

QEvin is built so that semantic search, if it is added later, sits beside the graph and does not replace it.

What does versioning and diffing give you after a release?

Each exploration run is built to produce a new version of the graph. Prior versions are not overwritten. That gives a QA team three answers right after a deployment.

  1. What changed. Pages added or removed, controls renamed, transitions that lead somewhere new.
  2. Which tests are affected. Follow the edges from a changed page or locator to the journeys and scripts that use it.
  3. What is stale. Facts recorded on an older build, and locators that no longer resolve, are marked stale instead of staying quietly green.

Suppose the shop renames "Proceed to checkout" to "Checkout". A diff shows one changed control. The graph shows one journey that uses it and one script that clicks it. You fix one locator instead of reading a wall of failed runs. Questions like "which locators are stale in this build?" and "which critical journeys have no validated automation?" become queries, not archaeology.

How does a graph stop every test run from re-exploring the app?

Without stored knowledge, every new session starts from zero. An agent clicks through the same menu it clicked through last week. That costs time and tokens, and it produces slightly different results each time.

With a graph, the next run starts from what is already known. Validated pages and journeys are reused. QEvin is built so that exploration time goes to areas that are new, changed, stale or only guessed at. The graph also lets generated scripts pick locators that were seen to work, instead of inventing new ones each time.

The same idea applies to replay. Once a journey is mapped and validated, a deterministic Playwright script can run it with no model in the loop. The companion post, AI test automation with Playwright: explore first, then replay, covers that split.

Who uses the knowledge graph?

How is QEvin built around this?

QEvin is built to treat the graph as the product, not as a by-product of a chat. It is meant to explore your app in a controlled browser, record what it sees as pages, locators, transitions and journeys, and attach a status, a source and a version to each fact. Generated tests come from the graph. Changes between runs appear as a diff that a person reviews before anything is published to the wider team. People approve publishing, and QEvin will not push code on its own.

QEvin is not released yet. If you want to follow it, the home page has the latest, and the blog has the rest of the series.