Human skills to win in Software Testing

Gaurav Singh
8 min readFeb 25, 2023

Hey there, 👋

It’s been some time since I’ve written a blog. Life happened and I was busy taking care of other things. But I want to get back to more regular writing, so here we go. I’ve traditionally written lots of technical posts, so taking a break from it, I wanted to talk about something other than test automation.

This topic is equally if not more important.

Off late I’ve been listening to lots of podcasts about core human motivation and psychology and have been pondering an important question:

What skills does it take to win as a test engineer?

That’s an interesting question. We know Software Testing is a complex and nuanced domain, It can be done at many different intersections of technology some examples of which are Frontend (Mobile, web), Backend (API, message queues), AI, Data and infrastructure, and frameworks supporting it.

If we try to get a list of all the skills you need it would surely be a damn big book to read. There have been some attempts to capture them

Much has been written about how to go about the testing process in different domains whether by hand or through automation.

However, a thing to note is that this wonderful process still is largely done by humans. It’s easier to quantify the hard tech skills needed such as coding, system design, and tools, and there are lots of good resources out there.

But what about other skills that are needed to succeed in this profession, maybe the more human skills?

Let’s take a step back and think about those, shall we?

I self-reflected a bit and asked myself this question:

What skills have worked for you in your own testing career?

Let me try and recollect some of them here

Beginner’s mind

For starters, having a beginner’s mind that is open and curious is important.

Why you may ask?

Well, as test engineers you are trying to discover if the product you are testing satisfies a customer need and to what degree is it successful in that endeavor isn’t it?

Modern software systems are complex, and as you go about testing, it’s easy to fall into the trap of navigating your app flows in predictable patterns (test scripts anyone?) without applying a curious mindset.

Why is this important?

If you are not able to approach the same system you have been testing for years from different angles, then chances are you may miss the edges, corners cases that a customer might find and we all know that it may be too late since in this fast-paced customer-centric world and age of convenience, customers always have alternate options, don’t they?

If your app/service sucks, they may just go to your competitor and you lose a relationship.

Cultivating a beginner’s mind is not an easy skill to develop because as humans we like certainty and it’s much easier to follow set patterns.

We also have our own set of unconscious biases. To develop this, you need to be an good exploratory tester and we are in luck since there are some cool resources out there on this topic

Negotiation

You may think my job as a tester is to break the software (a common misconception, because we discover ways in which the experience is already broken) and other cool engineering things like writing awesome libraries and tools to do automated testing swiftly.

What’s this about negotiation you say?

Allow me to motivate you in this direction.

Any tester worth his salt has to work with others on the team. That means you need to understand what your partners on the team care about to be able to convince them why the direction you are advocating for is worth taking.

  • For instance, Your product manager may care about getting features/updates shipped to customers fast.
  • Developers may want to finish their coding task and move on to the next big shiny thing or feature
  • Designer, Business people, sales, and marketing have their own motivations

How do you make testing a priority for them?

When you find something in the product, a bug, a deviation if you must.

It may be a really important one to fix but how do you convince this boatload of people to prioritize fixing those issues so that we have more happy customers in the end?

Well, you guessed it.

Yes, you need to be a skilled and pragmatic negotiator

Now, building this muscle is hard work, probably one of the toughest skills to acquire.

Do it the wrong way and it won’t take 5 seconds for others on your team to move to their own priorities.

But do it well and you just may be able to convince them.

That brings me to my next important skill

Building relationships and trust

Have you ever tried to negotiate with someone where there is no degree of trust?

How did that work out for ya?

And if you contrast that to negotiation with a friend or with someone where there is a high degree of trust in the relationship, I’m sure you might have been able to find a way to get a win-win result in the end.

I can’t stress this enough, but trust really is the most important thing that you as a tester needs to learn how to build. Trust with your team and XFN (cross-functional partners) i.e. Devs, PM, Design, Sales, Marketing, Business, SRE, DevOps

Some degree of trust gets built implicitly over the time period of working with someone.

Your degree of competence (craftsmanship) goes a long way to establish yourself as someone who is trustworthy and people around you observe how you go about your business.

  • Do you deliver on your promises and do what you say (i.e. walk the talk)?
  • Do you follow up on what you say?
  • Do you show up daily for your team and customers?
  • Do you communicate well (more on this next)?
  • Do you care and teach others and share knowledge about how you go about the testing process?
  • Are you open, transparent, and empathetic (to others’ needs) instead of being critical and judgemental?

