Glossary of software testing quality assurance terms

Last updated on October 26, 2022

Below are links to articles covering software testing and quality assurance topics. Can’t find what you’re looking for?
Then tell us! We’re always adding to our definitions and we always appreciate suggestions from our readers.


    A/B test

    A/B testing is an excellent way to understand how different designs will engage your users and what they think about the features. A/B testing involves comparing two (or more) different UI options and finding which one is best for a user. This gives you valuable insight into whether or not there are any bugs in these new ideas before going live with them.

    The right interface will make users feel like they are partaking not just in their own task, but also help shape what happens next for everyone else on this platform. In order to get the best results from A/B testing, it is important that you have good instrumentation of your application.

    Acceptance criteria

    Simplified, acceptance criteria is a list of conditions that a feature needs to perform so that users will accept. It helps define exactly how much value stakeholders demand out of your product or service. When writing acceptance criteria, it's important to make sure that the requirements are clear and concise. These should cover all aspects of what is expected from your product or service so there aren't any gaps in functionality upon delivery.

    Acceptance testing

    Acceptance testing is the final stage in a software development cycle. This involves your customers or end-users verifying that your product functions as expected and works well with what you had envisioned for it to do from start to end, before release or public availability. There are various forms of acceptance testing including beta testing, operational acceptance testing, and user acceptance tests which can be done at different levels depending on what's needed most urgently in those cases.

    Accessibility testing

    Accessibility testing is the process of making the application usable by people with disabilities such as vision impairment, hearing disabilities, or other physical and cognitive conditions. It ensures that those who are differently-abled can use your app no matter their condition because they will be able to accomplish what you want them to without any limitations.


    The accuracy of the software product to provide the right or agreed results with the needed degree of precision.

    Actual result

    The actual result is the behavior observed or produced when a component or system has been put under test.

    Ad-hoc testing

    Ad-hoc testing is a type of software testing that is conducted without any planning or preparation. It is usually done by the testers themselves, rather than by formal testing teams. Ad-hoc testing can be performed at any stage of the software development cycle, but it is most effective when used early on, during the design and development phases. The main advantage of ad-hoc testing is that it allows testers to use their creativity and intuition to find defects that may otherwise be missed.

    Additional resources:


    Adaptability refers to the capacity of a software in which it can adapt and perform in various environments. There are no specific actions or methods required to run this software rather than using its existing behavior.

    Agile testing

    Agile testing is a software testing practice that follows the agile software development methodology. Agile testing involves all members of the agile team in quality assurance activities throughout the software development lifecycle. Agile testers work closely with developers to ensure that user stories are testable and that tests are developed early in the process. Agile testers also run automated tests as part of the continuous integration process. Agile testing is an iterative, incremental approach to software testing that can be used in conjunction with other agile software development practices such as test-driven development and behavior-driven.

    Additional resources:

    Alpha testing

    Alpha testing is a type of acceptance testing that is typically conducted at an early phase by the software developers themselves who have the necessary knowledge to provide technical feedback and advice on how to fix what's wrong. Alpha testing is usually followed by beta testing, in which a sampling of the intended audience actually tries the product out, and then followed by the release candidate phase. Alpha testing is usually carried out in a controlled environment, such as the developer's own personal computer, to ensure that any bugs or issues are discovered and addressed before the software is made available to the public.


    An audit is an internal or external verification activity to validate if a software product meets development plans, quality requirements, industry standards, guidelines, and best practices based on defined criteria. A software audit will focus on compliance of product or process rather than the technical quality of this product.

    Automated testing

    Automated testing is a process where software tests are carried out with little or no intervention from a human tester. Automated testing can be used to test the functionality of a software application as well as its compliance with certain standards and guidelines. This can be done using a variety of tools. Automated testing can save you time and money by reducing the need for repeated manual testing.


    Availability is a measure to calculate how often a software is accessible for use. In other words, it is usually counted based on the number of times when the software is available to handle service requests.


    Back-to-back testing

    Back to back testing is a type of software testing in which two or more different versions of a software program are tested against each other. This can be done to verify that the different versions produce the same results, or to identify any discrepancies between them. Back to back testing is often used when upgrading or migrating to new software, to ensure that data will be transferred correctly and that users will be able to access the new system with no problems. It can also be used to compare the performance of different software products, or to test how well a software program functions when it is running on different hardware platforms. In any case, back to back testing is an important tool for ensuring the quality and compatibility of software.


    A baseline refers to a benchmark that is created and formally agreed to form the performance of an application. This can be used for further development and can be changed later via a formal process.

    Beta testing

    Beta testing is a type of software testing in which a beta version of the software is released to a small group of preselected users for feedback. Beta testing is typically the last stage of software testing before the software is released to the general public. The purpose of beta testing is to identify any bugs or issues with the software so that they can be fixed before the final release.

    Beta testers often provide feedback on the usability and user experience of the software, as well as any potential problems with its functionality. Beta testers may also be asked to provide feedback about new features or design changes. Beta testing is an important part of the software development process and can help to ensure that the final product is high quality and user-friendly.

    Blackbox testing

    Blackbox testing is a testing method that mainly focuses on the functionality of an application. It involves comparing an input value with an output value to examine the application's deliverables under various requests.

    Additional resources:

    Branch coverage

    Branch coverage is a type of software testing that tests all the branch conditions in a program. A branch is a coding construct that can have two outcomes, usually 'true' or 'false'. If a branch condition is not tested, it could lead to undefined behavior in the program. This means that branch coverage is a way of ensuring that all possible outcomes of a branch are tested. One common way to achieve branch coverage is with input values that exercise all the different branch conditions. Another approach is to use decision tables which list all the possible combinations of inputs and outputs. Branch coverage can be combined with other types of testing, such as statement coverage, to give an even more comprehensive test.

    Branch testing

    Branch testing, also known as branch condition testing or all-uses testing, is a white box testing technique used to test the conditions and logical constructs of a program code. It is used to test all possible branch paths in the program code. A branch is any point in the code where there is a decision to be made, such as an if-then statement. All branch paths must be thoroughly tested to ensure that the program works correctly no matter what the input data is. branch testing can be time-consuming and difficult to do manually, so it is often automated using tools specifically designed for this purpose. When done correctly, branch testing can help to ensure that a software application is robust and free of defects.


    A bug, in software testing, is an error, flaw, mistake, failure, or fault in a computer program or system that causes it to produce an incorrect or unexpected result, or to behave in unintended ways.

    Bug lifecycle

    Bug Life Cycle (BLC), also known as Defect Life Cycle, is a basic knowledge that plays an important role to help not only testers but also other stakeholders to manage bugs effectively. It contains stages that a bug will go through during its lifetime, which is initiated when a bug is found until it reaches its closure.

    Additional resources:


    Canary testing

    Canary testing is a software testing technique in which a new feature or change is released to a small subset of users (around 5-10% of users). The goal of canary testing is to compare their user experience with users that are still on the previous version of the code. This allows your new code to be tested while running on your production servers under real-world conditions. By comparing the new code against the existing code, you’ll be able to spot any issues and unexpected behaviors, helping to improve future iterations.

    Code coverage

    Code coverage is a measure of how much code is being executed by a given test suite. In other words, it's a way of determining how complete a given set of tests is. There are various types of code coverage, but the most common is line coverage.

    Compliance testing

    Compliance testing is a type of software testing that is performed to ensure that the software meets all industry compliance standards. This can be used to assess compliance with standards such as HIPAA, Sarbanes-Oxley, and PCI DSS. In compliance testing, testers typically create test cases based on the compliance requirements. They then use these test cases to assess whether the system meets all of the compliance criteria. If the system does not meet all of the compliance criteria, it is said to be non-compliant.

    Component testing

    A component consists of several software items that can be tested in isolation. Components are typically tested using the White-box approach. However, Black-box testing can also be used here if there are a few assumptions in coding implementation. The goal of component testing is to verify that each component works as expected and integrates correctly with other components. To do this, tests need to provide suitable input values to ensure that they work correctly as a system.


    Condition is a state where the software will produce the output depending on the input of the condition and it can be evaluated as True or False.

    Condition determination testing

    Condition determination testing is a white-box testing technique in which test cases are executed to independently affect a single decision outcome.

    Condition determination coverage

    Condition determination coverage is the percentage of condition results that independently affect a decision outcome.100% condition determination coverage equals to 100% decision condition coverage.

    Condition testing

    Condition testing is a testing method in which test cases are designed to thoroughly test each logical condition in the program.

    Conversion testing

    Conversion testing is to verify whether a data format can be converted to another data format that can be used by the application.

    Capability Maturity Model (CMM-Levels)

    The capability Maturity Model is a framework to measure the maturity of a software development process. It includes five levels to access an organization: Initial, Managed, Defined, Quantitatively Managed, and Optimizing. Each maturity level is evaluated based on the outcomes of the specific goals.


    Data-driven testing

    Data driven testing is a testing method in which a single test script can be executed for all test data from data sources such as tables or spreadsheets. This testing method helps to keep data separate from the test scripts while it runs on different combinations of input test data and generating test results of the same test scripts.


    Debugging is a process to investigate, diagnose, and analyze to find the cause of an issue in the software.


    Defect is an error in an application that prevents the system from working as expected. The defect occurs when there is an error in coding or in logic that makes the software fail to perform its functionality.

    Development testing

    Development testing is an approach to applying testing during the development phase so that code is written and automatically tested. In this way, development and testing are brought closer to discover and fix issues more quickly.

    Documentation testing

    Documentation testing is a type of non-functional testing in which the documented artifacts will be tested. Testing documentation such as test plans, test case specifications, and test reports are one of the most cost-effective strategies to bring product success.


    End-to-end testing

    End-to-end testing refers to a testing method used in the software development lifecycle to test the functionality from beginning to end via the complete set of user flows. It aims to replicate a real user’s behaviors to ensure the application performs as expected.

    Additional resource:

    Entry criteria

    Entry criteria are the specific conditions or requirements that must be achieved or completed before starting testing.

    Error guessing

    Error guessing is a testing technique that involves using the prior experience of testers to guess or anticipate the error. There is no specific method and it is experience-based testing in which skills are necessarily required.


    Estimation is an activity to calculate and manage the approximate time and resources to complete a test on the software. It helps to forecast the duration and expenses to avoid any over budget and timeline.

    Exhaustive testing

    Exhaustive testing is a process where everything is tested extensively to ensure the application can not malfunction or fails to perform. It includes all possible data combinations used to cover all testing parameters and is also known as complete testing.

    Exit criteria

    Exit criteria defines a set of conditions or requirements which need to be fulfilled before finishing testing.

    Expected result

    Expected result is the ideal outcome that is expected after executing a test case.

    Exploratory testing

    Exploratory testing is a method of evaluating software with no particular plan or test cases in mind. It's the art of breaking things to find out what works and doesn't work. To put it simply: you learn as you go. Exploratory testing in Agile is an important activity in a fast-paced environment as it allows teams to adapt quickly to changes.

    Additional resources:



    Failure refers to a state after the defects are caught and result in the system failing to perform its functions and producing incorrect results.

    Failure rate

    Failure rate is the ratio of the total number of failures of a category to a given unit of measure. Example: failures per unit of time, failures per number of transactions.

    False-negative result

    The false-negative result happens when a test case passes after being executed but the bugs still occur in the software. In other words, a false-negative indicates that there is no bug when there is one. The consequence of false-negative is that the bug leaks to production and causes problems for users. False-negative is harmful as it tells a lie and lets the bug exist on the application.

    False-positive result

    A false-positive result happens when a test case fails while there is no bug after the execution. Although a false-positive result has no impact on the software, it wastes time as testers need to spend time debugging a bug that actually does not occur.

    Functional testing

    Functional testing is a type of black-box testing to verify if the software application works correctly to the functional requirements and specifications. Each function of the application will be checked with the appropriate input and expected output. This type of testing does not require any source code and can be done manually or using automated tests.


    High-level test case

    A high-level test case is established in a general way based on the functionality of an application without going deeply into details of the steps to execute it. A high-level test case has benefits in terms of giving testers a chance to explore edge cases and find more bugs rather than spending time following steps by steps. It also comes with a challenge for inexperienced testers as not all scenarios are covered.

    Horizontal traceability

    Horizontal traceability is a method to track requirements by using test document layers such as test plan, test case specification, and test script.

    Additional resources:


    Incremental testing

    Incremental testing is used as an approach during integration testing to test the modules one by one using stubs or drivers to check the defects. It helps to discover the defects early in a smaller part and detects the cause easily.

    Integration testing

    Integration testing is a technique in which different modules are integrated and tested logically as a group. In that way, this type of testing will check data communication in the interaction between modules, units, or components. Integration testing is necessary to steadily verify if the software modules work in parts before assembling them into an entire system.

    Additional resources:

    Interface testing

    Interface testing is used to verify the proper communication between two separate software systems. An interface can be anything like APIs to web services. In other words, an interface is a software program consisting of a collection of commands, instructions, messages, etc that a device and a user can use to communicate with each other. Some main purposes of interface testing are: to ensure security standards in communication or to access usability issues.

    Interoperability testing

    Interoperability testing is a testing type that evaluates whether an application is compatible with other components and systems without any compatibility issues. It verifies the cross-use functionality between systems and ensures they can interact smoothly. Example: using interoperability testing to check data transfer successfully via Bluetooth from a smartphone to a tablet.

    Invalid testing

    Invalid testing is a method to use input values that will be rejected so that it can check a system in a way that can not be used.


    Keyword-driven testing

    Keyword-driven testing is a technique of functional automation testing framework when data files having keywords are used to run tests. These keywords describe actions to conduct a specific step. This type of testing has a high level of reusability as the tests are concise and easy to maintain. It is also known as table-driven testing or action word-based testing.


    Load testing

    Load testing is used to assess the performance of a system under real-life load conditions. It is done by simulating multiple user demands on software in order to check how the software responds in this condition. Load testing aims to understand and improve the performance and stability of the software.


    Maintainability testing

    Maintainability testing is to test the capability of a system when it needs to be updated, changed, or modified if required. In other words, it checks how easy to maintain the system. This is necessary because changes may happen during the software life cycle and it requires maintenance frequently.

    Manual testing

    Manual testing is a process in which software testers interact with the software application directly, without any automation tool. This process can be carried out to test functionality, usability, or other aspects of the software.

    Additional resources:

    Multiple condition testing

    Multiple condition testing is a technique in which test cases are designed to execute combinations of single condition outcomes (within one statement).


    Negative testing

    Negative testing is a testing technique in which invalid input will be used to conduct test cases. In that way, it will check whether the application performs correctly with negative values. This method helps to ensure that the software is not affected and remains stable under invalid or unwanted data inputs.

    Non-Functional testing

    Non-functional testing is a testing type to check aspects that functional testing can not cover such as performance, usability, reliability, etc. It verifies how well the software should work and helps to increase the usability and efficiency of the product.

    Additional resources:


    Operational acceptance testing

    Operational acceptance testing is used to evaluate the operational readiness of the system before releasing it to production. Operational Acceptance Testing is also known as Operational Readiness Testing (ORT) or Operations Readiness and Assurance Testing (ORAT)


    Pair testing

    Pair testing, a form of exploratory testing, involves two team members working on a single computer to test the same application.

    Additional resources:

    Peak testing

    Peak testing is used to assess how the system works during the busiest time. Example: checking how the banking system performs transactions during the high peak period at noon when there are many users using it.

    Penetration testing

    Penetration testing is a technique to simulate a cyber attack on a system in order to check the exploitable vulnerability. This is a kind of security exercise to demonstrate how robust the system can be to withstand threats and then reveal the business impacts of weaknesses.

    Performance testing

    Performance testing is a testing technique that involves checking how an application performs under a particular load. Performance testing focuses on Speed (to check if the application responds quickly), Scalability (to determine the maximum load that the application can handle), and Stability (to verify if the application is stable under different loads)


    Priority refers to the order that a defect should be resolved. If a defect is set as a high priority, it should be addressed sooner. 

    Process cycle test

    Process cycle test is a black box testing technique using test cases to execute business scenarios and processes. The test basis will include structured information in the form of paths and decision points on the system behavior.


    A prototype in software testing is a system that has been created to simulate production environment data, design, and architecture. This system is used by developers and testers to learn about the application before it is actually built. A prototype also allows developers to test various design scenarios and get feedback from users early on in the development process.


    Quality/quality assurance

    Quality assurance (or QA) is a key component of software testing and refers to the processes and practices involved in ensuring that the quality of an application or product meets established standards. This involves implementing quality control measures at all stages of the development process, from initial design to post-launch evaluation.

    Additional resources:


    Random testing

    Random testing is software testing in a form of functional black box testing in which the system is tested by generating random, independent inputs and test cases. Results of random testing are then compared against specifications to verify whether the test output is a pass or fail.

    Recovery testing

    Recovery testing is a testing technique to verify if the application can recover from failures or hardware crashes. 

    Regression testing

    Regression testing is the practice of ensuring an application still functions as expected after any code changes, updates, or improvements. This crucial step in software development ensures an application remains stable and functional for its users.

    Reliability testing

    Reliability Testing is about exercising an application so failures are discovered and removed before system deployment. The purpose of reliability testing is to determine whether the software meets the customer’s reliability requirements.


    Requirement is a condition to describe how an application should perform to help users achieve a goal. In that way, requirements are used for developers to carry out the implementation. 

    Requirement analysis 

    Requirements analysis is the process of determining user expectations for a new or modified product or system. These should be quantifiable and detailed.

    Requirement-based testing

    Requirement testing in software testing is a process of verifying that a software application meets the required specifications and does not have any defects. Requirement testing is a critical part of the software development process.

    Requirement gathering

    Requirements Gathering is the crucial process of generating a list of requirements (functional, system, technical, etc.). This includes requirements from customers, users, vendors, and more that will be used as the basis for the formal definition of what the project is.

    Requirement planning

    Requirement planning in software testing is the process of creating a plan that outlines how requirements will be gathered, analyzed, and managed. This plan should consider the various stakeholders involved in the process, as well as the tools and resources that will be used.

    Requirement Traceability Matrix (RTM)

    View of RTM once Requirement ID, Test case ID, and Defect ID are linked
    Creating RTM once Requirement ID, Test case ID, and Defect ID are linked

    Requirement Traceability Matrix, or RTM in short, is a document or a tool to map the test cases to business requirements and vice versa. The main purpose of RTM is to provide testing coverage insights. It ensures appropriate testing of requirements and aligns test cases with needs. RTM tracks the testing progress by looking at the status of test cases linked with specific requirements.

    Additional resources:

    Risk-based testing

    Risk-based testing is a testing strategy that involves evaluating the risk of an application based on the complexity, criticality or business, and frequency of use. Risk-based testing usually prioritizes test cases that have more impact and a high possibility of defects.


    Sanity testing

    Testers perform Sanity testing after a few functionalities or some minor bugs fixed are added to the build. The primary purpose is to verify that the changes work as expected while keeping the whole system intact.

    Sanity testing will help to catch any issue early after the build is available for testing. It helps to save time if new functionalities or bug fixes are not working as intended. As a result, the build will be rejected before going to Regression testing, further prolonging the process.

    Additional resources:

    Scripted test

    A scripted test is a type of software testing that relies on pre-written scripts to test the functionality of a system. They are typically used to test core functionality, such as login forms and shopping carts. This allows developers to quickly write and execute tests without having to learn a new language. However, scripted tests can be difficult to maintain and scale, so they are often used in conjunction with other types of software testing, such as manual testing or exploratory testing.

    Security testing

    Security testing is a process used to assess the security of a computer system or application. The goal of security testing is to find security vulnerabilities that could be exploited by attackers. Security testing can be performed manually or using automated tools. Common security tests include penetration tests, security scans, and code reviews.

    Section-based testing

    Section-based testing in software testing is a process of dividing the software into smaller divisions or sections and testing each section separately. By breaking down the software into smaller pieces, section-based testing can help identify errors or bugs more quickly and efficiently.


    Severity in software testing refers to the level of impact that a software bug has on the system. It is classified into four levels: low, minor, major, and critical. The severity level helps determine the priority of the bug and the resources required to fix it.

    • Low severity: bugs that have minimal impact on the system and can be easily fixed.
    • Minor severity: bugs that may cause some inconvenience to the user but can be fixed without much effort. 
    • Major severity: bugs that may cause serious damage to the system or data loss. 
    • Critical severity: bugs that may lead to system failure or security breaches. severity levels are assigned to each bug based on its impact on the system. 

    Shift-left testing

    Shift left testing model graph

    Shift left testing was coined by Larry Smith in 2001 and has its roots in agile software development. The idea behind shift left testing is to reduce defects earlier and more often so that they are easier to fix, less costly, and less stressful on developers. It answers the problem of accelerating software development without compromising on quality.

    Additional resources:

    Smoke testing

    Smoke testing is a type of testing in which QA will execute a group of the most necessary test cases. This is done to check that the key features of an application work appropriately. In software development, smoke testing mainly focuses on the core functionalities to detect any issues in the initial stage. This will help the development team save time and effort before further development and testing.

    Additional resources:

    Software testing lifecycle

    Six phases of software testing lifecycle or STLC

    Software testing lifecycle or STLC for short is a sequence of specific activities performed during the testing process to ensure software quality goals are met.

    Additional resources:

    Specification-based testing

    Specification-based testing is also known as Behavior Based Testing and Black Box Testing as testers only focus on what the software does, not how it does it. 

    State transition

    State transition is the idea that every software system has a finite set of states, and that every event can cause the system to transition from one state to another. 

    State transition testing

    State transition testing is a black box testing technique that can be used to test the behavior of an application in response to various inputs. In state transition testing, the tester identifies all the different states that the system can be in, and then creates test cases to exercise transitions between those states.


    Statement in software testing refers to a single line of code that can be executed by the software.

    State coverage

    State coverage measures whether unit-level tests check the outputs and side effects of a program.

    Statement testing

    Statement testing is a whitebox test design technique in which test cases are designed to execute statements, verifying each line of code work as intended.

    Static testing

    Static testing in software testing is the process of verifying the accuracy and quality of software code at the specification or implementation level without actually executing it. This can be done manually, by having a human review the code, or automatically, by using static analysis tools.

    Stress testing

    Stress testing in software testing is the process of putting stress on the software in order to test its limits. This can be done in a number of ways, but the goal is always to push the software to its breaking point in order to find any potential issues.

    System testing

    System testing in software testing is a process of verifying that a system meets its requirements. This type of testing can be performed manually or with automated tools usually after unit and integration testing have been completed. In system testing, all system components are tested together to ensure that they work as expected. This includes testing the system's functionality, performance, security, and stability.



    Test in software testing is the process of verifying the accuracy and quality of software code. It involves running the code through a set of test cases to check for bugs or errors. Testing can be done manually or automatically.

    See automated testing.

    Test basis

    When conducting software testing, the test basis is the set of documents and other artifacts that provide information about the software under test. This can include requirements documents, design specifications, code, and test plans. The test basis is used to determine what aspects of the software should be tested and how. It also provides a point of reference for evaluating the results of testing. 

    Test case

    A test case in software testing is a set of pre-requisites and required data under which a tester will determine whether an application, software system or one of its features is working as it should. 

    Test case specification

    A test case specification is a document that describes the test cases for a given test item. The test case specification will typically include an objective, inputs, test actions, expected results, and execution preconditions.

    Test coverage

    Test coverage in software testing is a measure used to assess the adequacy of a set of tests. It is a technique used to test how much of the code is being executed by the test suite and how much is not being executed. To put it simply, test coverage is a way of quantifying how much testing has been done. There are different ways to calculate test coverage, but generally, it is expressed as a percentage. For example, if a test suite covers 80% of the code, then that means that 80% of the code has been executed by the test suite and 20% has not been executed.

    Test-driven development

    Test-driven development is a methodology for developing software in which tests are written before code is developed. The idea is that by writing the tests first, you can define the desired behavior of the code and then write the code to match that behavior. This approach can help to ensure that the code meets the requirements of the test and that it is properly tested. 

    Test maintenance

    Test maintenance is the process of making sure that test plans and test scripts are kept up-to-date with the changing codebase. Test maintenance can be a time-consuming and error-prone process, but it is essential for ensuring the accuracy of test results.

    Test plan

    A test plan is a document that outlines the strategy that will be used to test a software application. The test plan includes a description of the test environment, the test schedule, the test cases that will be executed, and the expected results. A test plan is an important tool for ensuring that all aspects of the software application are properly tested before it is released to customers. By creating a detailed test plan, testers can make sure that they are thoroughly testing the software and that they are doing so in a consistent and coordinated manner.

    Test script

    A test script is a set of instructions (written in a scripting/programming language) that is used to test a software application. Test scripts are often used in automated testing and can be run against a test suite or test harness (which is a collection of test scripts). There are many benefits to using test scripts, including the ability to test software more efficiently and effectively. Test scripts can also be reused, which makes them especially useful for regression testing. In addition, test scripts can be easily shared among team members, which helps to ensure that everyone is on the same page.

    Test step

    A test step is a basic unit of testing that consists of an action and an expected result that is documented against the other step. Test steps are often grouped together into test cases, which are used to comprehensively test a software application. By breaking down the testing process into smaller, more manageable pieces, test steps help to ensure that all aspects of the software are thoroughly tested.


    Step 1: From the homepage, click the Sign in button
    Step 2: Input a valid username and password into these fields
    Step 3: Click Enter and observe the result

    Test suite

    A test suite is a collection of test cases that are intended to be used to test a software program to show that it has the required functionality and performance characteristics. A test suite typically contains test cases for positive and negative scenarios, as well as for edge cases. In order to be effective, a test suite must be well-organized and easy to use. It should also be regularly updated as new features are added to the software program.

    Testing pyramid

    The testing pyramid is a guideline that suggests what proportion of tests should be unit tests, integration tests, and exploratory tests. The idea is that most of your tests should be unit tests (which are small and isolated), with fewer integration tests and even fewer exploratory tests (which are time-consuming and manual) - approaching the pyramid from the bottom-up. 

    Testing pyramid examining cost vs speed vs test coverage vs ROI

    This approach can help to improve the efficiency of your testing process by allowing you to focus on the most important test cases. It can also help to prevent you from over-testing, which can lead to wasted time and effort. Of course, the testing pyramid is just a guideline, and you may need to adjust it to fit the needs of your specific project.

    Testing trophy

    testing trophy with 4 phases stating with static at the bottom to end-to-end at the top

    A testing trophy is a bottom-to-top professional method for testing web applications. It helps you write just enough tests—and the right ones at that. The whole idea of the testing trophy is that what is really of value is the return on investment. The trophy comprises four types of tests: End to End testing, Integration testing, Unit testing, and Static testing.

    Additional resources:


    Traceability in software testing is the process of mapping test requirements to test cases, and then to the test results. It provides a clear trace of what has been tested, and what still needs to be tested. Traceability is essential for ensuring that all requirements have been met and that no requirement has been overlooked.

    Transparent box testing

    Transparent box testing, also known as whitebox testing, is a method of software testing that looks at the internal structure of the program being tested. The tester designs test cases based on an understanding of how the software is supposed to work. Transparent box testing can be used to test individual functions or classes, as well as the overall structure of the program. 

    Top-down testing

    Top down testing is a method of software testing where the top level of the software is tested first, followed by the lower levels. In top down testing, test cases are executed on the top level of the code, and if no errors are found, the lower levels are tested. This approach can be contrasted with bottom-up testing, where the lower levels are tested first.


    UI testing

    UI testing is a type of software testing that focuses on the graphical user interface of an application. This can include testing all application flows and user journeys. UI testing can be conducted manually or automatically, which is more commonly referred to as automated testing.

    Unit testing

    Unit testing is a type of test to verify the output of a piece of code working as intended following a given input. Developers, who understand the code structure, mainly perform this whitebox testing method. Whether a piece of code under test is a function (method) or a class, an important rule to keep in mind is that the code to test should be independent or isolated from all dependencies such as file system, database, environment, etc. 

    Additional resources:


    Usability in software testing is the study of how easy it is for users to understand and use a software application. In other words, usability testing is all about making sure that users can easily figure out how to use an app, and that they have a positive experience while doing so. There are a number of different factors that contribute to usability, including the design of the user interface, the overall user experience, and the accessibility of the app.

    Usability testing

    Usability testing is a type of software testing that assesses how easy it is for users to interact with a system. It typically involves recruiting a group of test users and asking them to complete specific tasks using the system under test. The goal is to observe how easily and effectively users are able to complete the tasks and to identify any areas where the system does not meet their needs. Usability testing can be conducted at any stage in the development process, from early prototypes to finished products. However, it is most effective when it is done early and frequently so that usability problems can be identified and addressed before the product is released.

    User acceptance testing

    User acceptance testing is a type of software testing that is suitable for release to end-users. The goal of user acceptance testing is to ensure that the software meets the needs of its intended users and that they are able to use it effectively. User acceptance testing can be conducted using various methods but is most commonly performed using approaches such as beta testing.

    Additional resources:

    User research

    User research in software testing is the process of understanding user needs and requirements in order to create better software products. It involves studying how users interact with a software application and using this information to improve the user experience. User research can be conducted through surveys, interviews, focus groups, and user observation. It is an important part of the software development process as it helps to ensure that the final product meets the needs of its users. In addition, user research can help to identify user pain points and areas for improvement. By understanding the needs of its users, a software development team can create a better product that is more likely to be successful.

    User story

    A user story in software testing is a tool used to describe a user's desired interaction with a system. User stories are written from the user's perspective and typically take the form of: "As a [type of user], I want to [perform some task] so that [I can achieve some goal]." User stories are used to capture user requirements, and they are an important part of agile software development. In addition to describing user interactions, user stories can also be used to specify acceptance criteria for testing. By writing user stories, developers and testers can ensure that the system meets the needs of the users.



    v-model displaying developers life cycle through verification phase to validation phase to tester life cyclet

    The V model in software testing is a visual guide that helps you understand the different steps involved in testing a software application. The V model can be used for any type of software testing, but it's especially useful for waterfall projects, where each stage of testing must be completed before the next one can begin. The V model can help you plan your testing effort, estimate how long it will take, and identify which tests need to be run at each stage. It's also a valuable tool for communicating your testing strategy to stakeholders.


    A key aspect of Acceptance testing, validation is basically ensuring that the software actually works as intended. In other words, validation is performed to check whether the software meets the user's needs. Contrast this with verification.


    Verification in software testing is basically determining whether or not the software meets the specified requirements. This can be done through manual testing or automated testing. Verification can be done using various methods like inspections, walkthroughs, and reviews.

    Visual testing

    Visual testing is a process of testing software by visual means, typically using screenshots. It is used to find visual defects in the software under tests that would be difficult to find with other types of testing, such as incorrect alignment, wrong colors, or missing graphics. 

    Visual testing can be performed manually or automated by taking screenshots and comparing them to a set of expected results.


    Web application testing

    Web application testing is a process of testing a web application to ensure that it is functioning correctly. There are a variety of different types of web applications, so web application testing must be tailored to the specific features and functions of the app being tested. One of the most important aspects of web application testing is making sure that the user interface is easy to use and navigate. This includes testing for things like correct spelling and grammar, as well as ensuring that buttons and links are placed in logical locations. In addition, web application testers must also check for compatibility with different browsers and devices, as well as test for security vulnerabilities. 

    Additional resources:

    Whitebox testing

    Whitebox testing is a method of testing software that looks at the internals of the code and the structure of the application. White box testers design their tests based on an understanding of how the code works and how it is organized. The aim is to explicitly test every part of the code. White box testing is often used in conjunction with Blackbox testing, which focuses on the functionality of the code rather than its internals. Whitebox testing is also known as Glassbox testing, open box testing, or structure-based testing.

    Waterfall testing

    Waterfall testing is a type of software testing where each phase of the software development cycle is completed before moving on to the next phase. Waterfall testing is often used in waterfall model software development, where there is a strict sequence of steps to be followed. Waterfall testing can be an effective way to test software if it is well-designed and well-documented.