This will help you in deciding if Software Testing career is the right one for you. Mostly, the first question in interviews that you attend would be, “Tell me about yourself!”
There are three qualities that are important to be a great software tester. What are they? Curiosity to learn, Big picture thinking, and attention to detail. All right! Let’s go! Let’s look at the first quality, “Curiosity to learn”. What makes Software Testing exciting and also challenging is the exploration of software. Exploration is part and parcel of Software Testing. Exploration is done to find out how the software under test works and gain detailed knowledge about that software.
Only when you learn the software in detail, you will be able to gauge whether the software is as per what is expected out of it, by validating whether the software is doing the right thing, and verifying whether the software is doing things in the right fashion. For this, you need to be curious to learn, explore, and experiment. In some cases, you might not have the software available to explore upfront and there might be documents available to tell you how the software should behave. These documents are good starting points to learn how the software works. Based on these documents which are usually the requirements and the functional specifications, you can come up with a plan on how to test the software.
There are a couple of ways to do this. One is to come up with a great test plan with test cases and the other is to have a general charter without detailed test cases. Charters are helpful if your software is expected to go through a lot of changes during development and you need to rework the test cases because of those changes. Mind maps are another way to document the software behavior. Test plans, charters, mind maps are all helpful in exploring the software and noting down a plan to test the software. For this effort to be successful, again, your curiosity to learn is an important aspect. Along with the curiosity to learn the software under test, you need to also have the curiosity to learn the technology stack used for building the software.
There are many things involved in this. Modern software testers are expected to be good at programming languages – not just for automation, but also for reviewing the product code along with the developers. This review is called “pair programming”. This is getting more popular these days and getting traction. As a software tester, you also need to be curious to learn the operating systems for which the software is built, the deployment infrastructure like containers, and the cloud infrastructure platforms. You also need to be curious to learn about the databases that are used by the software to store data, the storage infrastructure in which the software writes and reads the files from, and the details of the networks over which the product communicates with other systems. You might be already aware that you need to be well versed with the automation tools that are used to automate your test cases.
Note that these days, the software under test changes rapidly based on frequent customer feedback and so sometimes the technology stack could also change based on that. As a software tester you got to be nimble and quick to learn the new changes and be ready to test the new scenarios if they are working correctly. You should also be curious to learn about continuous integration, continuous delivery, and continuous deployment. You should also be familiar with the “DevOps” model in which many software systems are delivered today.
The second important quality is “Big picture thinking”. What do I mean by that? We are often caught up with the nitty-gritty details of how a specific module works, or how two or three modules work together when we integrate them. We forget to think about the big picture of how the software would behave as a solution when all the modules are put together. We don’t pay attention to the business needs, how the software should behave in the customer environment which is called as production environment, and the end-to-end flows in which the software would be used.
Those things are pretty important, and part of the big picture thinking. Whenever there is a new feature introduced to the software, or a change done to the software, you need to analyze from the big picture angle on how the overall software behavior would be affected or how the customer needs would be affected. This is pretty important for customer delight and customer success. Another important thing that’s part of big picture thinking is to assess the industry and business that the software is in, and the gap that the software addresses in the business space.
Things to consider are – does the software behavior adequately filling the business gap or what are the latest trends in the industry and the business that the software is in, is there a possibility of a disruption that could invalidate the software or make it lose market share, is this software full proof in addressing this disruption or will it fail to be used by the customers in the near future. These are also questions that you need to keep in mind and analyze while you are looking at the requirements and specifications of the software and bring up with the team when you think that something is not right. This analysis will help the product and the software being successful. In today’s world, there are a lot of dependencies in software. Almost every programming language uses packages, libraries, and open source software. As a software tester, from a big picture perspective, you need to thoroughly analyze what those dependencies are so that you can assess the risks involved in using those packages, libraries, and open source software.
Most of the times, defects or deviance from the behavior in those software are not in your control, but you can look at ways to how to work around or overcome those defects or deviations so that your software would achieve its objectives. Note that this is not just the job of a developer, and testers too should take active part in analyzing these dependencies and giving feedback to the developers. Practically speaking, developers time is limited, and they might not have gone into all the details while inheriting these dependencies to the product code. So, testers can take an active role in looking at the code and giving feedback on these dependencies. The third key quality that you as a software tester should have is “Attention to detail”. We talked about big picture thinking. Attention to detail or paying attention to nitty-gritty details is also a very important aspect of being a successful software tester. Let me share my personal experience on why attention to detail is important. In the recent past, I have been interacting with a few financial organizations in correcting data that have been entered incorrectly in their systems by their employees, with no fault of mine. The first issue was related to an institution entering a wrong reason or purpose code in a transaction which might affect me if the government authorities scrutinize that purpose code and ask me to show the transactions related to the wrong purpose code. The second instance was when two financial institutions interchanged the digits 0 and 1 while entering the numbers into the systems which led to wrong personal information entered into the system and wrong account information entered into the system.