STLC (Software Testing Life Cycle) – Overview & Phases
The Software Testing Life Cycle (STLC) is a set of standards and best practices for testing software applications. It guides software testers throughout the testing process and promotes a consistent and comprehensive method for quality assurance practices.
This systematic approach to testing ensures quality standards are met by giving testing teams a framework for planning and executing tests. It typically consists of six phases. However, some teams choose to combine steps, split them, or even add or remove some phases depending on their needs.
Mục lục bài viết
Why the Software Testing Life Cycle is Important
Similar to the Software Development Life Cycle, the Software Testing Life Cycle exists to help teams do their best work in an organized and consistent manner. It supports getting everyone on the same page and gives guidelines for progressing the work. Here are some of the ways the STLC helps teams:
- Teams have a better structure for aligning around the testing goals, scope, and project deliverables.
- The framework helps managers plan timelines and budgets for testing projects.
- The organized processes ensure the overall quality of the product.
- Testing teams benefit from having a framework and boundaries for conducting their work.
Who uses the Software Testing Life Cycle?
Typically, the testing team uses the Software Testing Life Cycle. However, depending on team structure, others connected with the product, such as engineers, testers, and product or project managers, will use it too. For agile teams using the STLC, their testing might include a wide range of folks, from developers to technical support. Sometimes, development and ops teams find it advantageous when setting up testing environments or reviewing defect reports.
STLC vs SDLC
Both cycles relate to the software development process, but their goals differ. Whereas the SDLC begins with gathering and creating requirements, the STLC starts by analyzing those requirements and then planning and executing tests to ensure the software functions in a way that meets those requirements.
The Software Testing Life Cycle can be performed as part of the Software Development Life Cycle or undertaken in parallel. The SDLC is an all-encompassing end-to-end process for building the software, which includes design, development, testing, and more. However, the STLC solely focuses on testing. So while “testing” is a phase within the SDLC, the STLC examines what is required to complete the testing phases.
Entry and Exit Criteria
There are entry and exit criteria for every phase of the STLC. The entry criteria are specific conditions, documents, or artifacts required before beginning a phase. In contrast, exit criteria are the conditions that must be met before a tester can proceed to the next phase of the Software Testing Life Cycle.
The STLC Phases
The Software Testing Life Cycle follows six phases:
- Requirement analysis
- Test planning
- Test design
- Environment setup
- Test execution
- Test cycle closure (reporting)
1. Requirement Analysis
Development projects typically start with a set of software requirements that specify what the business expects from the software application. During this Software Testing Life Cycle phase, the business requirements are analyzed to determine which requirements are testable. The testing team then reviews the testable requirements and works cross-functionally to determine how to test each one. Reviewing occurs during brainstorming sessions, team meetings, and asynchronous communication through team collaboration tools.
Having verified the requirements documents in this phase, the testing team can prepare test artifacts such as the test strategy and plan.
Entry criteria: Requirements, acceptance criteria, and product architecture have been documented.
Exit criteria: Requirements have been verified, and the test lead thoroughly understands which requirements are testable and which are not.
2. Test Planning
This second phase of the Software Testing Life Cycle is considered the most important because it determines what happens in the remaining stages. Test planning takes learnings from the previous phase to create and document the test strategy.
A testing team member creates the test strategy and test plan documents during the planning phase. Other team members can also contribute during this phase, but a senior team member usually owns it. The test plan is a comprehensive document that specifies who is involved, how testing will be done, the scope of work, timelines, and much more.
Entry criteria: Requirements analysis is complete.
Exit criteria: The test plan is completed and includes cost and time estimates.
3. Test Design
After the test plan, it’s time to create the test cases. Also known as the “test case development phase,” the test design phase is when the testing team writes manual test cases and creates automated test scripts.
Test team members can review their peer’s test cases and get approval for their own. This phase includes the necessary work for storing the test cases in a repository such as a test case management tool.
Once the test cases are written, a team lead can review and approve them. Making each test case identifiable and repeatable is essential because tests may need to be re-run as new functionality is introduced over time.
Entry criteria: The test plan has been approved.
Exit criteria: Test cases and test scripts have been written, and test data is created and available for emulating a realistic scenario for each test case.
4. Environment Setup
The test environment is the setting where the testing takes place. This phase often involves input from the development or ops team, as they often build and maintain the various environments. It’s important to have testing environments that match those of your users. For example, if your test group is mainly Android users, you’ll need to be able to test on the Android platform. Similarly, if your users are PC users, make sure you can test on Windows.
After setting up the environment, the development or ops team will need to help the testing team access it through an installation or login process. Depending on your product, you might have several testing environments to set up and create access for.
Entry criteria: The system design and product architecture can be understood.
Exit criteria: The test environment is ready for use, and an initial smoke test has been run and reported.
5. Test Execution
The test execution phase is when testing takes place. It is when testers run test cases, report defects, and update the requirements traceability matrix.
As developers fix reported defects, testers can retest and verify bug fixes. Leveraging both manual and automated tests is essential during this phase to ensure good test coverage. This is sometimes the most chaotic phase of the STLC because the number of tests to run can quickly mount up. Therefore, having the right tools and systems in place to support staying organized, productive, and efficient is vital.
Entry criteria: All exit criteria from previous steps.
Exit criteria: The test execution report, defect report, and requirements traceability matrix are available.
6. Test Closure
In this final phase of the Software Development Life Cycle, the test lead prepares a test closure report showing test coverage and reported defects, which is then shared with the overall product team. The purpose of the test closure report is to summarize the results. A thorough test closure report will include details like the percentage of failed tests, the total number of defects logged, and more.
As a final step of the test closure phase, the testing team should archive test data and other artifacts for future use. From here, the software team plans for how they will release and support the software.
Entry criteria: Test results and all reports and logs are available from previous phases.
Exit criteria: Test lead sends test closure report and test metrics.
Agile Software Testing Life Cycle Phases
The Testing Life Cycle will look slightly different when following the agile methodology. Agile promotes rapid iterations and flexibility, so with this in mind, many of the robust documents we see in the traditional Software Testing Life Cycle are skipped. Let’s look at what a Testing Life Cycle might look like for an agile team.
1. Sprint Planning
Sprints help software teams take large complex projects and break them into smaller, more manageable work units. The sprint planning session is a pre-determined meeting where product managers, developers, and testers discuss the feasibility and scope of work for the next sprint. This is where the team will get an understanding of what exactly needs to be tested.
2. Test Case Design
The testers determine how they will test the software in this phase. Options include documenting and writing test cases, conducting exploratory testing, or something more lightweight, like a checklist.
3. Test Execution
Testing begins once the development has concluded and the code is available for testing in QA. This might involve a dedicated testing team or the developers testing the code they wrote. Agile is flexible and constantly moving, so depending on team structure, the testing phase might involve a range of differently skilled people.
4. Regression and Deployment
It’s essential to ensure any new changes haven’t negatively impacted existing functionality. Therefore, regression testing is necessary during this closing phase before final verification and deployment.
What happens if you don’t follow the STLC?
Whatever your team structure, it’s important to establish guidelines around how you plan, design, conduct, and report on software testing. By not using the Software Testing Life Cycle, you risk wasting time and money and disappointing customers.
If quality assurance is an afterthought, your software will likely have many defects. Bring quality to the forefront by following a set of Software Testing Life Cycle phases that work for your team.
Conclusion
The Software Testing Life Cycle varies across teams and companies, but it exists for a good reason. It enables teams to plan work accurately and helps set expectations with customers on timelines and budgets. It also delivers structure for building a quality assurance program from the ground up. Product owners, engineers, and designers should be familiar with the STLC to work in harmony with their teams. No matter how your team works, the Software Testing Life Cycle will align you with your peers and enable a stronger team with higher performance.
About the writer
Jake Bartlett
Jake Bartlett lives and works in San Francisco, and has a background in software testing, customer support, and project management.
All Jake Bartlett’s articles
