Cross-Team Testing: Lessons from Collaborating with DevOps

"Why are we catching this bug after deployment?"

It was 2:47 AM. We were mid-incident. Again. As an SDET, I had run every test in our suite. But something had slipped through—a misconfigured environment variable that only DevOps had access to.

Sound familiar?

If you've ever felt like you're testing in the dark, unsure of what lurks on the other side of the pipeline, you’re not alone. The root cause? Siloed testing.

And the solution? Cross-team collaboration. Especially with DevOps.

Why Cross-Team Testing Matters More Than Ever

Modern software development is like a relay race.

SDETs, developers, and DevOps engineers each carry the baton for a leg of the journey. But if we’re not handing it off properly, bugs drop. And when they do, they land hard: missed SLAs, delayed releases, unhappy customers.

DevOps isn’t just about CI/CD pipelines or YAML files. It’s about systems thinking, infrastructure visibility, and deployment confidence. When SDETs embed themselves into DevOps conversations, something powerful happens:

• We test environments, not just code.
• We validate configurations, not just functions.
• We build resilience, not just test cases.

A Tale of Two Teams (and One Very Expensive Bug)

At one fintech company I worked with, production outages were frequent. QA blamed DevOps. DevOps blamed QA.

The fix? We ran a joint retrospective—DevOps, QA, and SDETs in one room. What emerged was eye-opening:

• Test environments were not identical to prod.
• Canary deployments weren’t monitored by QA tools.
• Critical logging was absent from SDET test plans.

We decided to embed an SDET into the DevOps planning sprint. Within one quarter:

• Incident count dropped by 40%
• Deployment rollback rate dropped by 60%
• Post-mortem blame sessions? Almost extinct.

Another Win: Feature Flags & Fast Feedback

At a retail tech startup, DevOps introduced feature flags to reduce risk. But toggling features in lower environments was inconsistent, causing confusion during regression testing.

Our solution? We built test hooks into the flags and created SDET-owned scripts to simulate flag states across environments.

Now QA could test every possible path, before the feature even reached staging.

Result? We caught 3 high-priority bugs in staging that would’ve cost us thousands in refunds.

Practical Strategies to Foster DevOps-SDET Collaboration

Here are some battle-tested strategies I’ve used (and seen work) to bring SDETs and DevOps closer:

1. Attend Each Other’s Standups

You’d be surprised how much clarity comes from just 5 minutes of listening in. Understand what DevOps is deploying, and they’ll understand what you’re testing.

2. Co-Own Environments

Make sure QA isn’t locked out of environment configurations. Better yet—enable SDETs to spin up their own isolated environments for testing infrastructure-related scenarios.

3. Automate Infra Validation Tests

Use your testing expertise to write automated tests for things like:

• Missing env variables
• Misconfigured services
• Invalid deployment artefacts

This builds trust and coverage.

4. Shift Security Left Together

Collaborate on testing SSL cert renewals, rate limiting, and secrets management before they hit production. It’s often DevOps' responsibility—but SDETs can test it too.

5. Create Shared Dashboards

Use tools like Grafana, Kibana, or Datadog to create QA visibility into:

• Deployment success rates
• System health post-release
• Test pass/fail heatmaps across environments

Collaboration is the New Coverage

As systems grow more complex, no team can catch every bug in isolation. DevOps has the context. SDETs have the craft. Together, we can build software that’s not just functional, but resilient, scalable, and safe.

What About You?

Have you collaborated closely with DevOps on testing? What worked—or didn’t work—for your team?

I’d love to hear your experiences, war stories, and ideas in the comments.

Let’s start a conversation that pushes our craft forward.

About the Author: As an experienced SDET passionate about breaking silos and building testable systems, I write about testing culture, quality engineering, and modern DevOps practices. Follow me for more insights on levelling up your QA game.