Software Testing

Beginner path · lesson 6 of 35

BeginnerFundamentals4 min readPublished November 12, 2026

The software development life cycle and testing

Software goes through the same basic stages, whatever method a team uses. Here's what those stages are, where testing fits into each one and why testing only at the end is risky.

On this page

Key takeaways

  • The software development life cycle (SDLC) is the path software takes from idea to release and beyond: requirements, design, build, test, release and maintenance.
  • Testing isn't just one of those stages. Every stage has a testing activity, starting with reviewing the requirements.
  • Waterfall, the V-model and Agile arrange the stages differently. In all of them, testing early is cheaper than testing late.

What the SDLC is

The software development life cycle describes the stages software goes through. The names vary, but most models include the same six:

  1. Requirements: what should the software do, and for whom?
  2. Design: how will it be built? Architecture, screens, data.
  3. Implementation: developers write the code.
  4. Testing: check that it works and does what people need.
  5. Release: put it in front of real users.
  6. Maintenance: fix problems, add improvements, keep it running.

Written like that, testing looks like step 4 of 6. That's the misunderstanding this article is here to fix.

Testing happens in every stage

The ISTQB Foundation syllabus puts it simply: for every development activity, there's a matching test activity.

StageWhat testers do
RequirementsReview them. Ask "how would we check this?" Point out gaps and contradictions.
DesignReview designs, spot risky areas, start planning tests.
ImplementationDesign test cases, test early builds, pair with developers.
TestingRun tests, explore, report bugs, retest fixes.
ReleaseCheck the release in its real environment. Give the team a clear picture of remaining risk.
MaintenanceTest fixes and changes, and check nothing else broke.

Finding a problem in a requirement takes a conversation. Finding the same problem after release can take a hotfix, support tickets and lost customers.

The common models

Waterfall

Each stage finishes before the next starts. Requirements are fixed up front, and testing comes after all the code is written.

It's predictable on paper. The risk is that serious problems are discovered at the very end, when there's the least time to fix them.

The V-model

A version of waterfall drawn as a V. Each development stage on the left is paired with a test level on the right.

  • Requirements ↔ acceptance testing
  • System design ↔ system testing
  • Architecture ↔ integration testing
  • Detailed design ↔ unit testing

The useful idea: you plan each test level while you do the matching development stage, not after.

Agile and iterative

Work is done in short cycles, often two weeks. Each cycle goes through all the stages for a small piece of the product.

Testing happens all the time, inside the team. Testers work beside developers and product owners, and a feature isn't "done" until it's tested.

DevOps and continuous delivery

Changes go to users many times a day through an automated pipeline. Automated tests run on every change, and monitoring in production becomes part of testing too.

When testing gets squeezed

Real-world example · HealthCare.gov, 2013A launch without enough testing

HealthCare.gov, the US federal health insurance marketplace, launched on 1 October 2013. Users met outages and errors from the first day.

The US Government Accountability Office (GAO) later found that the systems were not fully tested before launch. It also found that the site launched without confirmation that it met its performance requirements, and that a key readiness review had been pushed back to weeks before launch.

Lesson: when testing is treated as the last stage, it's the first thing to be cut when deadlines slip. Building testing into every stage means problems surface while there's still time to fix them.

What this means for you as a tester

  • Get involved early. Ask to review requirements and designs. Your questions are cheap at that point.
  • Learn your team's model. It tells you when you'll get things to test and how fast feedback is expected.
  • Don't wait for "the testing phase". Test the smallest piece that exists.

Check yourself

Your team uses Agile with two-week sprints. When should testing of a new feature start?

Show answer

At the start of the sprint, or before it. Testers can review the user story and acceptance criteria, ask questions and plan tests while the feature is being built. Then they test pieces as soon as they're ready, not on the last day of the sprint.