Skip to content
EncryptTechBD
Home Industries Our Work Blog Pricing About Contact Discuss Your Project
বাংলা (BN)
Software Engineering 6 min read

Software quality assurance strategy: problems and fixes

Diagnose the common failures in a software QA strategy, from late testing and vague acceptance criteria to brittle automation and missing release authority.

E
EncryptTechBD · 0 comments
Laptop displaying lines of code in a dark office
Photo: Negative Space / StockSnap

When a release causes an outage, the instinct is to blame the testers. The more useful question is which decision in the quality assurance strategy allowed the defect through. A QA strategy is not a test plan. It is the set of choices about risk, evidence, environments, automation and who has the authority to stop a release.

This guide describes problems that recur in growing software teams, their causes and the fixes that change outcomes. It assumes a business application, not a safety-critical system, though the principles travel.

Symptoms of a weak QA strategy

  • Defects are found by customers more often than by the team.
  • Testers receive builds late and are asked to "test everything" before a fixed date.
  • The regression suite takes so long that nobody runs all of it.
  • Automation exists, but the team does not trust its results.
  • Nobody can explain what "done" means for a requirement.
  • Quality is discussed only when something breaks.

Problem 1: testing begins after development is finished

What it looks like: requirements are handed over, development proceeds for weeks, and testers see the build near the release date. The test window compresses and the team ships what it could check rather than what matters.

Why it happens: the plan treats testing as a phase rather than a continuous activity, and no one is accountable for testability during design.

What to change: involve testers in refinement and design reviews. Ask for acceptance examples before development starts. Make the test approach part of the definition of ready, and reserve time for exploratory testing.

Evidence it worked: defects raised during refinement, fewer late-stage requirement changes and a test window that does not collapse in the final week.

Problem 2: acceptance criteria describe activity, not outcome

What it looks like: a ticket says "build payment reconciliation" or "improve the dashboard". Testers interpret it one way, the developer another and the business a third.

Why it happens: the team writes tasks from a solution description instead of an observable behaviour, and nobody agrees on the example that proves it works.

What to change: write acceptance criteria as examples with inputs, actions and expected results. Include the failure paths: expired card, duplicate submission, missing permission, timeout and partial data. Get the product owner to confirm the examples before work starts.

Evidence it worked: fewer "works as designed" arguments, fewer reopened tickets and a checklist support can use.

Problem 3: automation is measured by test count

What it looks like: the suite grows into hundreds of interface tests that fail for timing reasons, duplicate coverage and take hours to run. Engineers disable failing tests to get a release out.

Why it happens: automation is treated as a coverage target rather than a feedback system, and nobody owns its maintenance.

What to change: put most checks at the API and unit level, keep a small set of end-to-end journeys for critical paths, and track signal quality rather than count. Every failing test should have an owner and a decision: fix, rewrite or delete. Run the fast suite on every change and the slow suite on a schedule.

Evidence it worked: shorter feedback time, fewer flaky failures and engineers who trust a red build.

Problem 4: every change gets the same test depth

What it looks like: a label change and a payment rule change receive the same review and test effort, while a risky migration gets whatever time is left.

Why it happens: the process is uniform because prioritisation requires judgement and evidence.

What to change: assess each change on impact and likelihood. Consider money movement, personal data, authentication, integrations, data migration and customer-facing commitments as high impact. Define the minimum evidence for each tier.

Evidence it worked: test effort concentrated on the changes that can hurt the business, with no increase in escaped defects on high-risk work.

Problem 5: test environments and data are unreliable

What it looks like: the staging site runs different configuration from production, test data is a stale copy with real customer records, and a test fails because a third-party sandbox is down.

Why it happens: environments are treated as infrastructure chores rather than part of the quality system, and nobody owns their fitness for purpose.

What to change: define the environments required for each test level, keep configuration under version control, generate synthetic test data and mask personal data in any copy. Provide stable sandboxes for payment and messaging integrations.

Evidence it worked: fewer environment-related failures, reproducible defects and shorter setup time for new team members.

Problem 6: QA has no release authority

What it looks like: the release date is fixed before scope is known, and a known defect is shipped with a promise to fix it later. The test report is advisory, and commercial pressure always wins.

Why it happens: quality is seen as a department rather than a shared decision, and there is no agreed rule for what blocks a release.

What to change: define a short release policy: what must pass, what can ship with a documented exception, who accepts the risk and how the decision is recorded. Give one accountable person the authority to stop a release.

Evidence it worked: release decisions are predictable, exceptions are explicit and reviews point to decisions.

Diagnostic sequence

  1. Collect defect leakage: defects found after release, by severity and source.
  2. Map the test levels actually performed, not the ones in the process document.
  3. Sample ten recent requirements and compare acceptance criteria with the tests executed.
  4. Review the automation suite for runtime, flakiness and ownership.
  5. Check environment parity and test data handling against production.
  6. Read the last five release decisions and look for undocumented exceptions.

The output should be a short list of decisions to change, not a longer test plan.

A 90-day repair plan

Days 1 to 30: agree the release policy, introduce acceptance examples, identify the critical journeys and measure the current feedback time. Stop adding new end-to-end tests until the existing suite is trustworthy.

Days 31 to 60: tier the test approach by risk, fix or delete the worst automation, stabilise environments and start a weekly defect review that includes support.

Days 61 to 90: publish quality metrics, review the release exceptions, and decide which manual checks to automate next based on risk and repetition.

Quality metrics

  • Escaped defect rate: defects found after release divided by all defects found.
  • Defect age: median days from report to resolution, split by severity.
  • Feedback time: minutes from commit to a trustworthy test result.
  • Change failure rate: releases that require a hotfix or rollback.
  • Critical journey coverage: the share of agreed business journeys with an automated or scripted check.

Where this fits in our work

If the release process needs a hard look rather than another tool, start with Custom Software and Integrations. The pricing page explains how assessments and delivery work are scoped. For the interface layer, read the REST API design checklist.

Sources

Services that deliver this

Want this implemented properly?

Pricing →

Every engagement starts with a written scope. If a requirement is outside it, we quote it separately before starting.

Responses (0)

No comments yet. Add the first one below.

Leave a response

Your email address will not be published. Required fields are marked *.

Keep reading

More field notes