QA engineering is the work of helping software behave as people expect, by finding defects and building the tests and habits that prevent them. The role has...
Is the QA Engineer Role Dead? What Software Testing Looks Like Now
QA engineering is the work of helping software behave as people expect, by finding defects and building the tests and habits that prevent them. The role has changed: developers own more tests, while QA specialists increasingly build automation, assess risk, and probe what machines miss.
Key Takeaways- Quality assurance is broader than running test cases; it includes the practices that prevent defects.
- Developers commonly own unit and integration tests, while QA engineers focus on test systems, end-to-end coverage, and exploratory work.
- AI can draft tests and sort failures, but human review is still needed to judge whether a test checks the right thing.
- Useful quality measures include defect escape rate, meaningful coverage, detection and repair time, and flaky-test rate.
I’m Ermenildo V Castro, and I’ve seen the QA debate swing between two loud claims: the role is finished, or it has never mattered more. Neither claim helps a team decide who tests a risky payment change on Tuesday morning. The better question is how a team shares responsibility for quality, and which work still needs a specialist.
Across software teams at large technology companies, I’ve watched testing move closer to the people writing the code. That can reduce slow handoffs, but it can also leave gaps if everyone assumes someone else has checked the user’s full workflow. AI coding tools add another wrinkle: they can create code and test drafts quickly, yet speed does not tell us whether the tests reflect a real user need. Quality is a practical responsibility, not a job title alone. The goal is dependable software and work that respects the people who rely on it.
What Is QA Engineering Today?
Software testing checks whether a product behaves as expected. Quality assurance, or QA, is broader: it includes the design choices, tools, review habits, and team processes that help prevent defects in the first place. The terms often overlap in job listings, so the job title alone tells you little. One QA engineer may spend most of the day running manual checks; another may build an automation platform used by hundreds of developers.
Testing is not one activity. A healthy test approach uses several kinds of checks, each aimed at a different risk:
- Unit tests check a small function or component in isolation. The developer who changes the code is usually best placed to add these.
- Integration tests check whether connected parts work together, such as an application and its database or a service and an API.
- End-to-end (E2E) tests check a full user path through the real application, from sign-in to completing a purchase, for example.
- Regression tests rerun checks after changes to catch problems that were not part of the new feature.
- Performance and load tests examine response time and reliability under normal or heavy traffic.
- Exploratory testing uses a person’s judgment to investigate unclear behavior, usability, and surprising edge cases that a scripted test may miss.
A QA engineer’s job is often to help choose the right mix. More E2E tests do not automatically mean better coverage; these tests can be slow and fragile if they try to check every small rule through a browser. Martin Fowler’s practical test pyramid explains why teams often benefit from many fast, focused checks and fewer broad, slower ones. Google’s discussion of test sizes offers another useful way to think about scope and speed.
Here’s the distinction I use: testing asks, “Does this behavior work?” QA also asks, “What would make this behavior fail, how will we notice, and who will fix it?” That second set of questions can shape code reviews, release plans, monitoring, and how a team learns from production defects. QA is not merely a gate at the end of development. Done well, it is part of how the team builds.
Why QA Still Matters
Software can pass a pile of tests and still frustrate users. A test may check that a button works but miss that the button is impossible to find, or that a feature behaves poorly with a slow connection. QA matters because it brings attention to risks that are easy to miss when a team focuses only on whether code compiles.
The shift-left approach moves testing earlier in development. Developers write unit and integration tests as they build; automated checks run in continuous integration (CI) when code changes; and QA specialists help design the systems and broader checks. The point is not to make every developer a full-time tester. It is to find issues while the code and its author are still close at hand.
The work has several concrete benefits:
- Fewer defects reach users. A clear acceptance check or focused automated test can catch a mistake before release. I’ve seen a tiny test around an empty input prevent a far larger customer-support problem later.
- Safer changes to old code. Regression tests give teams evidence that a new feature has not broken a familiar workflow. Without them, developers can hesitate to improve code that nobody fully understands.
- Faster feedback. A CI check that finishes in minutes can point to a faulty change while the developer still remembers what they changed. A late discovery days before launch is more expensive and stressful.
- Better attention to human needs. Exploratory testing can reveal confusing labels, awkward screen-reader behavior, or error messages that blame the user. Quality includes the dignity and needs of the person using the product, not just a green build.
- More informed release decisions. Teams can assess what is known, what remains risky, and what should be monitored after launch instead of treating a test pass as a promise of perfection.
Frankly, a green CI badge is not proof that a product is good. It means a defined set of checks passed under particular conditions. At one large engineering organization, I saw a test suite report success while a common workflow failed when a user’s session expired. The test had modeled the happy path, not a realistic day. A tester who asked, “What happens when this takes too long?” found the missing behavior.
That is why dedicated QA roles still make sense, especially in products with complex rules, high costs of failure, many supported devices, or sensitive user data. The specialist’s contribution is not to take responsibility away from developers. It is to make risks visible, build better feedback, and help the whole team act on what it learns. Good stewardship means using people’s time and computing resources carefully; it does not mean skipping checks that protect users.
Step-by-Step Guide to Building a Modern QA Practice
A workable QA practice starts with risk, not a hunt for a magic tool. I’ve seen teams buy a browser automation package before agreeing on which customer problems matter most. They gained a new bill and a brittle test suite. Start with the behavior you need to protect.
- Describe the user’s important tasks. List the actions people must complete: creating an account, changing a password, placing an order, or exporting a report. Include the failure cases that could cause harm, lost money, or avoidable support calls. Keep the list short enough to use.
- Set clear expectations for each change. Write down what should happen, what must not happen, and how the team will tell the difference. A feature request such as “make checkout better” is too vague to test. An expectation such as “an expired card shows a clear error without charging the customer” gives developers and testers something concrete to check.
- Put fast checks near the code. Developers should usually write unit tests for the rules they change and integration tests for important connections. In a team I worked with, a developer caught a rounding error with a small unit test before the change reached a shared test environment. That quick feedback beat a long browser test by hours.
- Choose E2E tests with care. Use browser or device tests for a small set of critical user paths, not every detail. E2E checks can prove that the pieces work together, but they often take longer and may fail when an interface changes. Keep their purpose clear, and avoid repeating every unit-level rule in the browser.
- Run checks automatically in CI. A useful pipeline runs relevant tests on code changes and reports failures in a form people can understand. Make slow suites visible, set a clear owner for failures, and avoid making developers wait on a test that is known to fail at random. Fowler’s test-pyramid guidance is one starting point; the right mix depends on the product.
- Add human exploration where scripts fall short. Ask a tester to try unusual inputs, awkward timing, assistive technology, and confusing paths. Give that person a specific mission, such as “try to submit an order twice,” rather than the vague instruction to “click around.” Record what happened and whether it can be reproduced.
- Review AI-generated tests instead of trusting their volume. AI tools can draft unit tests or E2E scripts from code. Check that each test reflects intended behavior, fails when the behavior is wrong, and does not merely repeat the implementation. For software that uses generative AI, expected outputs may vary; a useful evaluation should judge quality against clear criteria rather than demand identical wording every time. OpenAI’s evaluation guide describes ways to assess model outputs. Human review still decides what “good” means for the product.
- Track the signals that lead to action. Look at defects that escape to production, time to detect and resolve issues, the rate of flaky tests, and whether important behavior has meaningful coverage. DORA’s delivery metrics guide can help teams assess software delivery, but delivery speed alone is not a quality score. Use measures to find problems, not to rank people.
The sequence matters. First agree on risk, then choose tests and tools. A process that produces lots of tests but no shared understanding of what they protect is busywork with a dashboard.
Comparison: QA Engineering vs. Developer-Owned Testing
The closest alternative to a dedicated QA function is a model where developers own nearly all testing. These are not enemies; many strong teams use both. The useful comparison is about ownership and focus, not which group cares more about quality.
| Area | Dedicated QA engineering | Developer-owned testing |
|---|
| Main focus | Test strategy, automation systems, E2E coverage, exploratory testing, and risk review | Unit and integration checks for code changes, plus fixing failures in the feature code |
| Best fit | Complex products, high-impact workflows, many devices, or rules that need broad testing experience | Small teams, clear code boundaries, fast-moving features, and well-supported test tools |
| Main strength | Offers a wider view of user behavior and test gaps across teams | Gives quick feedback close to the code and reduces handoffs |
| Common risk | QA becomes a final checkpoint that receives work too late | Gaps appear when everyone assumes someone else will test the full workflow |
| Useful measures | Escaped defects, test reliability, detection time, and coverage of key workflows | Fast feedback, meaningful unit and integration checks, and resolved CI failures |
In practice, the strongest setup is usually shared ownership with clear responsibilities. Developers can own tests for their changes; QA engineers can improve the test framework, investigate hard-to-script risks, and help teams decide where human judgment is needed. The details depend on the product. A service that handles a simple internal task may not need the same E2E coverage as a banking workflow.
AI increases the value of this division of work. If coding assistants lead to more changes per week, teams may face more test results, more CI load, and more opportunities for shallow generated tests. QA engineers can help check whether the system still gives useful feedback at that pace. Self-healing automation may repair selectors when a page changes, but it cannot decide whether the changed page still makes sense to a user.
That last point is easy to miss. A tool can reduce the cost of maintaining a test, but it cannot take responsibility for the product’s purpose. Use automation to remove repetitive effort, not to outsource judgment. NIST’s Secure Software Development Framework is a useful reminder that quality and security practices belong throughout development, rather than being bolted on at release time.
Common Mistakes to Avoid
Most advice about testing sounds reasonable until it turns into a rule used without context. “Automate everything” is a good example. It ignores the cost of maintaining tests and the value of a person looking at a product with fresh eyes.
- Treating code coverage as proof of quality. Coverage tells a team which code ran during tests, not whether the tests checked meaningful outcomes. A test can execute a line and still miss a broken result. I use coverage to find untested areas, then ask what user need the test protects.
- Making QA responsible for all quality. When developers throw work over a wall, QA receives it late and becomes a bottleneck. Quality belongs to the people who shape, write, review, test, and operate the software. A QA specialist can coordinate and improve the system without carrying every defect alone.
- Writing too many fragile E2E tests. Browser tests that depend on timing, unstable data, or brittle page details can fail for reasons unrelated to defects. Teams then rerun them until they pass, teaching everyone to ignore the warning. Keep the most valuable workflows and repair flaky tests promptly.
- Trusting AI-generated tests because they look polished. A generated test may mirror the code’s current behavior, including a bug, instead of checking the intended behavior. Review its claim, inputs, and failure condition. More lines of test code do not necessarily mean more protection.
- Using one quality number to judge people. Defect counts, coverage, and test volume can be gamed when tied to individual performance. Metrics should help a team spot a weakness and choose a response. DORA delivery measures can add context, but no single number says whether users are receiving dependable software.
Here’s the kicker: test failure is information, not an insult. A team that hides failures to keep a release moving may ship a problem it could have fixed. A team that studies a failure, repairs the cause, and improves its checks builds a more honest process. NIST’s secure-development guidance similarly treats security work as an ongoing practice, not a final inspection. Keep the review calm and specific: what failed, what risk does it pose, and what change will prevent a repeat?
Frequently Asked Questions
Is the QA engineer role going away?
No, but the work is changing. Developers increasingly write tests alongside code, so a QA engineer may spend less time executing a fixed checklist and more time improving automation, test strategy, and exploratory coverage. Some organizations still hire roles focused on manual testing, while others expect quality engineers to build tools and advise multiple teams. Read the job description carefully; titles are not consistent.
Who should write unit tests: developers or QA engineers?
Usually, the developer changing a small function or component should write its unit tests because that person knows the code and can get quick feedback. QA engineers can help set patterns, spot weak coverage, and test behavior across components. There is no rule that prevents collaboration. The important part is clear ownership: a test should not be left unwritten because two roles assumed the other one would do it.
Can AI replace software testers?
AI can help draft tests, group similar bug reports, and reduce repetitive work. It does not know by itself which user risks matter most, whether a confusing interface is acceptable, or whether a generated test checks the intended requirement. AI output also needs review for correctness and useful coverage. Treat it as an assistant, not the final authority on whether a product is safe or ready.
What quality metrics should a team track?
Start with measures that prompt a useful action: defect escape rate, how long issues take to detect and resolve, flaky-test rate, and meaningful coverage of important behavior. Code coverage can show where tests run, but it cannot prove those tests are strong. Pair numbers with examples and discussion. If a metric encourages people to hide defects or inflate test counts, change the metric or stop using it.
A QA career can include testing code, building automation, reviewing risk, improving CI, or helping teams understand what users experience. The common thread is careful attention to whether the product does what people need. That work changes with tools, but the need for sound judgment does not.
I’m Ermenildo V Castro, and I still trust a small, clear test more than a hundred checks nobody understands. Teams should share the work, use AI where it earns its place, and leave room for people to notice what a script cannot. That is how QA stays useful: not as a gatekeeper, but as a steady practice of making software more dependable for the people who use it.