Main image of article How to Become a QA Engineer

In simplest terms, a QA engineer runs tests to ensure the quality of software. These tests happen at multiple points throughout the creation and lifecycle of software. If you’re interested in becoming a QA engineer, keep in mind that QA is both an art and a science, and you’ll need to learn a solid range of technical and “soft” skills in order to establish yourself as a professional. Let’s dig in!

What do QA engineers need to learn?

In QA, testing takes place at multiple stages; here are four of the more important parts of testing, and you’ll need to become familiar with all of them:

Unit Testing: As developers build individual components of the system, they also test their code as they’re developing it using a technology called Test-Driven Development (TDD). You’ll want to master TDD. Typically the developers write these tests themselves; however, most developers, even the senior ones, often miss unit tests they should have included. That’s where you, as the QA engineer, can review their tests and point out tests they forgot. You will be the TDD expert who coaches the software developers in their unit testing.

Integration Testing: Since different developers work on different components on the system, the team needs to make sure that the parts all function together correctly, and that the software works as planned. This is called integration testing.

Regression Testing: As the different developers work on different components in the system, things can break. One developer might make a change to one component, and that component passes all its unit tests. But the developer might not realize that another piece of the software depended on the component to function a certain way, and now that other piece breaks. Regression testing will detect problems like that.

Load Testing or Stress Testing: As software runs on a computer or server, it may use up a lot of memory or disk space, or other software running simultaneously might use a lot of the same. How will the software perform under tight memory and disk conditions? Does the app crash? Does it handle the situation well? Load testing will determine this. If the app crashes, the developers can add code to gracefully handle the high-load situation.

Here are some other tools used in QA testing; you’ll encounter them often during your career:

If you’re just starting out, there are also some online resources that will teach you the fundamentals of QA testing, including (but again, not limited to):

Learning automated and manual testing is especially important

The tests listed above are all automated, which means they get started automatically during different stages of development by different DevOps tools, as we’ll describe later. That’s very different from manual testing, which is when someone sits in front of a computer and actively tests various software components; good QA engineers are familiar with manual testing, even if they tend to rely on automated tests.

Manual testing breaks down as follows:

  • Alpha Testing: This is an early set of tests usually run by people who work for the company, typically outside of the software development team. They use the software as much as they can, and report any problems or bugs. The software typically isn’t finished yet; alpha testers can try out those parts of the software that are mostly done.
  • Beta Testing: Once all the features are in place, beta testing takes place. The testers are usually customers willing to try out the software, knowing in advance that there may be bugs and problems. They report the problems back to the QA team so that the developers can fix them.

Programming skills are also key for QA engineers

Some QA engineers don’t write code as part of their job, but many do. Unit testing typically requires writing code in the language being tested; and as mentioned earlier, sometimes QA engineers have to help create the unit tests. For example, the two most popular JavaScript testing frameworks, mocha and jest, require writing code in JavaScript. However, the code is minimal; you don’t have to become an expert in the languages; just learn enough to be able to write the tests.

Remember that programming languages are similar; once you learn one language it’s not too hard to learn another. So spend a little time learning the basics of several current languages, including JavaScript, C#, python, and Java.

Learn the QA aspect of DevOps

DevOps refers to the operational side of software development, such as the tools and processes that automatically deploy software to the cloud so that it can be used. QA and testing is one part of DevOps. Automated tools, when constructed correctly, will pull the code from a code repository, build it, and test it. The tests should all pass; otherwise, the software will not be deployed. This all fits into a subset of DevOps known as CI/CD: continuous integration, continuous deployment.

Be careful when learning DevOps; the field is massive, and it’s easy to get lost in it. If you’re becoming a QA engineer, you’ll want to stick primarily to the testing and QA aspects of DevOps and the tools used in CI/CD. Different shops use different tools; you’ll want to have some familiarity with all of the bigger names, including:

Note that some of these are tools you install on your own servers, while some are cloud-based tools that interact with your cloud environment.

Pro tip: Pick one to learn as much as possible, and from there the concepts should apply to the others. Then spend just a small time with the others so you’re familiar with their features.

Learn GitHub

GitHub is where your team’s code is stored. Many deployment tools, including the DevOps tools mentioned above, can be set up to pull directly from GitHub, after which the code is built and then tested before being deployed automatically.

GitHub is also where team members can add code issues. As the QA engineer, you’ll likely be the person managing those issues. You’ll also want to understand how developers upload their fixes to GitHub in the form of “pull requests.” You may have to manage the pull requests, whereby the code fixes are merged into the existing code base. You don’t need to be an expert on GitHub, but you’ll want to be an expert in issues and pull requests, as well as a basic feel for how GitHub works in general.

Pro tip: Understand that all tests must pass. While that might seem counterintuitive at first, follow it through. Suppose you want to find out what happens if bad data is pushed into the software. In such a case, you don’t want the app to save the bad data to the database. At first glance, you might think that you want to test whether the data was saved to the database and that it should fail in its attempt; that is, the test should fail. This is incorrect, however. Instead you want to frame it in the affirmative: You want to test that data was indeed not stored, and you want that test to pass.

Knowing this, you want to know how to properly construct tests such that every test passes. Unit testing is a great place to practice making sure all tests pass.


QA and Test Engineers are vital roles within the development team. This is typically a separate career track from software development. Many people enjoy software development but don’t want to work as coders; this is an ideal role for them. The QA engineers are often treated with respect and equally alongside the software developers. It can be an exciting and rewarding role as you see the code evolve and the issues get fixed until there are—hopefully!—no bugs left.