Skip to main content

Quality assurance is becoming more and more popular. Experts estimate that the testing jobs in the US alone will increase by 25% in the next decade. If that interests you, you may wonder where to start learning about software testing.

In this article, I will answer questions to help you get started with software testing. I’ll review what software testing is, the most important testing concepts, and some software testing tools to consider. 

Software Testing Explained

The process consisting of all lifecycle activities, both static and dynamic, concerned with planning, preparation, and evaluation of a component or system and related work products to determine that they satisfy specified requirements, to demonstrate that they are fit for purpose and to detect defects.

ISTQB’s glossary

Software testing plays an important role in the software development process that validates the software application functions as intended and meets the requirements and expectations of its end users.

The goal is to identify defects, errors, and inconsistencies in the software application before it is released to the public. Testing involves running the software in different conditions, configurations, and scenarios to ensure it works correctly and efficiently.

If you're curious about how to start in the software testing field, here's a list of common QA interview questions (and answers!).

Software Testing Life Cycle

The software testing life cycle (STLC) is the process followed by software testers to ensure that the application under test meets the specified quality standards and requirements. The STLC typically consists of several phases designed to ensure that the software application is thoroughly tested and meets the desired level of quality before it is released to the end users. The following are the phases of the software testing life cycle:

infographics of what is software testing

Requirement Analysis

In this phase, the software testers analyze the requirements and specifications. They identify the functional and non-functional requirements, understand the purpose of the software application and the target audience, and develop test cases and scenarios accordingly.

Test Planning

In this phase, the testing team identifies the scope of the testing, the testing approach, and the resources required for testing. The test plan also identifies the risks and constraints associated with the testing process and outlines the testing timeline.

Test Design

In this phase, the testing team designs the test cases and scenarios based on the requirements and specifications. They also identify the test data required for testing and develop test scripts that automate the testing process.

Test Execution

the testers execute the test cases and scenarios designed in the previous phase. The test results are documented, and any defects or errors found in the software application are reported.

Discover what’s new in the QA world.

Discover what’s new in the QA world.

  • By submitting this form, you agree to receive our newsletter and occasional emails related to The QA Lead. You can unsubscribe any time. For more details, please review our Privacy Policy. We're protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.
  • This field is for validation purposes and should be left unchanged.

Test Reporting

In this phase, the testing team prepares a report with the test results and the defects identified during testing. The report may include their recommendations for fixing the defects and improving the software application's overall quality.

Test Closure

It’s the last phase when the testing team evaluates the testing process and identifies areas for improvement. They also prepare a test closure report that summarizes the testing process and the testing outcomes.

The software testing life cycle is a continuous process that requires collaboration between the testing team and the development team to ensure that the software application meets the desired level of quality and functionality.

Types Of Software Testing 

There are different types of software testing used by the QA teams, depending on the project's context and requirements.

We can distinguish between manual testing and automation testing, depending on how the tests are executed. Based on what is being tested, we can differentiate between functional and non-functional testing. Depending on the methods used, we have static and dynamic testing. Based on the approach, we can identify the white box and black box testing types. We also have exploratory testing, smoke and sanity testing, and regression testing. All these testing types may overlap between them, depending on how they are used. 

Manual Testing

With manual testing, the testing is done in person, without using automated tools or scripts. It may be more prone to error and usually takes longer. 

Automation Testing

Automation testing is performed by a machine that executes scripts written in advance. It requires more technical expertise, for example, knowledge of a programming language and automation tools such as Selenium. It can be more expensive than manual testing, and certain aspects of the testing process cannot be automated.

Functional Testing

Functional testing means verifying what the application does. Functional testing checks the software application's features and capabilities and ensures that they meet the requirements and specifications.

Non-functional Testing

As opposed to functional testing, non-functional tests focus on how the app behaves. There are multiple subtypes of non-functional testing, depending on what the main goal of the tests is. I will only cover a few of them in this article. 

Performance Testing: Measures the software application's response time, throughput, and scalability under various load conditions. It checks the software application's ability to handle multiple users and transactions simultaneously and to ensure that it functions efficiently under peak load conditions.

Load Testing: Simulates real-world user loads and is performed to determine a system’s behavior under normal and peak conditions. It’s used to identify whether the infrastructure used for hosting the application is sufficient and tells us how many simultaneous users the application can handle and the scale of the application required in terms of hardware, network capacity, etc. so that more users can access the application.

Stress Testing: Involves testing beyond the normal capacity, often to a breaking point, to observe the results. The goal is to ensure that the software does not crash in conditions of insufficient computational resources (such as memory, disk space, network request, etc).

Security Testing: Ensures the software application is secure and protected from unauthorized access. Security testing checks for vulnerabilities and weaknesses in the software application's security protocols and identifies any potential security threats.

Usability Testing: Used to assess whether the application is user-friendly. It checks how easy it is for users to navigate the software application and perform the intended functions efficiently.

Accessibility Testing: Considered a subset of usability testing, accessibility testing is performed to ensure that the application being tested is usable by people with disabilities.