All of these little bits and pieces go a long way to building trust. That brings me to a major next point

Empathy

One of the core human skills to develop is empathy.

Empathy is the capacity to understand or feel what another person is experiencing from within their frame of reference, that is, the capacity to place oneself in another’s position Source: Wikipedia

Why is this so important?

Well, that’s how you truly build trust with someone when you can understand where they are coming from and what their motivations are. Knowing this helps you meet them on common ground and move discussions forward.

Let’s take an example, say you found an important bug. Wow, congratulations. The feeling of finding issues is always great.

And then you quickly make the infamous remark (either to your peers ⛔ or hopefully in your own inner minds monologue),

“I don’t understand what the developer was even thinking when developing this, this is basic stuff, How could they miss this? Why can’t they just test all this before handing over the build to me?”

It’s human to think this way but probably not very helpful.

You would be much better served to try and understand why this problem occurred in the first place:

Let’s consider some possibilities:

  • Dev who wrote this feature is new to the company, tools, and processes and is not aware of org-specific good practices
  • Dev might have had 2–3 different priorities in his mind at the same time and missed this case
  • Dev might have been unable to focus due to a personal situation
  • Dev does not understand the system well enough and has gaps in knowledge leading to the miss
  • Dev did not have the perspective to test his feature in the different platforms that are needed

And so on and so forth …

Do you get it?

It could be any of these reasons or perhaps even more.

We need to remember that for now _coding is mostly designed and developed by humans and we should understand that humans make mistakes, which is _ironically the most human thing to do, as the tester should be an ally to the devs and your XFNs and help fix the problems at their root.

If I were to challenge you to pick any of these possible situations above, I’m sure you’ll be able to think of some possible mitigations and you’ll be much better served or move forward

Also, empathy is not just limited to Devs that you work with, it’s across the whole suite of XFN partners and most importantly the customers that you serve. Challenge yourself to do better

How do you show true empathy? One of the ways is rock-solid communication with compassion.

Communication

Next to empathy, this is probably the biggest skill to develop

And hopefully this should come as no secret to you.

Good open and transparent communication is truly the key to developing good work relationships and also to drive projects forward. Have you noticed highly recognized engineers in your org, the community leaders if you will?

Have you observed not just what they say or write but also _how _ they go about it?

There are multiple facets to true effective communication and it’s been heavily written about. You could definitely pick up books on it or watch multiple videos but the most important aspect is to practice doing it well.

In general, To be good at communication. You need to improve as a speaker, i.e. be able to clearly communicate your thoughts, ideas and arguments in a direct and respectful manner.

This is the core of what negotiation skills also build off on. While we refer to them as soft skills, these are hard skills to develop, but the open secret is no one is born a good communicator. You just need to give it time and space and lots of compassionate practice.

What could be some of the ways to improve?

  • Try speaking up in your team meetings, bug triages, community
  • Try to gather feedback around it.
  • You could challenge yourself to even try public speaking in internal or external conferences

Communication is not just spoken, written communication is a large part of it as well.

Just take a step back and think how many percent of time do you spend writing, be it on chat messages, emails, docs, slides. So on and forth.

It’s a massive advantage to be able to write and express your ideas into words that are not only clear but also concise and communicate the meaning well enough. One way to improve is to develop the habit of writing.

You could start a blog or if you are a bit shy, write a couple of paragraphs each day in a personal google doc. AI assisted writing softwares could be a good addition to your toolbelt as well

Closing thoughts

So let’s recap and bring it home, shall we?

To be an excellent Test engineer, you need:

  • Beginner’s mind: Be curios and develop ability to look at things from a fresh perspective
  • Negotiation: Be able to build consensus, resolve conflicts and negotiate with other partners in your team or org
  • Build trust: Know how to build relationships and develop mutual trust
  • Empathy: Develop empathy towards other XFN partners and customers
  • Communication: Be an excellent communicator

Did I miss anything here?

Let me know will ya? I would love to hear your thoughts in comments

Thanks for the time you spent reading this 🙌. If you found this post helpful, please share it with your friends and follow me (@automationhacks) for more such insights in Software Testing and Automation. Until next time, Happy Testing 🕵🏻 and Learning! 🌱

Newsletter YouTube Blog LinkedIn Twitter.

Originally published at https://automationhacks.io on February 25, 2023.

--

--

Gaurav Singh

Software Engineer passionate about Software Testing, Test Automation {Tooling, Frameworks, Infrastructure}, and scaling teams.