Software Testing

Beginner path · lesson 7 of 35

BeginnerFundamentals6 min readPublished November 12, 2026

The software testing life cycle (STLC), step by step

Testing isn't one activity but a sequence: understand what to test, plan, design tests, prepare the environment, run them, report and close. Here's each STLC phase, its entry and exit criteria, and how it looks in an Agile team.

On this page

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.

3. Test case design

Turn requirements into concrete tests: test cases, checklists, test charters for exploratory sessions, and the test data they need.

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.

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.

PhaseTypical entry criteriaTypical exit criteria
Requirement analysisRequirements are availableQuestions answered or logged; testable requirements agreed
Test planningRequirements analysedPlan reviewed and approved
Test designPlan approved; requirements stable enoughTest cases reviewed; test data ready
Environment setupBuild and infrastructure availableSmoke test passes
Test executionEnvironment ready; test cases readyAll planned tests run; no open critical bugs; agreed coverage reached
Test closureExecution finished or stoppedSummary 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:

  1. Refinement: the tester reads the story, asks questions and helps write acceptance criteria (requirement analysis).
  2. Sprint planning: testing tasks and risks are discussed and estimated (planning).
  3. 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).
  4. Definition of Done: the story isn't "done" until it's tested and its bugs are handled (exit criteria).
  5. 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.

Real-world exampleTesting started on a broken build

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.