- QA is always the first thing companies outsource, with predictable results

- Companies either go the route or “separate QA org with separate management chain” or “have QA engineers report to dev managers”. I’ve seen serious misaligned incentives and toxic outcomes with both

- Frequent Slack messages at 4:15 PM on Friday - “hey they just merged the PR, we really need it tested before Monday stand up”

- QA becomes a de facto dumping ground for glue work that other teams don’t want to do. Senior QA ends up morphing into a de facto “responsibility without authority” project manager role

- There is zero internet “community” around QA the way there is for developers or designers. There is no Slashdot or Hacker News for QA and there never will be. Just a bazaar of book authors and consultants promoting themselves on LinkedIn

IMO the only thing that makes sense anymore is having good SDETs embedded in engineering teams.

This rings so many bells that it feels like some Buddhist festival. Apply the same approach to QA, Operations, and anything outside the actual product development: when this arrogance was shared between bosses and developers, all good on their side. Now with the AI, the arrogance is staying only on the bosses' side, and we have developers freaking out.

1. Quality management is a continuous process that starts with product discovery and business requirements. Developers often assume that requirements are clear and move on to building the happy path. QA often explore requirements in depth and ask a lot of good questions.

2. QA usually have the best knowledge of the product and help product managers to understand its current behavior, when new requirements suggest to change it.

3. The same applies to product design. Good designer never leaves the team with a few annotated screens, supporting developers until the product is shipped. Design QA - the verification of conformance of implementation to design specs - can be done with QA team, which can assist with automation of design-specific tests.

4. Customer support - QA people are natural partners of customer support organization, with their knowledge of the product, existing bugs and workarounds.

And just a story: on one of my previous jobs recently hired QA engineer spotted number error in an All Hands presentation. That was an immediate buy-in from founders. :)

1. If you don't have Quality Assurance, then you have Quality Uncertainty.

2. QA is a full time job. If you offload the responsibility of QA to the engineers, then you're giving them 2 full time jobs. So unless they're working 16 hours days (even if they are tbh), you aren't assuring quality, you're compromising it.

Any process in an organization of size will have indicators that measure output. Those indicators should typically be paired with indicators that measure the quality of the output, to ensure product or service levels. That's the theory, and the genesis of 'quality management': whether you're measuring output code or breakfasts [1] or chemicals or widgets or medicine, you need to measure the quality of the output if there are any client specifications or expectations around the output. And there are very few cases where your customers will not have any specs or expectations around your product or service.

How you manage quality follows from those basics; it matters where you measure quality but it is so process dependent - earlier in the process lowers costs, but may not suffice to guarantee final quality - that quality management has to be designed around the specific process; balancing cost with benefit and requirements. How deep or specialized quality management becomes depends on the needs of the org, the size of the org, and the needs of the particular process.

This is why I'm skeptical about whether broad articles like this are beneficial overall. Why and how matter, and where's the foundational discussion behind why and how? Do folks not think at the organizational/business level? Maybe not everyone is a Sheryl Sandberg :-)

[1] https://en.wikipedia.org/wiki/High_Output_Management

Except I worked at a company with a QA department made up of entirely "Automated Verification Engineers" ... over a decade ago. And the head of the department had taught at a local QA school (so presumably other QA engineers learned that style of work from her also).

Good QA departments switched to this mode long before AI was even a thing! Maybe 90+% of QA departments didn't work that way pre-AI, but there certainly were ones that did!

A great QA can understand the features of a product quickly, turn those concepts into some sort of grid or matrix in their mind, then pull a bunch of paths and scenarios with estimated priorities and probabilities at a fast and efficient pace, all with great coverage. They can also identify features contradicting each other more quickly than product people.

I think a good QA is capable of being a great vibe coder nowadays, too. If you can write great test suites (write names only), agents nowadays are able to turn those specs into decent codebases. Comparatively, I know a lot of decent dev having not very good taste in testing, who often write overlapping tests or missing important paths.

