How to Foster Collaboration Between QA and Dev Teams

One of the most impactful changes I've seen in quality happens when you implement one specific process: a 30-minute QA-Dev sync meeting for each feature before coding begins to discuss the implementation and testing strategy. When I first bring this up with a client, I get predictable objections: Developers don’t want to "waste" their time. Leadership doesn’t want to "lose" development time. Testing is necessary anyway, so why discuss it? Our QA doesn’t couldn't possibly understand code. The reality is that the impact of effective testing can be remarkably hard for an organization to see. When it goes smoothly, nothing happens — no fires to put out, no production issues. As a result, meetings like this can be difficult for leadership to measure or justify with a clear metric. What confuses me personally is why most engineering leaders say they understand the testing pyramid, yet they often break it in two, essentially creating two separate pyramids. Instead, you should have a collaborative session where QA and Dev discuss the entire testing pyramid — from unit tests to integration and end-to-end tests — to ensure comprehensive and efficient coverage. Talking through what constitutes effective unit and integration tests dramatically affects manual and end-to-end testing. Additionally, I'm continually impressed by how a QA who doesn’t "understand" full-stack development can still call out issues like missing validations, test cases, and edge cases in a method. QA/Devs should also evaluate whether any refactoring is needed, identify potential impacts on existing functionality, and clarify ambiguous requirements early. The outcome is a clear test plan, agreement on automated and manual checks, and a shared understanding that reduces late-stage bugs and improves overall product quality. #quality #testing #software

Assign a test owner before the start of coding. The test owner is responsible for the test strategy and accountable for whatever testing the team does. The test strategy is part of ready to start coding, on par with the development designs. Reviewed test results are part of being done, meaning the team performed whatever testing they intend and have had a chance to make a decision based on what they learned. Anybody can be a test owner, who that is will be determined by the team during the transition from planning to coding. Whether it is a dedicated tester, another developer brought in to help, or the same developer writing the code, the team makes an informed decision based on their understanding of risk and nature of the planned work. The test owner describes the test approach in the test strategy. The team will execute on that approach as agreed by the team. The test owner and developer(s) work together to make sure the development plan and testing plan are optimized and work together as much as possible. Where and how testing happens, during unit tests, in test environments, on specialized equipment, via exploratory end-to-end testing sessions, as part of deployment pipelines, or postproduction is all determined and described in the test strategy. The goal of approach is to establish test accountability as part of the core release plan in a way that affects all the engineering decisions and allows a more flexible approach to testing. Rigid processes such as "hand-off to QA" give way to context-driven decisions based on what is being tested and a team assessment of needs and risk. Dogma driven discussions about "who does testing" are eliminated when the testing problem is broken into parts and pieces and work assigned in a manner that fits the work itself. "Throw it over the wall" vanishes as testing works its way into every stage in the process. The key are the simple points in the cartoon: 1) assign a test owner at the start, 2) deliver a test strategy as part of ready to code, 3) reviewed test results are part of done. These three points form an anchor that establish accountability and a point where feedback on what works and what does not can begin correction. #softwaretesting #softwaredevelopment #shiftleftisdeadlonglifeshiftitalloverthefreakinmap

Ever feel like you're speaking a different language than your colleagues? That's how our QA team felt when I worked at Blizzard. Company policy: Keep QA separate from dev teams. Reality: Constant miscommunication and frustration. Riot saw an opportunity. Why not embed QA directly with developers? → Started small: Invited key QA members to our daily standups → Result: Instant improvement in bug reporting and fixes But it wasn't smooth sailing: → Pushback from management → Developers skeptical of "outsiders" → QA unsure of their new role Persistence paid off. After many months: → Faster bug fixes → Higher quality releases → Happier teams all around This experiment became the foundation for a new company-wide policy. Now, embedded QA is standard practice not just at Riot, but across the industry. Lesson learned: Sometimes the best solutions come from breaking the rules (respectfully). 2 Questions I find useful to ask (regularly): 1) What unspoken policy is holding our team back? 2) How can we bridge gaps between departments? QA are the unsung heroes of game development. P.S. Tell the QA in your life you appreciate them today.

New Game Production Q&A today, here’s a question I didn’t get to answer from the last one. From Julian: “What strategies have you found for bringing QA into the active development cycle, when it's traditionally been decoupled and viewed as an "end of development" function?” You know, the biggest thing I see keeping QA as the ‘last in the pipeline’ discipline is that we often silo them away and treat them as if that ‘end of development’ function is all they can do. It’s a low-efficacy view of QA, plus a studio design that even in the org chart has them apart from everyone else. The first thing I’d want to do is start breaking QA analysts out of their silo and embedding them on teams. I’m not kidding, even if you just do that, if you’ve hired QA that can take initiative and care about the quality of the player experience, they will go into teams and meetings and find ways to add value. Next, you want to rethink the nature of QA. If you view them as ‘people that find and report bugs’, the view that their role is all bunched up at the end when the game is ‘done’ can almost sort’ve be badly rationalized. But if you view them as individuals on teams who are responsible for making sure low quality experiences - and I mean the engaged experience of the player, not graphical fidelity or refined UI! - don’t get to players, and as people who are to maintain a deep connection to the quality of the products they are helping deliver, you can start understanding just how valuable the QA function can be. Even at a ‘dealing with bugs’ level, a truth discovered in engineering (and is also true in game dev) is that your time to resolve a bug is directly related to the effort required to solve it. If a QA analyst on a team finds a bug in 6 hours working alongside a designer and engineer on a new bit of gameplay or a feature, odds are that bug will be resolved in a fraction of the time it would have taken someone to puzzle their way through the code and lua 6 months from now while we’re all in a panic trying to ship. Having QA embedded on teams, creating test plans, working to make sure everyone is following your definition of done, advocating for stable builds and regular playtests, and ultimately pushing for whatever is produced to actually land with your audience is an end to end function. It’s ok to put a lot of responsibility on your QA. They’ve worked in a world where all they do is submit reports. They want to be involved. Seriously, in my years of game dev I’ve rarely seen a discipline rise to the challenges put before them more than QA. Massive respect. They can be a much bigger asset to studios than they typically are. Stop wasting the energy and awareness they bring! #gameproduction #gamedevelopment #gameindustry #qaanalyst

What do testers do when development is not complete? While you _could_ spend a bunch of time writing "test cases" and a "test plan", I think that's often a wasteful use of time. Instead: * You could participate in requirement and design discussions and reviews. * You could do some lightweight test design, using tools like mind maps, test charters, etc. (jotting down high-level test ideas that will help guide the actual testing without getting too prescriptive and time-consuming like highly scripted "test cases") * You could even start testing by working with the developer to get access to the partial implementation, keeping in mind that some things may not be "done" and delivering feedback more informally than you might for a bug in finished code. Depending on how the team works this could be the code on a developer's personal branch, or turning on a particular "feature flag", etc. * You might continue doing some deeper testing on other recently implemented work, or adjacent areas. Testing doesn't have to happen only "at the end" of a user story, feature, release, or project. I prefer moving away from viewing the process as "development implements a thing, and then hands it off to a 'QA' team when they're done" and instead embedding testers and developers in the same team where they're constantly interacting and collaborating. There are still "handoffs", but they're within the same team (hint, they also happen even if you have a team of just developers), and they're smaller and more frequent so everyone tends to retain more context, in addition to not having people waiting around to have a "finished" thing handed to them after days or weeks of effort without being able to get eyes on it or provide feedback in the interim. #softwaretesting #criticalthinking #agiletesting