My Career in Software Testing: Learnings from 3 Mistakes

May 24, 2023Rahul Parwal
My Career in Software Testing A Reflection on 3 Mistakes and What They Taught Me

Start automating your tests 5X Faster in Simple English with Testsigma

Try for free

As a software tester, I have been fortunate enough to work on a variety of projects, from web services to SDK (Software Development Kit) APIs, and in different industries. Throughout my journey, I have learned some valuable lessons, mostly from my own failures. In this article, I would like to share those lessons with you. Whether you are an experienced tester or just starting out, I hope these lessons will help you to be more successful and efficient in your role.

Mistake 1: Neglecting UX: Over Focus on Functionality.

When testing software, it is easy to get caught up in checking that the functionality works as expected. However, testing for usability and user experience is equally important. The software may be functioning correctly, but if it is difficult to use or understand, it will not be adopted by developers and would not be met with a positive response from the customers. Without good usability, you will always risk dealing with people’s problems more instead of technical problems. 

“No matter what they tell you, it’s always a people problem.”

Jerry Weinberg

Lesson 1: Don’t Neglect the UX: Balance Functionality Testing with Usability Testing

  • Implement steps to improve the usability of software, such as clear and easy-to-follow documentation, helpful error messages, unique error codes, avoiding breaking changes, etc.

  • Increase the selling potential of software through good usability testing.

  • Focus on the usability feedback about the product from the sales and customer relationship team.

To ensure that your software is usable, ensure the following:

  • The documentation is clear and easy to follow.

  • The error messages are helpful.

  • There are unique error codes for unique errors.

  • Make sure the documentation does not assume the user to be knowledgeable of the technical jargon.

  • All jargon and abbreviations are documented.

  • Avoid any changes that break the existing functionality without repeated prior notifications in release notes. Ex: It’s very important to mark APIs deprecated well in advance instead of surprising them with breaking changes.

Good usability testing of your software can help you to increase your software’s selling ability. Here is a checklist that I have made to cover important usability checkpoints for your usability testing: Usability Heuristic Checklist – Testing Titbits – Rahul Parwal

Also, Checkout these articles on Testsigma blog to learn more about UX Lessons: 

In one of my initial projects, we made the mistake of using a popular testing tool without fully considering its suitability for our specific use case and problem statement. This turned out to be a costly mistake in the long run, as the tool did not provide the features and capabilities we needed to effectively test and validate our software. We delayed switching to another suitable tool due to sunk cost fallacy.

Sunk cost fallacy is the phenomenon whereby a person is reluctant to abandon a strategy or course of action because they have invested heavily in it, even when it is clear that abandonment would be more beneficial. We eventually had to switch to a different tool that was better suited to our use case and problem statement, but the cost of this transition was significant. 

The sunk cost fallacy is throwing good money after bad.

– Unknown

Lesson 2: Solve the Problem, don’t just chase Trends: Choose Tools Wisely

While it’s understandable to be drawn to a popular tool, it’s crucial to take the time to perform a detailed tool analysis for your current and future needs before making a decision. Having learned this lesson, these are the changes that I have done to my tooling approach:

  • Started a practice of conducting tool analysis before making a decision, taking into consideration parameters such as supported protocols, testability, documentation and community, capabilities, adaptability, etc.

  • Shifted focus from finding a problem for a trending solution (or tool) to solving the real problem.

  • Enabled deep testing by using customizable and flexible tools.

When selecting a tool, consider the following parameters:

  • Supported protocols and standards.

  • The tool should enable your testability.

  • The tool has good documentation and a supportive community.

  • Capabilities of the tool, how well it integrates with your existing systems, and how easily it can be customized to fit your needs.

  • Can it be adapted to accommodate growth, new technologies, and changes in the market.

Testsigma is one such platform that checks all these parameters.

The list of possible factors can be very exhaustive. To ensure that I cover all important points, here is a checklist that I personally use when evaluating new tools: Rapid Software Testing Heuristics for Evaluating Testing Tools.

Mistake 3: No Pairing & Collaboration with Dev Team

During the early stages of my career, I did not collaborate or interact much with my developers. I believed that my role as a tester might get biased if I talk with them or listen to their opinions on testing. However, this is a double edge sword. 

Lesson 3: Unleash Pairing: Collaborate to Innovate

Over the years, I have realized that collaboration is the key when it comes to innovation and one of the most effective ways to do this is through pairing. By pairing with your developers, you can share technical skills, and testing knowledge, and help identify potential risks and challenges early on. This would also contribute towards preventing bugs instead of fixing them. 

One can also ask questions to better plan their testing:

  • What have you tested already?
  • What testing is remaining?
  • How are you mocking the API for your development?
  • Do you have some tools that I can also use?
  • Can we add this feature to enable testability?
  • What are you worried about?
  • Do you want me to deep test certain areas?

By doing so, you tap into the tacit knowledge of your development team and upskill your testing game. Transferring great inter-disciplinary knowledge is also a key aspect of pairing, as it helps bridge the gap between different departments and enhances cross-functional collaboration.

When working with developers, I have found the below practices to be useful in increasing collaboration:

  • Share your testing plans and results with the developers.
  • Ask for their input on the testing process.
  • Debrief your test strategy and test notes.
  • Talk about testability and how developers can enable you to test better.
  • Documenting your test automation solutions to enable test collaboration.

By collaborating well with your developers, you can help to ensure that the testing of software is done with good quality and meets the expectations of your stakeholders.


These are just a few of the lessons that I have learnt from my journey as a software tester. I hope that these lessons will help you to be more successful in your role as a software tester. Whether you are just starting out or are an experienced tester, never stop learning and improving your skills.

The world of technology is changing constantly and it’s important to change, upskill and adapt to the times today. It is also important to treat every failure as a learning opportunity and use it as a building block towards becoming a better testing craftsperson.

Successful people do what unsuccessful people are not willing to do. Don’t wish it were easier; wish you were better.

– Jim Rohn

For all our visual readers, I have summarized this entire article in this mind map.

Embed URL:

Until next time, Happy Testing, Happy Learning!

Subscribe to get all our latest blogs,
updates delivered directly to your inbox.


Top 6 Game Testing Tools You Need to Know


Power of POC in Testing: Your Exclusive Guide to Success


Test objects in software testing | Types & How to Create it?