Author’s Note
Part 1 of this blog was written in November 2023- back when I had time, opinions, and the illusion I’d actually hit publish. Then it got shelved, buried under shifting priorities and the usual chaos. But recently I stumbled across it, reread it, and thought: “Hmm, some of this actually held up.” So here we are.
This little resurrection was cathartic. I got to do what I love most: complain and bring awareness about broken systems I care deeply for. If you’re here for that energy, welcome.
Fair warning: This is a long read. If terms like “QA,” “DevOps,” “CI/CD,” or “test automation” mean nothing to you, feel free to back out gracefully--or stick around and learn something. I’m not your manager.
*Short on time? Skip to Part 2 *
PART 1 - 2023
QA Isn’t a Final Step -- Why DevOps Needs Quality from Day One
QA Is Not a Department You Call When You’re Done
The way we build games is changing-finally. The days of developers sprinting to the finish line and tossing a build over the wall to QA are over. Or at least, they should be.
If you’re still running your game studio like it’s 2010
Developers building in isolation, QA coming in at the end to mop up...
You’re wasting time, burning money, and shipping bugs. Full stop.
What’s replacing that model?
A development culture where QA is embedded from day one.
Where testing and building happen side by side, not in sequence. And where the line between “dev” and “QA” is blurred on purpose.
This isn’t about chasing trends. It’s about doing what actually works--and what lets you ship better games faster without breaking your team in the process.
Sea of Thieves team get it^^^
Let’s break down how we got here, why the siloed approach broke down, and what it looks like when QA becomes a fully integrated part of DevOps.
The Siloed Mess: Why the Old QA Model Doesn’t Work Anymore
Here’s the old setup: Developers build the game, QA tests it after the fact.
Two teams, two goals, and one predictable result:
Bugs slipping through, last-minute crunch, and everyone pointing fingers when something breaks.
This “waterfall-lite” model might have worked when games were smaller, expectations were lower, and patches came on physical discs. But today? It’s a liability.
QA chasing bugs at the end of the process is like inspecting a house after it's been built, furnished, and moved into.
Sure, you’ll find the wiring issue, but fixing it means ripping open the walls.
That kind of rework is expensive, time-consuming, and demoralizing.
And let’s not pretend this is just about process-it’s about power dynamics.
In too many studios, QA is treated like a secondary function, not a strategic partner. Devs move on to the next feature while testers are stuck validating builds, already at least one step behind. There’s a delay, a disconnect, and little to no context for what’s changed-just pressure to find the problems without the tools or position to do anything about them.
The result? Delays, expensive rework, and “Meh, we’ll patch it later” energy.
But here’s the kicker: it’s not that this model failed because QA wasn’t doing their job. It failed because QA was kept out of the job until it was too late to make a real difference.
If you’re serious about shipping quality, QA can’t be a phase. It has to be a mindset. And that mindset starts with integration-not handoffs.
DevOps Isn’t a Buzzword | It’s the Fix
Let’s clear something up: DevOps isn’t just some trendy acronym studios toss around to sound modern.
It’s not a tool.
It’s not a department.
It’s a shift in how teams work.
Built on the idea that development and operations (yes, QA is part of that) should happen together, not in sequence.
In game development, DevOps means your QA isn’t waiting on the sidelines--they’re in the room and have a seat at the table from day one.
It’s about Continuous Integration:
Developers commit code often, and it’s tested immediately through Unit Testing and Regression Testing.
It’s about Continuous Delivery:
Those builds are ready to go live | hourly, daily, whatever your cadence is |
without needing a weeklong QA scramble to make them shippable.
And it’s about Automation doing the heavy lifting so your team isn’t stuck running manual tests for the hundredth time.
Automated test suites (like the ones powered by GameDriver) catch regressions the second they show up. Dashboards keep everyone aligned. Devs and QA aren’t working in silos--they’re shoulder to shoulder, solving problems before they spiral.
And the payoff?
Tighter feedback loops. Fewer bugs. Faster iterations. Happier players. No PR disaster because a launch build melted someone’s GPU…(Unrelated, but something something power cables melting)
DevOps isn’t just faster. It’s smarter. But only if QA is treated as a core part of the pipeline--not as the cleanup crew.
What Embedded QA Actually Looks Like
Let’s kill the fantasy right now: QA isn’t a final boss you fight after the game is “done.” If that’s still your workflow, you’re building problems into your process...and then acting surprised when they blow up in your face.
Integrated QA flips that script.
Instead of waiting for a feature to be “ready,” QA is already there-reviewing it in the engine, in the tools, in the design docs. They’re asking the hard questions before anyone commits a line of code. They’re spotting logic gaps in system design and testing content in the same damn tools the designers use.
This isn’t hypothetical. Studios are already doing it. Their QA team doesn’t just file bugs--they help prevent them by working side-by-side with designers and devs in real-time. And guess what? Their games ship smoother because of it.
Here’s what this looks like in practice:
- QA is part of daily standups. Not observers--participants.
- Shared dashboards track test results, code changes, and open bugs for everyone to see. No mystery. No surprises.
- Developers write unit tests and assist with automation. QA gives feedback on design flow and gameplay feel.
- If something breaks, it gets fixed that day, not three sprints later.
It’s collaborative. It’s transparent. It works.
The real shift here isn’t technical-it’s cultural. It’s moving from “quality assurance” to quality ownership. QA isn’t the fallback plan. They’re co-creators. And when everyone on the team treats quality like part of their job, better games happen faster, and with way less stress.
How to Actually Build This Into Your Pipeline
Let’s stop pretending this is hard. Integrating QA into DevOps isn’t some moonshot-it’s a mindset shift backed by tools you probably already have.
Here’s how teams are making it real:
1. Get Everyone in the Same Room (Literally or Not)
QA shouldn’t be sitting in a different Slack channel, physical office, or mental category. If you’re not having regular check-ins where devs and QA talk through blockers, you’re already behind. Shared goals. Shared visibility. Shared accountability.
2. Use CI/CD Like You Mean It
If your team isn’t shipping code through a continuous integration pipeline, you’re asking for problems. CI/CD tools (Jenkins, GitHub Actions, whatever fits) aren’t just for automating builds--they’re the nervous system that connects dev and QA. Every commit should trigger tests. Every test should give instant feedback. That’s how you stay fast and clean.
3. Automate the Repetitive Stuff, Save Humans for the Weird Stuff
No one should be manually checking if the main menu works. Use automation frameworks (yes, including GameDriver) to cover the basics--UI paths, physics sanity checks, asset validation, and more. Then let QA focus on what bots can’t: how the game feels, how it flows, what breaks when players act like absolute goblins.
4. Build Shared Dashboards or Don’t Bother
Everyone should be able to see what’s broken, what’s fixed, and what’s in review. That visibility is what kills finger-pointing and confusion. Tools like Jira and Linear are great, but only if they’re set up with shared ownership in mind. Bonus points if test results, build status, and bug priorities all live in the same place.
5. Sprint Like You Mean It
DevOps and Agile aren’t just management-speak--they work because they force alignment. Short cycles, constant retrospectives, and testable deliverables mean QA isn’t chasing ghosts. They’re testing what’s current, not what was “done” two weeks ago.
6. Treat the Process Like It’s Evolving--Because It Is
DevOps with embedded QA isn’t static. Your tools will change. Your workflows will change. The way your teams communicate should keep evolving too. That means constant learning, regular retrospectives, and not being afraid to scrap what’s not working. The studios that succeed aren’t the ones with perfect systems--they’re the ones that adapt fast.
Conclusion: QA Isn’t Optional | It’s Foundational
You can’t ship a great game by treating quality like an afterthought. You can’t build stable pipelines if QA is siloed until the end. And you definitely can’t keep pace with today’s players-or today’s dev demands-if your workflows are stuck in the past.
Integrated QA isn’t a trend. It’s the baseline.
The studios getting it right aren’t just writing better tests--They’re tearing down walls, embedding QA in design, dev, and daily work. They’re building pipelines that catch issues early and fix them fast. They’re creating teams where everyone owns the outcome, not just their little corner of it.
This isn’t theory. It’s already happening.
Welcome to the blog intermission. Feel free to give your eyes a break and thank you for making it this far.
You’ve made it past my original ramblings and now we can get to the good stuff.
PART 2- May 2025
How QA and DevOps Are Evolving in 2025
If You're Not Doing This Yet, You're Already Behind
In 2023, integrating QA into DevOps was an emerging best practice.
In 2024, it became more of the norm
In 2025? It’s the minimum bar for shipping anything stable.
The studios that used to treat QA like a post-production department have either restructured--or they’ve fallen behind.
That’s not hyperbole. It’s just what happens when your competitors are embedding QA from day one, shipping daily builds, and catching bugs before you even notice them.
This isn’t just a shift in how teams work.
It’s a full-scale redefinition of what quality means in game development and who owns it.
So what’s changed in the last year? A lot.
Let’s get into the real-world practices, tools, and structural shifts that are making QA + DevOps not just sustainable, but scalable.
Embedded QA Is the New Norm
QA is no longer the department that shows up at the end to test what someone else built.
The smartest studios have embedded QA directly into development squads. No more silos, no more backlogged bug reports from testers kept out of the loop.
Obsidian’s approach to Avowed is a prime example.
Instead of treating QA like bug-hunters, they renamed the role to QA Analyst and dropped them directly into the engine alongside designers and devs. These testers aren’t waiting for builds-they’re validating gameplay content in real time, inside the same tools the rest of the team is using.
Result? Fewer bugs, faster fixes, and a smoother launch.
This kind of structure is no longer experimental. It’s operational.
And it’s not just AAA.
Indie teams (especially those where one person is the dev, the designer, and the tester) have started adopting this mindset by default.
Developers test as they build.
CI pipelines catch breaking changes before they reach players.
Feedback from Early Access communities is treated like live QA data, prioritized, patched, and pushed within days (sometimes hours).
What both sides of the industry have realized is simple: when QA is embedded from the start, quality becomes part of the creative process- not a hurdle to clear after the fact.
It also flattens the hierarchy.
QA can flag broken logic before it hits a branch. Designers can see exactly how their content behaves under test. Developers aren’t guessing what QA needs-they’re collaborating with them directly.
This is what “shift-left” actually looks like: QA at the source of creation, not just the point of failure.
Workflows Are Finally Catching Up
It’s one thing to say QA is part of the dev process. It’s another to actually build workflows that support it. In 2025, the best studios aren’t just talking about DevOps--they’ve baked it into how they ship every day.
The backbone? CI/CD pipelines.
These aren’t just for enterprise software anymore. Game teams (big and small) are running continuous integration systems that automatically build and test code with every commit. It’s not flashy, but it’s what lets QA validate changes minutes after they’re made instead of weeks later.
Take nightly builds. Trunk-based development used to be a risky move.
Now, it’s the standard for teams who don’t want to spend their lives untangling stale branches and mystery bugs. QA can run tests on that night’s build, flag regressions, and get feedback back to devs before anyone’s coffee is cold.
And let’s talk cloud-based testing. Studios aren’t just emailing builds anymore. Platforms like AWS now let you stream a fresh build directly to internal or external testers without a giant install or setup phase. That means QA (and sometimes real players) can hammer on new content immediately, providing feedback that loops right back into the dev process.
For live-service games, these workflows aren’t just helpful | They’re non-negotiable.
When you’re shipping updates weekly (or daily), you need infrastructure that supports continuous testing, validation, and deployment. That’s what DevOps delivers, and QA is no longer tacked on at the end of that cycle-they’re embedded inside it.
No more bottlenecks. No more overnight heroics before a patch.
Just code, test, iterate, repeat.
Culture Shift: Shared Ownership or Nothing
You can have the best pipelines and automation in the world, but if your team still treats QA like second-class citizens, you’ve missed the point.
The real shift in 2025 isn’t just technical-it’s cultural. Studios are finally starting to treat QA as co-owners of the product, not just bug reporters.
In the smartest teams, QA is in the standups. They’re in sprint planning. They’re giving feedback before features are scoped not after they break in testing. That kind of inclusion changes everything.
Developers aren’t just coding anymore
They’re thinking about how to test their own work. Writing unit tests. Pairing with QA to automate workflows.
And when something breaks, it’s not “QA’s problem.”
It’s everyone’s problem.
On the flip side, QA isn’t waiting for someone else to define their role. They’re contributing to design decisions. They’re surfacing playability issues, not just functional bugs. And they’re doing it using the same tools and languages as the rest of the team.
Take Obsidian again. Their QA team was trained to use the same editor and asset pipeline as the designers. That’s not just efficient--it removes the traditional wall between “making the game” and “testing the game.” Everyone works in the same space. Everyone speaks the same language. No gatekeeping. No handoffs. Just shared ownership.
This kind of alignment creates tighter feedback loops, clearer communication, and way fewer dropped balls. Bugs don’t get lost in translation. Design issues don’t get ignored until launch. Everyone moves faster-and smarter-because no one’s waiting for someone else to care about quality.
It’s not collaboration solely for the sake of culture. It’s collaboration because it’s the only way to build complex games without burning out or breaking things.
(and pays off)
Smarter Tools, Not Just Faster Testing
Let’s talk about the tech that’s changing the game behind the scenes.
Because the biggest breakthroughs in QA aren’t just about speed.
They’re about insight.
In 2025, AI and automation have moved from flashy GDC demos to real, daily use. QA teams are using machine learning to detect patterns in crash logs, flag regressions automatically, and even predict where bugs are likely to show up. This isn’t about replacing human testers-it’s about giving them superpowers.
At GDC, NVIDIA showcased multi-modal AI that can scan massive open worlds, identify visual bugs, and analyze telemetry data in ways no human could pull off on a deadline. That’s not theoretical. That’s a real solution to a real problem: scale.
And that’s just the start.
Studios are also building out automated playtesting frameworks--scripted bots that run through gameplay loops, stress systems, and flag broken states before a single human touches the build. These bots aren’t about cutting corners. They’re about covering ground so your human QA team can focus on the stuff machines still suck at: feel, flow, fun.
Both Unreal and Unity have stepped up with stronger native testing frameworks. And third-party tools are making it easier than ever to simulate player input across every menu, mechanic, and mission. These tools plug directly into CI pipelines--so testing doesn’t just happen daily, it happens constantly.
Then there’s the cloud.
Need to test a multiplayer map with 50 users? Don’t round up bodies
Spin up test servers in the cloud and let virtual clients handle the heavy lifting. Want to send the latest build to your external QA team or community playtesters? Stream it instantly, no install required.
Tools aren’t just better-They’re smarter, leaner, and finally tuned for how real game teams work now.
But here’s the catch: these tools only make a difference if QA has access, input, and authority to use them as part of the build process. Not just to verify it after the fact.
AAA or Indie, the Shift Is Universal
DevOps isn’t just for the big studios with six-figure tooling budgets and dedicated DevOps engineers. It’s for everyone--because the core value is the same: build smarter, test earlier, fix faster.
That said, how it looks varies depending on your size.
AAA: Structure, Scale, and Specialized Roles
Many big studios have gone all-in on formalizing this integration. They’re embedding QA in every feature team. They’re renaming roles, restructuring departments, and investing in serious automation pipelines.
Take RGG Studio, the team behind the Like a Dragon series. Their secret?
QA isn’t an afterthought | It’s embedded from day one. Testing and debugging begin early in development while running in parallel with game production.
This approach allows the team to maintain their rapid release schedule without compromising…..wait for it…Quality.
QA analysts aren’t sitting in isolation.They’re embedded with design and dev, working directly in the game engine.
Indies: Ingenuity, Speed, and Player-Driven QA
Meanwhile, indie studios are proving you don’t need a 100-person QA team to get it right. Devs wear multiple hats--often QA included. But they’ve still embraced DevOps in their own way.
Instead of formal QA departments, they’re using lightweight CI services like GitHub Actions or Unity Cloud Build. Every commit triggers a build. Every build gets tested--even if it’s just by the dev themselves.
They lean hard on their communities, too. Early Access isn’t just a marketing play--it’s an extension of QA. Feedback from players goes straight into the pipeline, and hotfixes are pushed same-day. That’s DevOps. That’s quality as a shared responsibility.
The bottom line? Whether you’re a AAA studio with cloud infrastructure or a two-person team pushing patches through itch.io, the logic holds: testing early, integrating QA, and building tight feedback loops make you faster, leaner, and more likely to ship something that doesn’t crash at the title screen.
Conclusion: QA+DevOps Isn’t the Future
It’s the Standard
If there’s one thing the past year made clear, it’s this: quality is no longer something you “test for” at the end. It’s something you build in from the start.
Studios that are winning right now, whether they’re shipping AAA RPGs or pixel roguelikes--aren’t doing it with last-minute QA sweeps and duct-taped build processes. They’re doing it with embedded QA, real-time feedback loops, smart automation, and workflows that treat testing like part of development, not something that happens after it.
The old model? It’s dead.
And if you’re still clinging to it, you’re not just behind...You’re making your team’s job harder and your product riskier.
What works now is clear:
- QA and dev working in the same systems, on the same problems, at the same time.
- Automated testing that catches issues before they ship.
- CI/CD pipelines that push builds faster than you can draft a patch note.
- Tools and culture that make quality a team-wide priority | Not a department’s job.
This isn’t just how you catch bugs.
It’s how you keep your team sane, your process lean, and your players happy.
The tech is there. The playbook is written.
The only question is: are you going to use it?
Reference Links:
https://gamedriver.io/
https://www.gamedeveloper.com/programming/how-avowed-s-qa-team-stomped-out-bugs-by-working-inside-the-design-tools
https://aws.amazon.com/gametech/events/gdc2025/demo-showcase/build-distribution-playtesting/
https://www.ign.com/games/genre/live-service
https://www.digitaltrends.com/gaming/avowed-review-xbox-series-x/#dt-heading-relevant-fantasy
https://schedule.gdconf.com/session/empower-qa-teams-with-multi-modal-ai-presented-by-nvidia/
https://developer.nvidia.com/blog
https://unity.com/solutions/ci-cd
https://github.com/features/actions
https://www.reddit.com/r/justgamedevthings/comments/1fmxpir/multiplayer_chat/
Inspector randal on Tiktok https://www.tiktok.com/t/ZP86kMoNY/
https://toucharcade.com/2024/07/29/no-mans-sky-2024-review/
Additional Resources around QA-
IQPC Game Quality Fourm- https://www.iqpc.com/events-gamequalityforum
Qualicon by Game Quality- https://gamequality.org/
Underground Game QA- https://www.linkedin.com/company/underground-game-qa/about/