If engineering owns quality, then engineering own all, up the chain. No need for anything and anybody.

Which is the AI pipe dream, really.

You are, in fact, with using AI, QA or coding or otherwise, externalizing services in hope the services will improve and costs will drop.

Let me know how that goes without HITLs.

It's terrifying without that support. The beancounter level mgt does not Get It that it's cheaper to have this kind of support now than much later in the product cycle.

I've been places where devs have no idea what the product-as a whole-does. They just work on the feature of the sprint and throw the code over the wall. Their testing consists of if: it compiled==it passed. They have no idea how to even start actually testing if it's not on the happy path.

I been in places where the code accomplished the spec, but in the most lazy way possible so it appeared to work but was useless outside of what the tests looked for.

I knew one QA guy that was amazing but was so overloaded because management kept hiring "cheap" QA that were actively making his life worse.

I'm a tech writer right now at a tech company and a dev just sent over an LLM generated "doc" that's referring to things that don't exist.

Neither management nor dev has learned anything from Therac-25. QA is hard.

What I find works best is when the Product Manager, Developer Lead, and QA Lead collaborate on requirements. The Product Manager designs the feature, the Developer focuses on technical design and architecture, and the QA Lead maps out user scenarios, integration points, and edge cases. Together, they define the requirements that constitute a successful feature.

When QA is involved early in the process, they understand and drive exactly how the feature should behave. This ensures that critical cases are considered and potential risks are handled before a single line of code is written.

If code generation becomes cheap, then verification becomes the bottleneck.

In that world, QA isn’t going away — it becomes the core engineering function.

Test automation is not same coding that developers do. I don’t mean from quality point but they have completely different set of things that matter. Unlike writer here may think while it is important to have tests that pass or fail fast the performance is not one of the most important characteristics. You see tests are run less often than the code and not all tests need to run every time or even every day. One of the most important characteristics of a good test is something developers easily overlook. It is maintainability. When code is written then it’s tested and then it sits in codebase until refactored. Tests don’t get this. Tests work on environment that is under constant change (especially in shift left) that makes maintainability and abstraction layers much more important with test automation code than with developing a feature.

Something to note that some developers do not understand testing at all. They may think it’s all about getting tests passed or getting software broken. It’s not either of those. It’s just checking that software works like expected in different scenarios.

Because of those two things: code maintainability and (mis)understanding testing in deeper level, some developers do great tests and enjoy good qa as resulting product gets better. And then there are developers that struggle with all of that and usually with their developing as well.

It's easy for developers to own 50 E2E tests. But from what we see with our users, it's a nightmare when they scale to thousands of tests, and between releases, 10 features might have changed, suddenly causing 300+ tests to fail simultaneously in CI. No developer wants to spend three days debugging and updating the tests, so the test suite rots.

