Question: How do I become a “Test Automation Engineer” from a “Manual Test Engineer” in the IT field?

Last Updated: 10-Mar-21

The previous version of my answer was quite biased toward Keyword-Driven Testing. I’ve revised my answer to make it more useful to a broader audience.

Step #1. Let’s retrospect first

• What makes you (a Manual Tester) a value-add to your team? Obviously, it’s because you already know how to do Software Testing to ensure Software Quality. So don’t be afraid that you’ll have to start from scratch. In fact, you are ahead of the game.
• Additionally, you also possess the domain knowledge of the industry you're operating in such as banking, refinancing, energy, e-commerce, Salesforce, SAP, Oracle EBS, textile, supply chain inspection, etc. This is where you outshine a programmer who only has the tech stuff covered or someone who has just recently joined the project. Leverage your valuable domain expertise as a competitive advantage in a job interview.

Step #2. Learn Automation-specific Skills

Now that you understand your strengths, let's examine the areas of knowledge that you'll need to learn.

• Element Locator: To automate an app, we'll need to understand how the app is built (HTML, Java, WPF, etc.) so that we can choose a reliable locator to identify the app's UI elements. A useful tool to craft and test element locators for your web app would be POM Builder (Chrome extension).
• Automation API: An automation interaction consists of two 2 main steps : [1] Element matching: the automation tool retrieves an "element locator" and matches it with a run-time UI element (usually some waits are applied), [2] Invoking a UI event on that newly found UI element. As an Automation Engineer, we'll need to get familiar with the API that the automation library provides. For each platform, we have different techniques thus different API to learn:
• Desktop: Reflection, Windows API (use the SendInput() function to simulate a mouse click or keystroke), Microsoft UIA, WinAppDriver API, etc.
• Web: Invoking Javascript events, Selenium WebDriver API, Playwright API, etc.
• Mobile: Appium API, Android UIAutomator, iOS UIAutomation, etc.
• Result reporting: We can use result reporters like Mochawesome, ExtentReports, Allure, ReportNG, etc. to generate a beautiful test report. We just need to learn how to read them and investigate the root cause of a certain test failure.
• Reusability: For web projects, go ahead with the PageObject Model (POM). For other projects, try to wrap repetitive chunks of test steps into a higher-level reusable function so that you can call it over again and again instead of reinventing the wheel. Reusability is very beneficial because you can scale up fast while keeping the maintenance cost cheap.
• Data-Driven Testing: Sometimes we'll find that executing a test repeatedly with different parameter combinations each time is the best way to increase test coverage and ensure quality. Those tests are called "data-driven" tests. In such as case, we'll need to go through the whole test suite and cherry-pick them out, parameterize them (replace hard-coded values by variables), design a good set of test data, then apply the data-driven feature your framework of choice, e.g. TestNG
• Test Execution: Automation runs are a bit different from manual test execution. We'll need to ensure that the test environment is stable so that we don't encounter environment issues (lack of dependencies, the wrong app under test, wrong OS, etc.) that have nothing to do with the quality of the app under test itself.
• Integrate with the larger ecosystem: Automation engineers don’t just automate tests, we also automate the Continuous Testing pipeline, a part of the CI/CD pipeline in DevOps. To do this, we'll usually rely on integration plugins of the automation framework or we must "plumb" the pipeline ourselves, e.g. spin up VM, install the app under test, install the test automation framework, dispatch the tests to the VM, collect all results, aggregate the results to generate a summary report that will be emailed to all stakeholders, etc.

Principles to Apply While Automating

• Readability: Create easy-to-understand tests so that business stakeholders can get on board.
• Scalability: Think long-term and ask what-if questions. What if you need to onboard a new team member? What if you want to port your app from desktop to web, Windows to Linux, iOS to Android, etc.? Can the current test assets be reused to reduce future test development efforts?
• Maintainability: What if more and more app versions are released introducing new business logic and GUI changes that break the current tests? Should some of your tests be parameterized? How to avoid duplication?

Some Other Useful Skills to Learn

• Programming: pick your favorite language, whatever it is, e.g. C#, Java, Python, etc. But I’d recommend Javascript/Typescript. It’s also helpful to be a polyglot.
• Web Techstack: React, Angular, HTML5, XML/XPath, REST, microservices, serverless functions, Lighthouse for frontend performance testing, etc.
• Database: MSSQL Server, MySQL, Oracle, SAP S/4 HANA, etc.
• CI/CD and DevOps: a popular source control system like Git, build tools like Jenkins, Microsoft Team Foundation Server, AWS, Azure DevOps, mobile cloud services like Remote TestKit, SauceLabs, BrowserStack, etc.
• Mini tools: Inspect, UIVerify, Spy++, Chrome DevTools (F12), POSTMan, curl, WireShark, etc.

Step #3. Prepare for a job interview

Step #4. Get the job and be a star

Conclusion

No doubt that career pivots are difficult and scary. But fortunately, transitioning from Manual Testing to Automation Engineer should not be among the hardest ones.

If you’re interested in learning more, check out a more elaborate guide here:

Good luck and happy testing!