Getting Started In Software Testing
Tags: testing, beginners, career, softwaredevelopment
Published: 2023-09-14 18:36:23

There are a number of [articles](https://dev.to/testrigtech/a-comprehensive-guide-how-to-start-your-career-in-software-testing-39jh) out there about [how](https://www.indeed.com/career-advice/finding-a-job/software-testing-engineer) to get [started](https://www.udemy.com/course/your-guide-to-start-software-testing-career/) in software testing, but this is mine. I know several people who are interested in testing and I would like to collect some thoughts and resources in a shared place for them. So, this will be more informally written but hopefully still useful for folks in general.

> Links within the article point to something that serves as an intro to that topic, and hopefully a jumping off point for further research.

## What Software Testers Do

If asked, most people would say software testers find bugs. This is true, but it is part of a larger mission of assessing  the state of the product and reporting the risks to decision makers (borrowed loosely from [James Bach](https://www.satisfice.com/)). Testers use a product, sometimes in a focused or novel way, to see what works and what does not. They report their findings to others who can prioritize and make decisions about releasing in this state. Sometimes bugs need to be fixed. Sometimes it's ok to risk releasing in a less than perfect condition. Testers are the ones who gather the detailed information to aid in those decisions.

Day to day this involves creating, writing, and executing tests or other test related activities. Documentation and analyzing results are also frequent tasks. As a tester progresses in their skills, they may start to write automation code to help speed up their testing or execute tedious portions.

## Important Skills

Even at entry level there are a number of skills that are good to have, or at least be familiar with. Ideally these would be taught to you as a new employee, but that's not how things generally work these days. Fortunately there is the lovely internet to help fill the gap.

While technical skills are important, to be successful at testing long term you need certain soft skills as well. These are important even in the most robotic form of testing where you just execute test cases.

### Technical

#### Familiarity with the SDLC

The [SDLC](https://en.wikipedia.org/wiki/Systems_development_life_cycle) is the Software Development Life Cycle. Basically, it is the process a company uses for turning business requirements into features, getting them into a product, and shipping that product. 

There are many types of processes, but the two you should be familiar with are [waterfall](https://www.tutorialspoint.com/sdlc/sdlc_waterfall_model.htm) and [agile](https://monday.com/blog/rnd/agile-sdlc/). Waterfall is the more classic, linear version and agile is more modern. It was created to address inefficiencies with waterfall.

#### General test concepts

There are a few general test concepts that are good to know. I would be surprised if they did not come up in an interview.

The biggest general concept is [the test pyramid](https://theqalead.com/topics/testing-pyramid/). The idea is that most tests should be targeted, quick [unit tests](https://www.guru99.com/unit-testing-guide.html), then fewer [integration tests](https://www.lambdatest.com/learning-hub/integration-testing) to ensure components work together, and a small amount of [end to end tests](https://www.freecodecamp.org/news/end-to-end-testing-tutorial/), which are slow and can be flaky. While not perfect, the pyramid is a bit of a standard. Looking into it is also a good jumping off point for test types and techniques.

Another general concept is defect tracking. Every company has a different way to track the discovered defects, but the flow is generally the same. Knowing how to [document a defect](https://techbeacon.com/app-dev-testing/how-write-effective-software-defect-reports), how to report it, and what happens to it during and post fix are important.

I should mention [exploratory testing](https://www.softwaretestinghelp.com/what-is-exploratory-testing/) somewhere. This is a test concept based on exploration and the skill of the tester instead of a checklist of test cases. It gaining more traction and is worth reading about. Personally, I think it is a much better way to test than more traditional paradigms.

#### Basic test techniques and heuristics

There are a huge number of test techniques that can be applied. You do not need to know all of them, but know these at a minimum: 
* Black/white/grey box
* Unit/integration
* Load and performance
* Security
* Internationalization/localization
* Accessibility
* Usability

There are also heuristics, or guidelines, of activities you can do within each of the above areas. These include things like decision tables, flow charts, domain analysis, and many others. 

Here are some comprehensive lists with more details:
* [Heuristic cheat sheet](https://www.ministryoftesting.com/articles/ab1cd85c?s_id=15770095) - Bounds to check, pearls or wisdom, and other suggestions
* [Heuristic Test Strategy Model](https://www.satisfice.com/download/heuristic-test-strategy-model) - From James Bach, this doc has several large lists of heuristics to keep in mind

#### Coding

Knowing how to program is not required to test software, but it does help greatly. It will help you view the product source code so you can troubleshoot better and understand the unit tests. Coding allows you to create utilities to help with your testing. Even if this is not full test automation, small ad-hoc programs are useful for verification and generation of large data sets. You can also automate tedious tasks.

I would recommend learning [Javascript](https://developer.mozilla.org/en-US/docs/Web/javascript) or [Python](https://www.python.org/) as a first language. Both are very common, easier to pick up, and do not require a compiler (although there are plenty of online development environments now). If you choose Python, use the 3.x version, not the legacy 2.x version.

Here are two good sites for learning how to code:
* [Codeacademy.com](https://www.codecademy.com/) - Free beginner coding lessons
* [Exercism.com](https://exercism.org/) - Another free site for learning programming languages. It offers quite a few, 67 total, including more advanced languages.

### Soft
#### Lateral thinking

I've come to realize that [lateral thinking](https://en.wikipedia.org/wiki/Lateral_thinking) is incredibly important for software testing. The ability to not only have a Plan B, but a C, D, E, and beyond is necessary since things frequently do not go as planned. This not just for creating test cases, but setting up the conditions for testing and how to work around issues and troubleshoot them.

Besides having a lot of computer or testing experience, it is difficult to develop this skill. Personally I have had success by working on [puzzle hunts](https://www.puzzlehunt.net/list) and playing [heavier board games](https://boardgamegeek.com/thread/1601627/top-100-best-heavy-games-results). You get exposed to a variety of puzzles and mechanics that require you to think outsie of the box. These activities also help you build tenacity.

#### Tenacity/Grit

The ability to stick with a problem and see it through to the end is important. This usually arises when trying to narrow down a defect's behavior or executing difficult test cases. It may not be easy to figure out what to do next, unravel complex behavior, or avoid getting frustrated. Of course, you should also know when something is too difficult and how to ask for help. 

The [standard advice](https://www.lifehack.org/884651/what-is-grit) is to try something you are not good and, practice a lot, and don't give up when it is hard. Good news is that this will happen as you pursue your testing career. Bad news is that it is very difficult in any context. You could also try some of the suggestions above under **Lateral Thinking**. Puzzles and board games can be difficult, but also more bite sized activities.

#### Documentation/organization

Being able to record ideas, activities, and findings are very key for a software tester. You will need to document tests you create and in a format that is easy to follow. You will need to document your findings and write up defect reports. Cleanly written reports make the bug fixing process more efficient and cuts down on your amount of work in the long run, developers and program managers will spend less time getting clarifications with you.

## Education / Certifications

Most testing positions, even entry level, will want you to have a Bachelor's degree in computer science or a similar field. And now my very personal opinion:

> When I started none of the testers had this. I have two electrical engineering degrees, but others had degrees in history, applied match, and analytical chemistry. We all did fine. It's not like a CS degree will teach you anything about testing, so the requirement seems like gatekeeping. Maybe having the college experience is valuable, but I know people who are amazing engineers who don't have a degree at all.

I guess what I want to say is don't feel like you have to have a four year degree in CS before applying. With the internet of today you can learn much more applicable skills online and create a portfolio to demonstrate them. It may be harder to break through that initial round of interviews, but I would also hope companies at least consider everything else on a resume before rejection. Probably a bit naive of me, but I have to try and think positive when I can.

### Online courses

There are many places that offer courses in software testing. Many cost, but are probably worth the money (especially compared to a university). I know there are also lots of YouTube and probably TikTok channels that offer content as well. The following have software testing specific courses, and are generally regarded as top learning sites:

* [Udemy](https://www.udemy.com/courses/search/?src=ukw&q=software+testing) - A popular online learning site. Most courses are paid, but frequently discounted. Here is a [free intro course](https://www.udemy.com/course/your-guide-to-start-software-testing-career/).
* [Coursera](https://www.coursera.org/search?query=software%20testing&) - I have not used it, but it is frequently recommended and has free courses
* [Pluralsight](https://app.pluralsight.com/id) - You need to log in to view the catalog. There is a 10 day trial, but it can be a bit pricey after that. There is not much testing content, but a ton of software stuff in general. I've used them for years and found it worth the money.

### About certifications

Many articles talk about [ISTQB](https://www.istqb.org/) certifications and how those are alternatives to school or a supplement to it. Many organizations also list them as job requirements. However, they are expensive. Cue my personal opinion again:

> From what I've seen these certifications teach an older and more limited idea of what software testing is. Worse, it passes their content off as the industry standard and if you don't follow it, you are lacking. I also have issue with certification programs in general, since they frequently seem like cash grabs and don't offer much in terms of learning skills.

That said, it is worth looking at ISTQB content, but I would not pay their expensive costs. Also, the content provides a decent basis of testing skills and ideas, but **they are not the end all be all of testing**! Please don't spend all your time focusing on this. It may seem like a smart move for getting started, but your time and money can be better spent.

## Getting Experience

And now the hardest part of getting started, obtaining experience. Ideally you would get this in an entry level position, but for some reason companies want testing experience even for entry level jobs. This is doubly baffling to me since its much easier and common to have programming experience than testing. But there are ways to gain experience outside having an internship as a student.

### Crowd sourced freelancing

There are a number of companies that use freelancers to perform test work for clients. The clients supply the tests to run and what devices to run them on, the company distributes that to their freelancers, who run the tests and report back, and all the aggregated results get returned to the client. These freelancers are anyone who signs up and completes some basic training. I do not have experience with this, but it seems like an excellent way to get experience and get paid at the same time. I'm sure the amount is not much, but still.

Here are a few resources to check out:
* [Top 10 list](https://www.softwaretestinghelp.com/crowdsourced-testing-companies/) of crowdsourced test companies
* [uTest](https://utest.com/) - Seems like a popular option
* [Testlio](https://testlio.com/) - Used by a company I worked a contract for. They seemed happy with them.

### Pair with mentor

If you can, find a senior software tester who can be a mentor. Besides passing on skills, they can offer suggestions on how things are done in the real world and ideas on what to study. You could also work with a mentor on pair testing or other activities such as reading discussions. 

Finding a mentor can be difficult. If you know people in tech, ask them if they know of anyone. You can also check out local meetups and groups. Finally, some of the larger testing sites on the internet have mentoring resources. Here is one from [The Test Tribe](https://www.thetesttribe.com/mentor/).

### Test random things and write posts or keep notebook

You can always test things around you and record the results. It doesn't just have to be just software. You can look at any piece of technology, or the system it is a part of, and start creating test cases, strategies, and configurations. You could also do a bit of [exploratory testing](https://www.softwaretestinghelp.com/what-is-exploratory-testing/) and note down what you did, much like a [scientist recording research](https://www.science.org/content/article/how-keep-lab-notebook).

[Michael Bolton](https://developsense.com/) does this [with a notebook](https://michaelbolton.net/presentations/ExploratoryTestingRecordingAndReporting.pdf), but you may want to use something that can be shared online. A tool like [Miro](https://miro.com/index/) or an online note taking app would work. Of course, you could always just take pictures of your notebook pages and share as an image gallery for portfolio purposes.

### Open source contributions

Contributing to an open source project is something that you can link to and demonstrates you have worked in an actual software development flow. Take a look at the list of issues for projects you already use. Some may need further testing or be narrowed down. You could do that and add your findings. You could also test on your own and submit any defects you find.

The testing you do does not need to be limited to functional cases. You could run accessibility tools, security tools, or review the unit tests. Heck, maybe they don't have unit tests at all, so you could ask to establish some. Doing all this will also give you a feel for what it is like to work with a developer to improve the codebase.

## Conclusion

I know if has been forever since I started my software testing career and that the bar is higher since then. However, there are tons of resources out there to help you. I hope what I've presented here is useful. I thought about what I look for when I interview junior testers and what is really important about being a good tester. Some of it is a little non-standard, but it's important to recognize when existing things need to evolve.

If you have any questions, please post in the comments below or send me an email.