How To Strengthen Quality Assurance Before A Major Deployment

getty

Faster release cycles and AI-assisted development have changed how software is built, but they haven’t made disciplined quality assurance any less important. Before a major deployment, teams need confidence that new code works as intended, integrates cleanly with existing systems and won’t introduce avoidable security, performance or reliability problems.

Compressed timelines and rapidly generated code can make defects harder to spot before they reach production. Below, Forbes Technology Council members share the QA steps teams should never skip before a major release and explain why those checks remain essential.

Use Mutation Testing To Validate QA Controls

Teams should never skip mutation testing. As AI-generated code speeds up release cycles, deliberately introducing small bugs into the codebase confirms that QA checks actually catch those bugs. Speed without stronger safeguards is how teams crash; a car doing 150 mph needs bigger brakes and wider tires than one doing 35. - Daniel Jebaraj, Syncfusion, Inc.

Test Real User Scenarios With Human Oversight

Teams should never skip user scenario definition and adversarial testing validated by human experts. AI can look perfect while hiding subtle errors. In my experience, issues creep up at handoff boundaries between teams, and AI exacerbates that. That’s why accountability must rest with a human. A precommitted rollback plan paired with clear ship gates ensures errors are caught before they compound. This contains the blast radius of inevitable production surprises. - Chhaya Methani, Microsoft

Forbes Technology Council is an invitation-only community for world-class CIOs, CTOs and technology executives. Do I qualify?

Run End-To-End Tests In A Production-Like Environment

The quality assurance step that should never be skipped before any major deployment is end-to-end testing in a production-like environment. As AI accelerates code generation, issues are more likely to surface in the ways systems interact across integrations, data flows and controls, rather than in isolated components. In banking, this ensures reliability, auditability and customer trust. - Matt Linderman, Atlantic Union Bank

Require Reviewers To Explain The Code

Substantive code review—where the approving engineer can explain not just what a change does but why it was implemented that way—is the step teams are increasingly skipping as AI accelerates output. AI-generated code is plausible enough to pass surface-level scrutiny, which means defects and architectural flaws get approved, not caught. A review that cannot answer “Do we understand this?” is not a quality gate but a sign-off ritual. - Kevin Cushnie, Modus Create

Test Real-World Scenarios For Regression Risks

Never skip scenario-based regression testing with human review. AI-generated code may pass basic tests but still fail in edge cases, integrations or business logic. In marketing science, one flawed release can misread performance signals or optimize toward the wrong outcome. Testing against real workflows protects trust, accuracy and decision quality. - Ambarish Majumdar, Meta

Enforce Automated Quality Gates

The step you never skip is the gate every change clears before it merges. The compiler, the type checker, the linter and the full test suite all run, and if a single one fails, the build fails. As more code gets generated, that gate matters more, because the volume going through it climbs while the human attention per line drops. - Michael Quoc, Product.ai

Scan AI-Generated Code For Security Risks

Teams need to ensure adversarial security taint analysis for all AI-generated outputs is never skipped. This step is crucial as AI models are very susceptible to data poisoning and may accidentally introduce legacy vulnerabilities and malware into the codebase. This is a necessary step, as fast release cycles cannot come at the cost of our perimeter security. - Adithyan RK, Hyring.com

Require Human ‘Comprehension Sign-Off’

Never skip a human “comprehension sign-off.” AI code is dangerous because it’s plausible—it compiles, reads clean, passes happy-path tests and disarms reviewers trained to spot risk in messy code. Before deploying, someone must explain what it does at the edges and how it fails. Tests catch what you anticipated; comprehension catches what you didn’t. - Hastimal Jangid, Coozmoo Digital Solutions, Inc.

Use Shadow Deployments To Test Production Traffic

Never skip a shadow deployment. Let the new release process real production traffic in read-only mode, without affecting users or data, and compare its behavior against the live system. AI-generated code can pass scripted tests and still behave oddly in the wild. Shadowing catches reality-shaped defects before customers become the test environment. - Akhilesh Sharma, A3Logics Inc.

