If you work in manual quality assurance (QA), you already know how to investigate software, question assumptions, and explain failures. Moving into automation means adding programming and engineering practices to that experience. Moving into product software development requires another step: learning to design, build, and maintain application features.
This guide uses “automated software engineering” to describe the move toward coding-based test automation and, where it fits your goals, broader software development. It is not a single standardized job title. The roadmap below gives you a sequence of skills, practical milestones, and ways to demonstrate progress without promising a fixed transition timeline.
Understand the three paths before choosing your next role
- Manual testing uses human observation and judgment to explore software, follow test cases, investigate unexpected behavior, and assess risks. Exploratory testing means learning about the product while designing and performing tests.
- Test automation engineering uses code to run repeatable checks, prepare test data, report failures, and maintain testing infrastructure. The work includes deciding what to automate and keeping the results trustworthy.
- Software development focuses on implementing product behavior: interfaces, business rules, services, data storage, and integrations. Developers also test, debug, review, and maintain their work.
The skills overlap, but the responsibilities and hiring expectations differ. Automation interviews may emphasize test design, frameworks, failure diagnosis, and reliable test suites. Development interviews may require stronger evidence of feature implementation, application design, data handling, and coding fundamentals. Exact expectations depend on the role.
Automation can be a stepping stone toward development, or a career direction in its own right. Titles such as QA automation engineer, test engineer, quality engineer, and software development engineer in test (SDET) vary between companies.
Manual testing still serves a purpose. A scripted check answers a defined question; it does not replace every investigation into confusing behavior, usability, or an unexpected risk. Your goal is to combine human judgment with repeatable checks, not automate every manual activity.
Recognize the engineering skills you already use
- Test-case design transfers to writing clear assertions: statements that check whether a result matches an expectation.
- Edge-case identification helps you choose boundary values, invalid inputs, missing data, and unusual sequences of actions.
- Bug reproduction transfers to creating a small, repeatable example that makes a defect easier to diagnose and fix.
- Troubleshooting helps you separate an application defect from a test problem, bad data, or a broken environment.
- Regression testing, checking that a change has not broken existing behavior, helps you choose valuable checks for an automated suite.
- Understanding application behavior helps you question requirements, recognize dependencies, and explain the effect of a change on users.
For example, suppose a discount works for a normal order but fails at a minimum-spend boundary. Your QA experience identifies the boundary and reproduces the issue. Automation skills turn those cases into repeatable checks. Development skills let you trace and change the discount calculation, then add tests that protect the fix.
Choose one language and an initial toolset
Review a small set of current vacancies in your target location or your own team’s technology stack. Note the language, framework, API skills, and expected responsibilities. Choose one language and one testing framework for your first project; you do not need to learn every tool below at once.
- JavaScript, followed by TypeScript: consider this route when targeting web applications or roles using Playwright Test. TypeScript adds type checking to JavaScript, helping identify certain coding mistakes before execution. Learn JavaScript fundamentals alongside it.
- Python: consider this route when target teams use Python for test code, services, or utilities. pytest is a Python testing framework; Playwright’s Python documentation recommends its pytest plugin for browser tests.
- Selenium: a browser-automation option worth choosing when it matches the target team’s existing framework. It works with language bindings, including Java, Python, and JavaScript. Pair it with the test runner used by the project.
Playwright supports multiple languages, but their testing integrations differ. Playwright Test is the JavaScript/TypeScript runner; a Python project does not use that same runner. Do not select a language solely because a tutorial says one browser tool requires it.
Official guidance: Playwright supported languages.
Official guidance: TypeScript for the New Programmer.
Official guidance: Selenium overview.
Step 1: learn programming through small QA problems
Start with variables, strings, numbers, conditions, loops, functions, collections, and error handling. Learn how to read a stack trace the sequence of function calls shown when a program fails and use a debugger to inspect values while code runs. Add modules and basic object-oriented concepts as your project needs them.
Practice with familiar tasks: validate a list of test inputs, compare expected and actual results, or summarize failures from a JSON file. JSON is a text format used to exchange structured data. Write the program yourself, run it with different inputs, and explain why it behaves as it does.
For JavaScript or TypeScript, learn asynchronous code and async/await: how to wait for operations such as a network request without treating an unfinished result as complete. This matters when writing browser and API tests.
Milestone: write a small utility that handles valid and invalid inputs, then add tests for it. You should be able to change a requirement and debug a failing case without copying a complete solution.
Step 2: use Git and a test framework
Git is version-control software that records changes to files. A repository holds a project and its history; a commit records a set of changes; a branch lets you work on a change separately. GitHub is one service for hosting Git repositories and collaborating.
Practice creating a branch, making a focused commit, viewing the difference between versions, and opening a pull request—a proposed change for review. Learn to resolve a simple merge conflict, where competing edits need to be reconciled. Use a .gitignore file to exclude appropriate generated files and keep credentials out of the repository.
Official guidance: Pro Git, About Version Control.
Next, use your chosen test framework to organize test cases and assertions. Learn setup and cleanup, parameterized tests that run the same logic with different inputs, and fixtures: reusable arrangements of data or resources needed by tests. Keep setup understandable rather than building a large framework immediately.
Official guidance: pytest documentation.
Milestone: another person can clone your repository, follow its setup instructions, run the tests, and understand a failure. Show an intentional bug being caught, fix it, and preserve the history of both changes.
Step 3: understand and test APIs
An application programming interface (API) lets software communicate with other software. For web APIs, learn HTTP requests and responses, methods such as GET and POST, status codes, headers, authentication, and JSON response bodies. Authentication checks identity; authorization determines which actions that identity may perform.
Use an API tool such as Postman to inspect requests and responses before automating them. Postman supports JavaScript tests in post-response scripts. If your project uses Playwright, its APIRequestContext can send requests directly, test APIs, and prepare data for browser tests. You can continue with one coherent toolset instead of adopting every API tool.
Official guidance: Postman API response tests.
Official guidance: Playwright API testing.
For a local task-management API, check that creating a task returns the expected fields and that the task can be retrieved. Test missing required fields and attempts to access another user’s task. Checking only for a successful status code misses important behavior.
Milestone: write independent API tests with known starting data, meaningful response assertions, and cleanup. Store tokens outside committed code and explain how to configure a test account.
Step 4: build maintainable browser automation
Start with a short, valuable user journey on an application you own or a practice application intended for testing. For example, create an account, add a task, edit it, and confirm the saved result. Also test a meaningful failure case. A browser test should verify an outcome, not merely click through screens.
- Choose stable locators: rules that identify page elements. Prefer accessible roles and labels or agreed test identifiers over brittle selectors tied to layout.
- Give tests independent data and starting states. Avoid a suite where one failed test prevents unrelated tests from running.
- Wait for observable conditions instead of adding arbitrary pauses. Playwright provides automatic waiting for supported actions and retrying assertions; Selenium supports explicit waits for conditions. Learn the behavior of your chosen tool.
- Use small helper functions for repeated actions. Introduce a page object a class or module representing interactions with a page when it makes the code easier to understand and maintain.
- Investigate flaky tests: checks that pass and fail inconsistently without an intended product change. Inspect logs, screenshots, or traces rather than hiding the problem with retries.
Official guidance: Playwright best practices.
Official guidance: Selenium waiting strategies.
Choose automation candidates by risk, repeatability, clarity of expected results, and maintenance cost. A stable check used on every release may be useful; a constantly changing prototype may benefit more from exploration. Cover business rules with unit tests where practical, service behavior with API tests, and a smaller set of critical user journeys with browser tests. A unit test checks a small piece of code in isolation.
Milestone: run the suite repeatedly from a clean starting state, diagnose a deliberately introduced failure, and show how a modest interface change affects your tests. Document the limitations instead of claiming complete coverage.
Step 5: run checks in CI and understand delivery
Continuous integration (CI) runs automated checks when developers share changes. Continuous delivery keeps changes ready for release, while continuous deployment automatically releases changes that pass the required checks. Learn the concepts before trying to build a complex release system.
GitHub Actions is one CI/CD option. A workflow is an automated process stored in a configuration file; a runner is the environment that executes its jobs. Start with a workflow that installs the project and runs tests on a pull request. Save useful test reports and failure evidence.
Official guidance: Understanding GitHub Actions.
When a test passes locally but fails in CI, compare configuration, dependency versions, test data, time zones, and timing. Keep credentials in the platform’s secret-management mechanism. Learn enough to investigate the pipeline; you do not need to automate a production deployment for your first portfolio project.
Milestone: a pull request triggers your checks, a deliberate failure produces a failing job, and you can explain the report and subsequent fix.
Step 6: add feature development if that is your destination
If you want a software development role, add evidence that you can build the behavior being tested. Extend your task application with validation, filtering, or a new API endpoint. Learn database queries with SQL, error handling, application structure, and the basics of the framework used by your target team. For frontend roles, add HTML, CSS, accessibility, and interface state; for backend roles, deepen your work on APIs, data, and permissions.
Practice implementing a requirement, writing appropriate tests, reviewing trade-offs, and explaining how data moves through the application. A large browser test suite alone does not demonstrate the same skills as implementing a product feature.
Milestone: deliver a small feature from requirement to working code, with tests and a reviewable pull request. Describe its limitations and what you would improve before wider use.
Build portfolio projects that make your work easy to assess
One well-explained project is a useful starting point. You can extend it as you learn rather than creating many disconnected tutorial copies.
- Regression suite for a practice shop: automate cart totals, quantity changes, and invalid checkout inputs against a local or permitted test application. Include a risk-based explanation of what remains manual, reusable setup, and a failure report.
- API test project for a task service: test creation, updates, validation, and access permissions. Provide repeatable data setup and a documented defect with reproduction steps, expected behavior, and the test that catches it.
- Feature-and-fix project: build a small issue tracker or extend an open-source practice app. Reproduce a defect, add a failing test, fix the implementation, and show the change in Git history. This provides stronger development evidence than test code alone.
Each repository should include a README explaining purpose, setup, required versions, configuration, how to run tests, and known limitations. Add a concise test strategy, a sample report, and an explanation of one difficult problem you solved. Use synthetic data and keep employer code, credentials, and customer information out of public projects.
Gain experience at work and collaborate with developers
Propose a small automation pilot with your manager or team: one stable, repetitive check with a clear owner and expected benefit. Agree on a test environment, maintenance responsibility, and how results will be reviewed. Avoid quietly introducing an unsupported suite that nobody can maintain.
- Pair with a developer to trace a reported bug from the interface to the relevant code or service.
- Ask for review of one small test or utility change, including naming, assertions, setup, and failure messages.
- Join requirement discussions and suggest acceptance criteria: observable conditions that show a feature meets its intended behavior.
- Keep a record of the checks you built, defects investigated, review feedback applied, and measurable outcomes where you have evidence.
If work does not provide an opportunity, use a personal project or contribute a focused test, documentation fix, or bug reproduction to an open-source project that welcomes contributions. Follow its contribution guidance and start with a manageable issue.
Present your QA experience on your CV and LinkedIn
Retain your actual job titles and distinguish work experience from personal projects. Emphasize the engineering relevance of what you did: investigated failures, designed boundary cases, collaborated on fixes, or maintained repeatable checks. List tools you can explain and use, rather than every tool you have encountered.
Example wording to adapt only if accurate: “Designed regression cases for checkout validation and worked with developers to reproduce boundary-value defects.” For a personal project: “Built a TypeScript and Playwright test suite for a local task app, with isolated test data and CI reports.” Add verified scope or outcomes when available; do not invent percentages or describe tutorial practice as production experience.
Our resume tips for career changers cover more ways to frame a career change.
On LinkedIn, state your current background and target direction clearly, link your strongest relevant project, and explain your contribution. A headline such as “QA Tester | Building TypeScript test automation” can describe your direction without claiming a role you have not held.
Prepare for interviews and avoid common mistakes
For automation roles, practice turning a requirement into tests, writing a small function, making API assertions, selecting locators, and investigating a flaky test. Be ready to explain what you would leave manual and why. For development roles, also practice implementing features, working with collections and basic data structures, debugging application code, and explaining design decisions. Use the job description to set the depth of preparation.
Prepare project stories covering the problem, your investigation, the change, evidence that it worked, and a limitation. Rehearse explaining a failed approach and the feedback you applied. During a practical exercise, clarify requirements, narrate your reasoning, and check edge cases instead of rushing to code.
- Avoid skipping programming fundamentals and relying entirely on recorded or generated scripts.
- Avoid automating every test through the browser or measuring success only by test count.
- Avoid dependent tests, hard-coded credentials, arbitrary waits, and retries that conceal failures.
- Avoid learning several frameworks at once without completing a maintainable project.
- Avoid claiming a transition deadline, guaranteed job outcome, or expertise you cannot demonstrate. Review and understand any AI-generated code before using it.
Frequently Asked Questions
Can a manual tester become an automation engineer?
Yes. Test-case design, edge-case thinking, bug reproduction, and troubleshooting all transfer to automation work. You will need to add programming, Git, a test framework, API testing, maintainable browser automation, and continuous integration, and show each skill through a project you can explain.
Which programming language should I learn for test automation?
Start from current vacancies or your own team’s stack. JavaScript followed by TypeScript suits web applications and teams using Playwright Test. Python suits teams that use it for test code or services, usually with pytest. Selenium is worth choosing when it matches the target team’s existing framework, with bindings for Java, Python, and JavaScript.
Should I learn Playwright or Selenium?
Choose the tool your target teams use. Playwright supports several languages, but its Playwright Test runner is for JavaScript and TypeScript, while Python projects typically use the pytest plugin. Selenium works through language bindings and pairs with the test runner the project already uses. Don’t pick a language only because a tutorial says one browser tool requires it.
Will test automation replace manual testing?
Not entirely. A scripted check answers a defined question, but it does not replace investigating confusing behavior, usability, or unexpected risks. The goal is to combine human judgment with repeatable checks, not to automate every manual activity.
What should a QA automation portfolio include?
One well-explained project is a good start. Examples include a regression suite for a practice shop, an API test project with repeatable data setup, or a feature-and-fix project that shows a failing test, the fix, and the Git history. Each repository should have a README covering purpose, setup, how to run the tests, and known limitations.
Can I move from QA into software development?
Yes, but development interviews usually expect stronger evidence of feature implementation, application design, data handling, and coding fundamentals. Build a small feature from requirement to working code, with tests and a reviewable pull request, to show you can build the behavior you used to test.
Choose your next milestone
Your QA background provides a useful foundation: you understand risks, application behavior, and how failures affect users. Add programming, version control, API testing, maintainable automation, and CI one step at a time. If development is your goal, make feature implementation a deliberate part of the plan.
Start by choosing a target role and one language, then build a small program you can test and explain. Move forward when you can demonstrate each milestone; the time required depends on your starting point, practice opportunities, and target role. For job-search preparation support, review the official Metana JobCamp page to see whether it fits your needs. If feature development is your destination, Metana’s AI Software Engineering Bootcamp covers building, testing and deploying full-stack applications with mentor feedback.
Tool guidance checked against official documentation on 28 October 2026. Follow the documentation for the versions you use; this roadmap does not assume a particular framework is required in every job market.

Written by
Sawiru Wimalatunge
Sawiru Wimalatunge is a Software Engineer and AI Researcher with an interest in artificial intelligence, modern software engineering practices, and emerging technologies. His work focuses on software development, exploring advancements in AI, and investigating how intelligent systems can improve the way software is designed and built. He is also involved in technical career coaching, helping aspiring developers strengthen their technical skills, prepare for job opportunities, and navigate their career paths in the tech industry. He is particularly interested in the evolving relationship between AI and software engineering, with an emphasis on practical applications, innovative development approaches, and making complex technical concepts more accessible.








