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:
- Requirements: what should the software do, and for whom?
- Design: how will it be built? Architecture, screens, data.
- Implementation: developers write the code.
- Testing: check that it works and does what people need.
- Release: put it in front of real users.
- 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.
| Stage | What testers do |
|---|---|
| Requirements | Review them. Ask "how would we check this?" Point out gaps and contradictions. |
| Design | Review designs, spot risky areas, start planning tests. |
| Implementation | Design test cases, test early builds, pair with developers. |
| Testing | Run tests, explore, report bugs, retest fixes. |
| Release | Check the release in its real environment. Give the team a clear picture of remaining risk. |
| Maintenance | Test 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
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.
