Topics on this page

Quality assurance

Quality assurance (QA) is an integral component of our change management process. The Solution Architecture team outlined a detailed pull request process that includes several review checkpoints. Detailed checklists inform and guide each review stage.

Roles and responsibilities

Below is a summary of the roles and responsibilities of QA at BriteCore. Both roles within the Scrum team collaborate closely on the work they are delivering within their team and inter-team efforts.

Product Owner

Product owners are responsible for:

  • Creation of acceptance criteria.
  • Providing vital business context for backlog items.
  • Acceptance testing when applicable.

Development team

Developers are responsible for:

  • All primary testing of feature development via unit, exploratory, integration, E2E and Regression tests, etc.
  • Test case creation and maintenance.
  • Testing the full-stack, frontend to backend.

Testing development flow

Figure 1 summarizes the test development process:

Figure 1: Test development process.

User story or defects

Each user story outlines acceptance criteria used to guide the tests. This process applies to defects too, to ensure we have appropriate test coverage to confirm that reported issues are fixed.

Unit tests

At this level, the tests are conducted on the smallest piece of code that can be logically isolated in a system.

Functional tests

Focus on an application’s business requirements. They only verify the output of an action and don’t check the intermediate states of the system when performing that action.

Nonfunctional tests

Evaluate the way the system operates rather than specific behaviors by examining performance, reliability, and usability.

Acceptance tests

Run to verify if a system satisfies its business requirements. It isn’t an exhaustive suite of test cases; however, it is expected that all pass for the work to be ready for a customer. Often will rely on the Given [some context] when [some trigger] then [outcome] format.

Exploratory tests

These tests aren’t based on test cases. They provide a quick analysis of the application behavior as you interact with it. Sometimes you might find these quick tests end up becoming test cases that were originally overlooked.

End-to-end tests

These tests are developed after the entire workflow is complete and run from the perspective of an end-user.