Getting Started with ContextQA Test Automation: Training Session 1

This guide is a written companion to ContextQA Training Session 1. The session introduces the platform, explains the testing problems it is built to solve, and then moves into a live walkthrough of the dashboard, creating and running a test, reading the results, and connecting everything to Jira.

If you are new to ContextQA, read this end to end. It follows the same order as the session, so you can pause the video at any point and find the matching steps here.

What ContextQA is and the problems it solves

ContextQA is a software test automation platform. It provides end-to-end testing for teams of any size and across different domains, whether you are an early stage startup, a growing company, or an enterprise. You can start automation from scratch on the platform, or migrate existing test cases onto it.

The session frames the problem first. Many quality issues trace back to the same root causes: not enough test automation, testing that is not continuous, limited test resources, technical debt, requirements that are not aligned with tests, and missing infrastructure for continuous integration and continuous testing. ContextQA is positioned to remove that mundane, repetitive work so teams can test more often without writing code.

To do that, ContextQA offers three ways to build a test:

• No-code: a record and play feature that captures your actions in the browser.
• Low-code: write each step in plain English and the platform turns it into an automated action.
• Pro-code: for complex functionality that the other two paths do not cover, write plain JavaScript or Node.js inside the same test case.

Current coverage includes functional testing, API testing, and mobile testing. At the time of this session, mobile testing was in beta. The platform is multi tenant, so each company gets its own database and resources, which keeps data private and lets ContextQA provide dedicated support.

Find the resources, Chrome extension, and documentation

Before building anything, get familiar with where help lives. On the ContextQA website you can sign up for free, then explore the product and the supporting resources.

1. Go to the ContextQA website and register with your name, email, and password, or use single sign-on.
2. Install the Chrome extension from the link on the site, which opens the Chrome Web Store. The extension is important because it provides the record and validation capabilities.
3. Open the documentation, which covers features like API testing, data driven testing, and cross browser testing, with screenshots and step by step instructions.
4. Browse the videos and webinars linked on the site for extra context.

The Chrome extension works best with Google Chrome. Edge is also supported, and Safari and Firefox modes are available, with Chrome as the primary supported browser. The platform works well with modern web applications across domains such as e-commerce, healthcare, and technology platforms.

Navigate the dashboard and organize test cases

After you log in, you land on the dashboard. It groups test cases by category and shows pass, fail, and execution information. The navigation bar runs along the top left, starting with the home screen, then the option to create a test case, then the test development screen where the main features live.

When you create a test case, you fill in fields that make large test suites manageable:

• Priority, such as critical, major, or minor.
• Type, such as functional or API.
• Status of the test case.
• Prerequisites to run before this test case, which lets you build modular tests.
• Labels, which let you run specific features or test cases against specific pull requests.
• A test data profile for data driven testing.

On the test case list you can search older tests, sort by name or created date, and filter by criteria like priority and type. Once you build a filter, you can save it so that view is available later from the three dots menu. This organization matters at scale. When a customer has thousands or tens of thousands of test cases, labels, categories, and status are what keep delivery on time.

Create and run a test in plain English

Here is the core flow the session demonstrates. Start from a blank test case and write the steps in plain English.

1. Open a new test case so the fields appear empty.
2. Type your first step in plain English, for example navigate to a URL.
3. Add assertions and low-code templates as you type, for example verify the page title or verify the parent page URL.
4. Click Run. ContextQA executes the test automatically, by default in headless mode.
5. Open the run to view the result.

Each execution you trigger is recorded so you build a history over time. Open a run and you get a detailed view: a video of the execution, a full trace of what worked and what did not, and screenshots captured step by step.

We do not just want to say that this is failing. We want to tell you why it is failing. That is the context we add to test execution.

When a step fails, ContextQA shows the actual result against the expected result. In the session, a step expected the title to read one value but the page returned a slightly different value, including a difference in case, so the assertion did not match. You can then handle that with a regular expression or another approach. Failed steps are marked clearly, and logs from the execution help whoever is debugging understand what happened. For larger issues, the analysis is connected to generative AI to help find the cause.

Read results: screenshots, visual regression, and self healing

When you create a test, ContextQA automatically takes a screenshot for each action and keeps it as a golden copy. On every later run it captures fresh screenshots and compares them against that golden copy, so visual regressions surface on their own. This matters because no tester has time to check every element on every screen by hand.

Self healing handles small changes for you. If an element changes in a minor way, for example the same login button is present but its ID changed, ContextQA uses AI to find the alternative and the test keeps running. The run is marked as healed so the change stays transparent and you do not need to re-record. If an element is completely missing from the page, the test fails and reports the exact step where the element was not found, along with the video and screenshots you can hand to a developer.

Link test runs and bugs to Jira

ContextQA leans into Jira rather than replacing it. The goal is to make manual test cases, executions, and coverage visible inside Jira so leadership can see what the QA team is doing without leaving their existing tool.

To raise a bug from a failed run:

1. In your plugins or integration manager, add your Jira account URL, username, and API key to connect.
2. Open the run and click the Jira icon. ContextQA copies the prerequisites and the steps into the ticket.
3. Mark it as a bug, let it load the project you are working on, and set priority and due date.
4. Click Create. The bug is created in Jira with all the details attached.

Inside Jira, ContextQA is a native application that shows test steps, test coverage based on labels, a performance score, the last update, and the last execution status. Because test cases can be mapped to requirements through labels, you get traceability in both directions, so you can ask whether a requirement has test coverage and trace a failure back to its source.

Capture manual testing so it becomes automation

Not every feature is ready for automation on day one, but everything still needs testing. The session shows how to handle that without losing the work.

1. Create a test case in ContextQA even if it is just a placeholder, for example a login screen check, and add whatever notes and flags you have.
2. When you do not have time to automate, use Run manually and step through the test yourself.
3. Mark each step or the overall test as pass or fail and add the result.
4. Add more steps over time during backlog grooming or whenever you find time.

Because you write those steps in the platform as you go, the manual test gradually turns into an automated one. ContextQA captures the execution history whether you ran the test manually or automatically, and that history shows up in Jira. The idea is to put your manual testing effort somewhere that translates straight into automation, without forcing any particular methodology on the team.

Next steps

Sign up for a free ContextQA account, install the Chrome extension, and try the flow from this session: create a test case, write a couple of steps in plain English, click Run, and open the result to watch the video and screenshots. Then connect Jira and create a bug from a failed run. Session 2 builds on this with the Chrome extension recorder, parameterized testing, API testing, and editing test cases in more depth.