Make Every Process Owner Accountable For Quality

The No. 1 technique we advocate is Ji Kotei Kanketsu, often translated as “own process ownership.” Each process owner (whether it’s a human or an agent) takes complete responsibility for quality and agrees to ensure that their own defects never flow downstream. Rather than adding ML into existing processes and relying on downstream checks to catch problems, JKK inverts this. - Nicole Radziwill, Team-X AI (a unit of Ultranauts, Inc.)

Verify AI-Generated Code With Symbolic AI

AI-generated code (which means generated by LLMs) doesn’t boast 100% reliability. More code means more system interactions and more edge cases, but LLMs can’t verify code reliably. The next wave will be about code verification. The suitable quality assurance step is to launch AI agents employing symbolic AI, which can verify software functions and generate auditable causal chains. - Filip Dvorak, Filuta AI

Maintain Traceability From Requirements To Validation

One QA step that should never be skipped is requirements traceability. AI can generate code quickly, but it can’t ensure alignment with business intent. Every major deployment should demonstrate that requirements, implementation and validation are connected. Speed is valuable, but confidence comes from knowing you’ve solved the right problem. - Lori Schafer, Digital Wave Technology

Validate Regulatory Compliance Before Release

Teams should never skip compliance validation before deploying AI-generated code in regulated industries. AI doesn't understand HIPAA, SOX, CMMC or NSM-10 requirements. Functionally correct code could violate regulatory controls without anyone knowing until an audit surfaces it. Testing against regulatory frameworks ensures the code doesn’t create compliance violations. Post-deployment remediation costs far more and invites scrutiny that damages trust. - Dan Sorensen, Nexus Security Advisors

Audit Code Permissions And Access Requests

Audit what permissions the new code requests. Unit tests check that the logic works. They rarely check that the code only accesses the data and APIs it needs. AI-generated code overpermissions by default because broad scopes are the path of least resistance. A permissions diff before deployment catches the access creep that becomes the next breach vector. - Nidhi Jain, CloudEagle.ai

Bring In A Fresh Reviewer

Never skip a “fresh eyes” review by an engineer who didn’t write or prompt the code. AI can produce convincing solutions that hide flawed assumptions. A reviewer unfamiliar with the implementation is more likely to ask the questions automated tests never will. - Shuchi Agrawal

Prepare And Practice A Rollback Plan

Never deploy without a rollback plan that your whole team has walked through. AI-accelerated development lets you build faster, but faster also means more surface area for something to go wrong. If your team cannot revert to a stable version within minutes, you are not ready to ship. Confidence in your release should include confidence in your recovery. - Marc Fischer, Dogtown Media LLC

Validate Observability Before Launch

One quality assurance step teams should never skip is validating observability before deployment. AI helps teams release code faster, so it’s unrealistic to expect every issue to be caught in testing. What matters is ensuring the application can be monitored, traced and quickly rolled back if something goes wrong. In today’s fast-moving development environment, the ability to detect and respond to problems quickly is just as important as preventing them. - Arun Goyal, Octal IT Solution LLP

Confirm the Code Matches Business Intent

Business logic validation is the step teams most often skip when speed is the priority. AI-generated code can pass unit tests and still produce outputs that are technically correct but operationally wrong. In supply chain environments, a pricing error or order routing flaw that slips into production can create real financial and customer impact within hours. Having a human verify that the code does what the business intended is not optional. - Steven Singer, Julius Silvert, Inc.

Test For Hallucinated Dependencies

AI often suggests libraries or API calls that look real but don’t exist. Never skip dependency resolution validation in a production-like sandbox. Why? A fake package can pass linting (an automated process of analyzing source code), then fail mid-deployment, taking down AI features during peak sales hours. Trust but verify every import. - Eshaan Jain, Mphasis Silverline