Key takeaways
- The software testing life cycle (STLC) is the sequence of activities that turns "we need to test this" into "here's what we found and what's left". Common versions have about six phases, from requirement analysis to test closure.
- Each phase has entry criteria (what must be ready before you start) and exit criteria (what must be true before you can call it done).
- In Agile teams the phases don't disappear. They shrink and repeat for every story and every sprint.
Where the STLC fits
The software development life cycle (SDLC) describes how a product is built, from idea to release. The STLC zooms in on the testing part: what testers do, in what order, to test a release or a feature.
It's a favourite junior interview question, because it shows whether you see testing as a process or just as "running tests".
The six phases
Different companies and courses name the phases slightly differently. This is the most common version.
1. Requirement analysis
Read the requirements, user stories and designs. Work out what is testable, ask questions about anything unclear, and identify the risky areas.
- Output: a list of testable requirements and open questions; sometimes a first traceability matrix.
2. Test planning
Decide how testing will be done: scope (what's in and out), approach, tools, who does what, schedule, risks and the criteria for finishing.
- Output: a test plan, or a lighter test approach for small projects. See test case, test plan and test strategy.
3. Test case design
Turn requirements into concrete tests: test cases, checklists, test charters for exploratory sessions, and the test data they need.
- Output: reviewed test cases and test data. See how to write a good test case.
4. Test environment setup
Prepare where the tests will run: the right build, servers, databases, accounts, devices and integrations. This often runs in parallel with test design.
- Output: a working environment, confirmed by a quick smoke test. See test environments explained.
5. Test execution
Run the tests, record results, and report every failure as a bug. Retest fixes and run regression tests to check nothing else broke.
- Output: test results, bug reports, and status updates as you go.
6. Test closure
Check the exit criteria, summarise what was tested and what wasn't, list known open bugs and their risk, and note lessons for next time.
- Output: a test summary report and a recommendation: ready to release, or not yet, and why.
Entry and exit criteria
Every phase has a gate in and a gate out. They prevent two classic problems: starting work that can't succeed yet, and declaring work "done" when it isn't.
| Phase | Typical entry criteria | Typical exit criteria |
|---|---|---|
| Requirement analysis | Requirements are available | Questions answered or logged; testable requirements agreed |
| Test planning | Requirements analysed | Plan reviewed and approved |
| Test design | Plan approved; requirements stable enough | Test cases reviewed; test data ready |
| Environment setup | Build and infrastructure available | Smoke test passes |
| Test execution | Environment ready; test cases ready | All planned tests run; no open critical bugs; agreed coverage reached |
| Test closure | Execution finished or stopped | Summary report delivered; lessons recorded |
The ISTQB version
The ISTQB Foundation syllabus describes the test process with slightly different names: test planning, test monitoring and control, test analysis, test design, test implementation, test execution and test completion.
The ideas are the same. Two differences are worth knowing for the exam:
- Monitoring and control runs throughout: comparing progress with the plan and adjusting.
- Analysis ("what to test") and design ("how to test it") are separate steps.
The STLC in an Agile team
In a two-week sprint, there's no month-long planning phase. The same activities happen, but small and fast, for each user story:
- Refinement: the tester reads the story, asks questions and helps write acceptance criteria (requirement analysis).
- Sprint planning: testing tasks and risks are discussed and estimated (planning).
- During the sprint: test ideas and cases are written while the code is built (design), and the story is tested on a test environment as soon as it's ready (execution).
- Definition of Done: the story isn't "done" until it's tested and its bugs are handled (exit criteria).
- Sprint review and retrospective: what was tested, what escaped, what to improve (closure).
See Agile and Scrum for new testers for how this looks day to day.
A team had five days to test a release. On day one, the testers started running test cases straight away.
By lunchtime they had logged 23 bugs. Most were the same problem: the test environment was connected to an empty product database, so search, cart and checkout all failed. The developers spent the afternoon triaging duplicates, and the testers had to rerun everything the next day.
The next release, the team added an entry criterion for execution: "environment smoke test passes: a user can log in, search, add to cart and reach checkout". It took 15 minutes and caught a misconfigured environment twice in the following months.
Lesson: entry criteria aren't bureaucracy. They stop the team wasting days on work that can't succeed yet.
Do
Agree exit criteria before testing starts, so "are we done?" is answered with facts, not with the deadline.
Don't
Treat the STLC as paperwork to fill in. Each phase exists to answer a question; if your project doesn't need a document for it, answer the question anyway.
Check yourself
It's release day. 95% of the test cases have run, two major bugs are open and the product owner asks: 'Can we release?' Which STLC phase are you in, and how do you answer?
Show answer
You're at the end of test execution, moving into test closure. Compare the situation with the agreed exit criteria: if they say "no open major bugs", the criteria aren't met. Then give the facts: what wasn't tested, what the two bugs do, who they affect and any workarounds. The release decision belongs to the business, but it should be made with that information.
