Software testing: The key approaches and methodologies
Imagine you enter a clothes store and see every piece of clothing in the same color and size. That’s basically a description of software that never went into testing. Either it suits your needs (accidentally), or it’s completely useless. The purpose of developing a software product is to satisfy a wide range of needs — and life cycle testing is the best way to make it work.
We’ve created a detailed guide that gives you a good understanding of what software testing life cycle is and how to approach it. We also defined the scope of testers’ responsibilities to help you navigate through the development setting in a smarter way.
What is STLC and why your company needs it
Software testing life cycle (STLC) is an important part of developing software, which covers a range of practicality tests and debugging practices. The goal is always the same — ensuring that the software works in a particular setting, for a particular audience.
The concept of software testing reaches back into the 1950s. Even though at its dawn STLC had a very different form and the process of execution. In 1956, software testing was defined as a kind of a debugging-oriented approach — a very cursory software check out. Later on, the purpose of STLC moved into the direction of bugs identification, and eventually became prevention-oriented. So by the end of the 90s, developers would run software testing in order to achieve both — eliminate bugs and ensure software satisfies certain specifications. It’s pretty similar to what we understand under STLC today.
Here are the core phases that make the process of STLC in 2019:
- Analysis of requirements and specifications
- Test planning
- Development of test case
- Setting up test environment
- Running a test
- Closing test cycle.
Each of these phases shares the same DNA: You need entry and exit criteria, deliverables, and an activity itself to make each of them work. For instance, for test case development, you’ll need the following elements:
- Entry criteria: A document with a list of requirements;
- Activity: Run 10 different test cases, based on specified requirements;
- Exit criteria: Reviewed test scripts;
- Deliverables: Testing data.
Let’s dive a bit deeper into what each of the STLC phases represents.
Before we begin, let us note that each of the STLC activities is executed by a team of testers. So we won’t be describing the process of describing requirements, which is done by a development team.
The first touchpoint of a tester with a software development project is receiving a list of requirements. These could be functional requirements describing what a software should do (usually provided by devs), or non-functional requirements that relate to other aspects like security and sustainability (usually listed by security specialists, sales team, etc.) At this point, QAs are mainly responsible for identifying the tests that should be executed and thinking about the testing environment.
This stage is about specific steps you would take to prepare for testing:
- Estimate time and effort;
- Determine what type of training if any you need to complete a test.
- Choosing the tools for software testing.
Typically, by the end of this phase, you have a document with detailed descriptions of your testing environment.
Development of test case
Before you jump into testing, you have to ensure the test data works. This stage involves the development of test cases and automation scripts, which will be a huge help at the time of actual testing. Try to come up with as many successful test cases as possible — this will help you minimize faults with your software.
Setting up test environment
Decide how, when, and where your software will undergo testing. This can either be a part of test case development or a separate phase run by a part of your QA team. Make sure you have everything you need in terms of tools, hardware setup, and other parts of a testing environment before moving to the core stage. If needed, run a smoke test at this point — ensuring that the essential functions of your product work.
Running a test
Once you’re ready with test cases, test data, and environment setup, you can start executing your software tests. Make sure you do the following (and have it carefully documented):
- Results of every test, including the failed ones;
- Failed scenarios/scripts;
- A list of defects and bugs, along with related test cases;
- Results of retesting (if you have it planned) and identified defects.
- Detailed report on the nature of defects you encountered throughout every testing scenario.
Closing test cycle
At this point, you’ll need to verify your exit criteria versus actual deliverables. If a test has been carried out in a small team, you can invite a larger team of QAs to analyze the case. The result of test cycle closure should be a document that covers quantitative and qualitative testing results, evaluation of test coverage, timeline, the key goals, and quality of execution. This will help not only create the best-functioning software product, but also work on mistakes.
Types of software testing methodologies
As we’ve mentioned before, testing is an integral part of software development. In many small companies, a programmer might embrace the role of a QA specialist. Therefore, it’s important to understand the meaning of testing in the context of programming. There are many software development methodologies that help describe the processes.
We’ll define the core three, which shape the biggest chunk of development ecosystems.
Waterfall model represents sequential software development. This means that each of the new phases we’ve talked about previously can start only after the previous one has been finished. The model stems from the old times — when programmers were the ones writing code, testing, and debugging. Which means there had to be an order of things. In modern settings, where software products are developed by teams of architects, engineers, devs, and QAs, Waterfall is becoming outdated. Yet, it can be useful for the projects with very clear specifications that are not likely to change.
Usually, Waterfall Model covers a very specific sequence of phases, which include:
Iterative software development
This is, basically, a variation of Waterfall Model where instead of planning for sequential iterations you break your project into iterations. The same execution, but different approach. Iterative development works well if you have a complete vision of a product right from the start. After completing every iteration, a team would typically collect feedback and make changes before moving on to the next phase.
Agile and Scrum are the buzziest words in the modern tech startup world. The approach of agile software development has been developed as a response to what its predecessors — Waterfall and Iterative Development — failed to address. Mainly, Agile Development is building software via a cycle of repeated iterations, based on the agreements between a client and those responsible for development and testing. It allows keeping up with constantly changing demands.
In other words, Agile Development embodies continuous development and, hence, continuous testing. Due to short development iterations, the team has capabilities for fixing bugs as they go — once a defect in identified, it will be fixed within the same iteration.
Here are the main methods of agile testing:
- Acceptance Test-driven Development (ATDD): Software tests that are based on a combination of points of views. The goal of such tests is matching the expectations of a client with the capabilities of developers and testers.
- Behavior-driven Development (BDD): The type of testing that is based on scenarios — practical examples of how specific features should behave. These are usually done with the involvement of both a client and a development team.
- Exploratory testing: As the name suggests, exploratory testing is about checking how the features work and their actual impact on the use of software. So it’s practice over theory.
Being the most flexible of all, Agile Development enables developers and testers create software that’s highly adaptable to changes. Through daily scrums and repetitive iterations, you can respond to feedback faster than with any other approach.
If you want to dive deeper into the philosophy of Agile, check out Manifesto for Agile Software Development.
How to hire the best software testers
Let’s start with a huge mistake — some companies encourage developers to test the code they produce. Even with a limited budget and lots of work to do, this is an absolute no-no. Not only do programmers fail at applying the right testing methodologies, it’s also a simple rule of human psychology — people tend not to notice their own mistakes, no matter how many times they look into code. Therefore, we encourage you to start a software development journey with at least one professional QA specialist.
If software testing is not even close to your professional domain, we’ll guide you through the major requirements you should set for your candidates.
Training and education of software testers
Talking about the educational background, the perfect case is when a software tester has a degree in Computer Science. There are also two types of tester certifications that are appreciated in most countries:
- CSTE (Certified Software Tester): The certification is issued by the International Software Certification Board and enables you to work in the domains of quality assurance, business analysis, and software testing. Note that passing CSTE exams is not enough to receive the certification — a person should also have the relevant work experience and a bachelor’s degree in Computer Science or similar.
- ISTQB Certification: There are two types of ISTQB testing certifications — Foundations and Expert. Both are issued by the American Software Testing Qualifications Board. This is a better choice for those who want to enter the field and have no relevant education or work experience.
Of course, we live in the we-don’t-need-no-education age, where traditional training makes way less sense than before. What’s important is the practical knowledge of testing methodologies and the ability to flexibly work with diverse projects.
Here’s a set of technical skills we encourage you to look into:
- The knowledge of modern testing tools. Automation has long been an integral part of quality assurance. Therefore, it’s an absolute must for a tester to explore and use automation tools. The least it will give them is a substantial boost in testing speed. For instance, the platforms like Testlink help monitor the test cases across the teams of any size.
- Ability to work with database management systems. Ideally, a QA specialist should be able to handle both SQL and No-SQL databases. This is where the understanding of popular DBMSs like Oracle and MySQL is very helpful.
- The knowledge of a scripting language and Linux commands will be a big plus, especially if the project requires extensive automation.
But that’s only a part of the game. A successful software tester should also have a range of non-technical skills:
- Time management. It’s not a buzzword when we talk about automation and QA specialists. Very often, the time of deployment depends on the length and quality of testing. So we recommend to ensure your candidate is organized and can handle tough deadlines.
- Good analytical skills. A QA specialist should not necessarily be able to code, but it’s definitely a huge plus if a tester understands how software functions and is able to break complex software systems into smaller units that he/she can work with.
- Strong communication skills. You want a person who is able to identify and discuss flaws in your software as well as can communicate the ways to handle them. Plus, a tester is always working in a tight cooperation with developers which requires mutual understanding.
A superstar QA team, in hours
Ok, but how and where do you hire best QA specialists? Especially if you need the whole team, hiring can get complicated. First of all, pay attention to the location. Tester salaries vary depending on where you’re hiring from. According to Testbytes, the average software testing salary in the USA varies between $60,000 and $108,000, but is much lower in Asia and Eastern Europe. For instance, in India the annual rates are between $6,500 and 11,300. This means, if your business is based in the U.S., you’ll save lots of money if you hire QAs from India, Philippines, or Ukraine.
That being said, the main condition for hiring a good tester is knowing what you’re looking for. Check the portfolio and certifications, compare prices across different countries, and run interviews. Or, hire a professional outsource development company and have your team in hours.