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.
- Pages and states. Routes, modals, tabs and the states they can be in.
- Components and locators. The controls on each page, with their roles, accessible names and the locator candidates that identify them.
- Transitions. An action, such as a click, and the page or state it leads to.
- Journeys. Ordered paths through transitions, such as "guest checks out".
- Test cases and scripts. What covers which journey, and which locators each script uses.
- Evidence. Screenshots, DOM snapshots, traces and run results that support each fact.
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.
| From | Action | To | Status |
|---|---|---|---|
| Products | Click "View product" | Product | Validated |
| Product | Click "Add to cart", then "View cart" | Cart | Validated |
| Cart | Click "Proceed to checkout" | Login prompt | Observed |
| Login prompt | Submit valid credentials | Checkout | Inferred |
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.
- You cannot diff them. A transcript from last month and one from today do not tell you which button moved. A graph can: a node was added, a locator changed, an edge disappeared.
- You cannot mark a part stale. An embedding has no idea that the app changed underneath it. A graph fact carries the version it was seen on, so it can be flagged when that version is old.
- You cannot ask where a claim came from. A retrieved paragraph does not link to a screenshot. A graph fact links to its evidence.
- You cannot ask structured questions. "Which journeys have no validated test?" is a query over a graph. It is a guess over a blob.
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.
- What changed. Pages added or removed, controls renamed, transitions that lead somewhere new.
- Which tests are affected. Follow the edges from a changed page or locator to the journeys and scripts that use it.
- 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?
- Testers read journeys, check evidence, confirm or correct facts, and pick what to automate. A person's confirmation is the strongest status a fact can hold.
- Developers look up which journeys use a page they are changing, and open the screenshot behind a failing step instead of asking for a repro.
- New joiners get a browsable map of how the product actually behaves, with the real screens, instead of a stale wiki page.
- QA leads see gaps: journeys with no validated test, pages that were only inferred, and facts that have gone stale.
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.