The bottleneck for large-scale E2E testing isn't creation, it's maintenance. We built Stably (https://stably.ai) specifically for this—we have a scalable cloud infrastructure that can process hundreds of concurrent Playwright test failures, understand them by stepping through the failure traces to debug the UI drift, and auto-fix the test scripts in minutes. Developer-led QA only works if you completely remove that massive maintenance tax.

Most importantly, they have the diligence and patience to methodically test subtly different cases, which I frankly don't have.

On the question of whether QA slows things down, I have to ask: slows down what? Slows down releasing something broken? Why is that something to optimize for? We should always be asking how long it takes to release the right thing (indeed I'm most productive when I can close a ticket after concluding nothing is needed).

I often find that devs who think otherwise have never had to ship anything against a drop dead date, or definitively prove that a supplier has not met a contractual obligation (after the normal engineers have found it to be their problem in the first place).

This was painful at first but I do think it's the way to go. We found that too much manual QA incentivizes devs writing features to throw it over the fence - why should they test more if someone else is paid to do it? Devs need to feel the pain of writing tests if their code is hard to test, and they need to be held accountable when their code blows up in production. This feedback loop is valuable in the long run.

Same thing for test automation. Previously we shipped this over to our in-team DevOps people and they built complicated CI/CD setups. Losing them meant we needed to simplify our stack. Took a while and it slowed down feature development, but it was worth it. Of course you need leadership who understands this and dedicates time to building this out.

In defense of DevOps, I think the landscape for automation was poor a few years back. Jenkins and Teamcity are way too complex. Github Actions (for all its warts, and there are many) is much simpler. Our pipelines are also in their own CI/CD (CDK, CodeBuild) - infrastructure as code is the key to scaling.

We still have manual QA people to test things we can't automate. Usually this is for weird surfaces such as smart TVs, or for perceptual tests. I don't see this going away any time soon, but high levels of automation elsewhere drive down the need for "catch-all" manual testing.

But it isn't? Finding and fixing are the major time sinks?

> You’re creating bad behavior for your engineers by not having them responsible for their quality.

What prevents you from maintaining responsibility if QA finds the bug? The thing you're throwing over is the investigation/finding, it doesn't follow that you should absolve the throwers

That being said, QA is definitely an important aspect of software development - regardless of who owns this work. Imo, instead of having a QA engineer per team or a few teams, you should have a QA shape role (similar to AVE you mentioned) that oversees a large area like an Org and pushes hard to make sure quality standards are held high across teams.

It's also trivial for engineers these days to have great e2e automated test coverage with AI. We're actually building getlark.ai that helps engineers with this.

I worked with a QA team for the last fifteen years until last year when they laid them all off.

QA is a discrete skill in and of itself. I have never met a dev truly qualified to do QA. If you don't think this you have never worked with a good QA person. A good QA persons super power is finding weird broken interactions between features and layers where they meet. Things you would never think of in a million years. Any dingbat can test input validation, but it takes a truly talented person to ask "what if I did X in one tab, Y in another, and then Z, all with this exact timing so events overlap". I have been truly stunned at some of the issues QA has found in the past.

As for time, they saved us so much time! Unless your goal is to not test at all and push slop, they are taking so much work off your plate!

Beyond feature testing, when a customer defect would come in they would use their expertise to validate it, reproduce it, document the parameters and boundaries of the issue before it ever got passed on to dev. Now all that work is on us.

Anything that involves gating bits of code, basically, and deciding whether to gate bits of code or not.

QA should not be forced into an engineering or automation track because the incentives are wrong. You end up with test code becoming the goal and then it usually rots due to most QA not having the experience to create a codebase that scales.

I don't think the industry today understands how to treat QA and I think that leads to a lot of assumptions that it's not useful.

That sure is a sequence of words.

It comes across to me like the emphasized part is arguing against what it's supposed to be arguing for.

Or is the premise that the developers somehow can't run the AI verifier?

We then got bought out and new management put in. They siloed QA and made it impossible for us to even talk to them about what we were doing. Within a year, we had one deployment fail four times in a row and went from favorite vendor to "utter trash vendor we can't get rid of." Our QA engineer quit, as well as the rest of the team (I was the last to leave). I'm still surprised they still have that customer.

[1] We were the only team having to deal with SS7. It wasn't easy hiring programmers for it, and I think at the highest head count, we had like five members (including the manager when we had one [2], but not including QA, which was "officially" never a part of our team).

[2] If it was tough hiring programmers to deal with SS7, it was even harder to hire managers to deal with programmers dealing with SS7. I think for half the time I was there (over 10 years) I had no official manager and reported to a director or higher in the company.

I’d like them to record their steps in details in videos and have AI dissected the steps into text descriptor that’s relevant to the code.

Also, I worked tech support for a number of years and I've watched all kinds of unexpected ways that people would interact with their devices. I always did all the weird stuff that most of us wouldn't consider when operating software:

"Why would someone drag every file to the desktop before they opened them?"

"I don't know, but I saw someone who always did that so I tried it."

Should Legal exist?

Should Facilities exist?

Surely your average employee could own each of these functions.

The moment that happens it will either be re-outsourced to QA anyways or quality will become a question of licensing and bonding of professional engineers

Enterprise software companies selling definitely need it. Customers ask was this tested? where is the test report?

What could possibly go wrong?

Quality is something that takes dedicated focus and lots of work. Therefore it’s a job, not an afterthought or latest priority for someone whose primary focus is not quality.

"QA" should exist regardless of whether you think dedicated software testing staff fit into your org. The whole team is responsible for assuring quality.

Dedicated software testers verify that the solution actually does what it's meant to do, and good software testers become deeply knowledgeable about the product and how features interact. They are ultimately a second pair of eyes, and should have a direct line to product owners or customers.

This can't be automated. The ongoing tests for verifying existing features continue to work without regression can and should be automated (throughout the dev process), adding generative AI to the human verification step is a recipe for disaster.

The testing pyramid is a par excellance SWE kool-aid. Someone wrote a logically-sounding blogpost about it many years ago and then people started regurgitating it without any empirical evidence behind it.

Many of us have realised that you need a "testing hourglass", not a "testing pyramid". Unit tests are universally considered useful, there's not much debate about it (also they're cheap). Integration tests are expensive and, in most cases, have very limited use. UI and API tests are extremely useful because they are testing whether the system behaves as we expect it to behave.

E.g. for a specific system of ours we have ~30k unit tests and ~10k UI/API tests. UI and API tests are effectively the living, valid documentation of how the system behaves. Those tests are what prevent the system becoming 'legacy'. UI and API tests are what enable large-scale refactors without breaking stuff.

Isolated QA should not exist because anything a QA engineer can do manually can be automated.

Of course, none of this is true in the real world.

For example, just last week we had a QA essentially bring down our web application on staging environment always reproducible with a sequence of four clicks. Follow the sequence with about the proper timing and boom, exception.

Should this have been caught before a single line of code was written? Yes, it should have been caught before any code was written. However, the reality is that it did not. Should this have been caught by some unit test? Integration test? End to end test? Code review? I'd argue as we barrel down a world of AI slop, we need to slow down more. We need QA more than ever.

The real reason many software orgs nowadays don't have QA is for the simple reason that it's slow. Everything in the consumer tech space is about rapid growth, and moving as fast as possible. Nobody cares very much that the software has bugs, what matters is whether it has users.

But outside of consumer tech, QA is a lot more common, since it matters a lot more that the software's logic is correct. (Speaking personally - I used to work for a genetics lab, and we had QA.) There are just different economic incentives involved.

Sorry. No 'blue screens' or stack traces in my pacemaker or insulin pump, please.

I would ask anyone that thinks QA is unnecessary to spend a few days on an actual aerospace production line. Software and hardware get EXCESSIVE QA. For good reason.

1. define a requirement 2. implement the requirement 3. verify that the requirement was implemented

TDD was built around the idea that 1 and 3 could be unified in automated testing, and that's certainly true for a large part of it. But QA as a discrete role needs to exist because, beyond verifying that 2 was done correctly, they expose higher level bugs in 1, the requirements themselves.

It's virtually impossible to define requirements completely and without second order interactions that cause problems. QA is as effective at exposing assumptions and handwaving by the people who created the wireframes or the visual design as by the developers failing to test their own work.

And ideally, this leads to the cycle being virtuous: higher quality starts at the requirements phase, not the implentation phase. It's not just that QA should work closely with the engineers--the engineers need to work closely with UX and VD to ensure they fully understand the requirements. The incentives are aligned among all parties.

Not even mentioning the potential regulatory/market and legal consequences if you don't.

Unit tests are very expensive and return little value. Conversely, a (manual?) 'smoke test' is very cheap and returns great value - the first thing you do when updating a server for example is to check it still responds (and nothing has gone wrong in the deployment process), takes 2 seconds to do, prevents highly embarrassing downtime due to a misconfigured docker pull or whatever.