Localization Testing: A software testing type in which the behavior of software is tested for a specific region, locale, or culture. Some attributes to consider during localization testing: text correctly translated, currency, measurement units, special characters allowed, and phone number formats

Compatibility Testing: Tests whether the application is proficient enough to run in different browsers, databases, hardware, operating systems, mobile devices, and networks

Static Testing and Dynamic Testing

Static testing relies on the manual examination of work products (i.e., reviews) or tool-driven evaluation of the code (think code reviews) or other work products (i.e., static analysis). It can be performed on (but is not limited to) specifications, business requirements, acceptance criteria, source code, test plans, test cases, test scripts, and user guides. 

Dynamic testing Is the actual execution of the software being tested. It can be manual or automated, or

White Box Testing and Black Box Testing 

White box testing is a type of testing where the tester has knowledge of the internal structure of the application’s code, while black box testing is performed without any need to understand the source code. Each of these testing types applies different testing techniques, such as equivalence partitioning, boundary value analysis, and decision table for black box testing, and statement coverage plus decision coverage for white box testing.

Exploratory Testing

Exploratory testing is a type of experience-based testing. It involves minimum planning and maximum test execution. 

The test design and execution activities are performed in parallel, typically without formally documenting the test conditions, test cases, or test scripts.

It’s a useful approach when there are no or poor specifications and time is severely limited, or it works great to complement automated testing.

Smoke Testing 

Smoke Testing, sometimes called “Build Verification Testing” or “Confidence Testing”,  is a software testing process where the testers verify whether the deployed build is stable. Smoke testing is a validation that we can proceed with further software testing. It consists of a minimal number of tests that run on each build to test critical software functionalities. 

Sanity Testing

Sanity testing is a type of software testing carried out following the delivery of a software build with minor code or feature modifications to confirm that the bugs have been resolved and no new issues have been introduced due to these changes. The objective is to confirm that the proposed feature functions roughly as expected.

Regression Testing

Regression testing is a type of software testing where we retest existing functionalities to validate that they still work correctly after any changes or updates to the software application. Regression testing ensures that the new changes or updates have not impacted the software application's existing functionality.

Compatibility Testing

Compatibility testing is used to ensure that the software application works correctly across different platforms, devices, and browsers. It checks that the software application is compatible with various hardware and software configurations

AI-generated image of working robots working on an assembly line to demonstrate how software testing works.

Testing levels

Software testing can be categorized into different levels based on the scope and objectives of the testing. The following are the common levels of software testing:

Unit Testing

Unit testing is the first level of testing and focuses on testing individual components or units of code in isolation. Unit testing verifies that each unit of code performs as expected and meets the specified requirements.

Integration Testing

Integration testing focuses on testing the interactions between different modules or components of the software application. Integration testing verifies that the modules or components work together as intended and meet the specified requirements.

System Testing

System testing is the level of testing where the entire software application is tested as a complete system. System testing verifies that the software application meets the specified requirements and performs as expected in various scenarios.

User Acceptance Testing

Acceptance testing is the level of testing where the software application is tested from the end-user perspective. Acceptance testing verifies that the software application meets the end user's needs and requirements and performs as expected in the user environment. Common user acceptance testing types are alpha testing and beta testing.

Each level of testing is important and serves a specific purpose in the software testing process. Testing should be performed at each level to ensure that the software application meets the desired level of quality and functionality and performs as expected in various scenarios. 

Software Testing Principles

There are seven main testing principles, as defined by the ISTQB:

  1. Testing shows the presence of defects, not their absence: You cannot guarantee the application is defect-free just because it was tested. However, after the testing, confidence in the product can increase.
  2. Exhaustive testing is impossible: Most apps are incredibly complex, so testing every possible combination and variation is impossible, especially because the testing time and resources are also limited.
  3. Early testing: The sooner the bugs and defects are discovered during the software development life cycle, the easier they can be to fix. That’s where Agile gets it right, as testing activities start very early.
  4. Defects cluster together: This means that areas where defects were found will most likely have even more defects. According to the Pareto principle, 80% of defects can be found in 20% of the functionalities.
  5. The pesticide paradox: Running the same tests repeatedly without updating them will not likely uncover any new issues. 
  6. Testing is context-dependent: Applications will be tested differently based on their context - for example, you test an API differently than a user interface, and you test web applications differently than mobile or desktop apps.  
  7. Absence-of-errors fallacy: In short, just because the defects have been found and fixed does not mean the software is useful to its users.

Need expert help selecting the right Testing Software?

If you’re struggling to choose the right software, let us help you. Just share your needs in the form below and you’ll get free access to our dedicated software advisors who match and connect you with the best vendors for your needs.

Conclusion

Software testing is a very complex domain, and many types of testing can be executed. It’s important to adapt your testing strategy based on the context of the software product being tested. There are endless resources on software testing, including podcasts, books, and more.

If you enjoyed this article, please subscribe to the QA Lead’s newsletter and be the first to know about new posts that cover testing and quality.

By Andreea Draniceanu

Hi there! My name is Andreea, I’m a software test engineer based in Romania. I’ve been in the software industry for over 10 years. Currently my main focus is UI test automation with C#, but I love exploring all QA-related areas 😊