The Difference in Perspective of “Testers” and “Developers”

In this article, we will see the different perspectives of Testers and Developers and their relationship to make a successful application together. 

We use multiple applications on a daily basis. Behind every application, whether it is for shopping, learning, ticket booking, etc there are a number of people. Their contribution has made our life so comfortable through these applications.

Among these, multiple technical people are “Testers” and “Developers”.

Testers and Developers

The aim of testers and developers is the same i.e. to provide a quality product to the stakeholders. But their way of thinking is different.

It is rightly said, “Testers and Developers are not different, but they follow a different path to achieve the same goal”.

Developers think: “How can I make the application?”

Testers think: “How can I break the application?”

Testers and Developers act like Tom and Jerry. But the end result is positive only when they both work together.

By saying “How can I break the application?” does not mean that a tester’s motto is to spoil the work done by developers. This means that the testers by their out-of-box thinking and by placing themselves in the customer’s shoes, apply all possible scenarios on the application. This is done so that the application does not break when it is in the live environment.

For any software application development, Software Development life Cycle (SDLC) plays an important role. Earlier, software testing was done at the last stage of development. But repairing the errors/bugs at the last stage proved to be very difficult and expensive.

To avoid such complexities, software testing is now a part of every phase of SDLC. This means testing starts from the very first phase of development.

“Testers” look at an application from a different creative perspective and if the requirements of the end-users are clearly understood, it makes a lot of difference.

Let’s get a brief idea of the tester’s perspective on the different phases of SDLC:

#1) Requirement gathering and Analysis:

In this phase, as per the requirement of the stakeholder and by accumulating suitable necessities of the application, a requirement document is prepared.

The required document will be shared with the testing team to have their view on the proposed requirements as well as send their queries in the form of a “Review comment”. The queries could be anything, be it the understanding of any particular section or prediction of some future possibilities of errors.

Let us take a very common example: The requirement of the end-user is “No special character is allowed in Input field “.

Developer’s role: Clearly, write a code for inserting an Input field by keeping a check that when a user enters any special character, an error is thrown or a proper error message is displayed.

Tester’s perspective: Tester will first check the stated requirements but then he will have multiple scenarios in mind. He will have questions like:

• What if only special characters are included in the input box? Will it display the same or a different message to the user?
• What if the user copies and pastes any combination of special characters and alphanumeric characters into the input box?

There are many other such scenarios that testers can think of while reviewing the Requirement document.

To evaluate any product or application, testing means questioning a product in order to cover almost every scenario because an end-user could be anyone and can use the application in any manner that they want to.

#2) System/Application design:

After collecting the data and finalization of requirements, the Developers will start their design on the application. This includes a review of the design documents before implementation by the developers.

Testers from their understanding and creative thinking analyse all the possible scenarios for all new features, enhancements, integrations, UI update, anything mentioned in the requirement. They create test cases, sanity check lists and data so that when the application comes for testing, they are ready with their testing parameters.

#3) Implementation phase:

In this phase, developers will implement the finalized system design.

From the developer’s perspective, we see that they are focused on building functionality that is a requirement. In their view, functionality will work perfectly and efficiently.

But when we look at it from a tester’s perspective, it is the exact opposite of a developer’s. When developers focus on implementing the functionality, testers apply all of their creativity to test the functionality. There also might be a case when developers misunderstood the requirement and in that case when testers apply their scenarios, there will be a failure in the application.

#4) System Testing:

In this phase, developers upload the application to staging/QA environment (environment that is available for testers to test) with a defined set of functionalities that have been implemented by the developer in that particular sprint/release.

Developers upload the application with the notion that the functionality implemented is developed perfectly as per the requirements specified; they are just giving application to the testers to re-verify.

But for testers, other than the desired functionality, there are many other different ways an end-user can think of using a particular application. It is the task of the testers to use their creative thinking and explore each and every possible scenario.

#5) Maintenance phase:

This phase is to check the combined efforts of Testers and developers.

The final application after all implementation is sent to the user to use it live. If it is working as desired then there is no problem. But if there is any deviation, it again requires the combined effort of both testers and developers in the maintenance phase.

Testers and Developers together make an effective team as it is the responsibility of both to ensure the best product. This can be achieved if both work hand in hand with proper understanding and take feedback positively.

Let us see some important points that define the role of Testers and Developers:

• While the developers should ensure that there are no bugs in what they develop, the Testers should make sure that if there are bugs, those should be reported and get fixed at the correct time.
• Developers should take the feedback from the tester in a positive and constructive manner.
• It is imperative to say that developers are “specialists” in a particular technical area and they could use all their technical skills to develop a project as per the requirement. Testers are third-party (assume a virtual user for the application) that reports errors or bugs in an effective manner based on which the application’s quality can be determined and areas for improvement identified.

Working as a Tester:

There are, of course, many good developers who can test well. The important point is being a human we can’t test our things/ application on our own, and we do require a second person opinion and feedback.

“Tester” is the person who is not influenced by the application developed and he gives his own judgements based on practical hands-on experience from using the application with all possible scenarios.

A Good Tester knows that a user makes numerous errors while learning and using a new product. Real-time users like to learn how to use a new product by trying and seeing what happens rather than reading a manual.

So, the main focus of the Tester is “What can go wrong”. The main focus of the Developer is to deliver the project as per the requirement.

Recommended read => Why Do You Like Testing?

Good Tester and Developer:

A Good Tester is one who is comfortable with conflicts. Many times it becomes very hard to pinpoint the source of the bug i.e. it may be a coding bug, documentation bug, design bug or may not even be a bug. But it’s the job of the tester to report every bug.

A Good Developer is one who takes feedback in a positive & constructive manner, diagnoses the problem, and debugs it. But developers often avoid conflicts and that causes hindrance.

Further good read => Who Earns More, Software Tester Or Developer?

Conclusion:

So, I conclude my article by saying that appreciating differences is critical for productive teams but different approaches aid in finding solutions, and lead to delivering a product that works at its best.

Everyone is doing their own task. Developers are there to develop an application. Testers are there to test an application.

Through this article, I have one more point to add “If we need to make Project/ Application the best, we need a critic with us who can give reliable feedback”.

About the author: This is a guest post by Sushma S. She is working as a Senior Software Test Engineer in an MNC.

Do you agree with me? Let me know your thoughts and provide your feedback in the comments section below. We would love to hear from you.