The STLC: the testing life cycle
Zoom into testing itself: the six phases of the Software Testing Life Cycle, plus the entry and exit criteria that decide when each phase can start and stop.
In the last lesson we zoomed out and saw the whole journey of building software, the SDLC. Now we zoom in on one box of that picture, the testing box, and discover it has a whole life cycle of its own. It's called the Software Testing Life Cycle, or STLC, and it turns "go test the thing" into an organised, professional sequence of steps.
Why bother with a structured cycle instead of just clicking around? Because organised testing is repeatable, explainable, and far less likely to miss something important. When a manager asks "are we ready to test?" or "are we done testing?", the STLC gives you a real answer instead of a shrug.
The six phases of the STLC
1. Requirement analysis
Understand what to test
2. Test planning
Decide the strategy and scope
3. Test case development
Write the actual tests
4. Test environment setup
Prepare where tests will run
5. Test execution
Run the tests, log the results
6. Test cycle closure
Wrap up and learn
- 1
Requirement analysis
Study what's being built and figure out what's worth testing. You read the requirements, ask questions about anything fuzzy, and decide what's actually testable. A vague requirement is a gift here, because catching it now is far cheaper than catching it later.
- 2
Test planning
Decide the strategy: what you'll test, what you won't, how much time and how many people it takes, what tools you'll use, and what counts as "done". The output is a test plan. This is the brain of the whole cycle.
- 3
Test case development
Write the specific tests: the exact steps, the data to use, and the result you expect each time. A good test case is so clear that someone else could run it and get the same answer.
- 4
Test environment setup
Prepare the place where tests will actually run: the right servers, browsers, devices, accounts, and sample data. A test is only as trustworthy as the environment it runs in.
- 5
Test execution
The hands-on part. Run the test cases, compare what happened to what you expected, and log every difference as a defect. Pass, fail, or blocked: each result gets recorded.
- 6
Test cycle closure
Wrap up. Summarise what was tested, what passed and failed, what's still open, and what you'd do better next time. This is where a team actually learns, instead of repeating the same mistakes.
Entry and exit criteria: the gates between phases
Here's the idea that makes the STLC feel professional rather than chaotic. Each phase has entry criteria (what must be true before you're allowed to start it) and exit criteria (what must be true before you're allowed to call it finished). Think of them as the bouncers at the door of each phase: you don't get in until you're ready, and you don't leave until you're done.
| Phase | Entry criteria (can we start?) | Exit criteria (can we finish?) |
|---|---|---|
| Test planning | Requirements are understood and reasonably stable. | A reviewed, approved test plan exists. |
| Test case development | The test plan is ready. | Test cases are written and reviewed. |
| Test execution | Test cases exist and the environment is ready. | All planned tests are run and results logged. |
| Test cycle closure | Execution is complete; defects are tracked. | Results are summarised and lessons captured. |
Entry and exit criteria stop two classic disasters: starting to test before anything's actually ready (wasting everyone's time) and declaring testing "done" when half the planned checks were never run (shipping blind). They turn "are we ready?" into a checklist instead of a guess.
Don't confuse the SDLC and the STLC, because the names are so similar. The SDLC is the life cycle of building the whole product. The STLC is the life cycle of the testing effort inside it. The STLC lives inside the testing phase of the SDLC, the way a chapter lives inside a book.
- The STLC is the organised life cycle of the testing effort, sitting inside the testing phase of the SDLC.
- Its six phases: requirement analysis, test planning, test case development, test environment setup, test execution, and test cycle closure.
- Entry criteria say what must be true before a phase can start; exit criteria say what must be true before it can be called done.
- Those criteria prevent the two classic blunders: testing before you're ready, and declaring victory before the work is finished.