Skip to main content

QA Strategy

Improving software quality: test strategy, automation and early QA

Quality is not created in the last test before release. How test strategy, early reviews, targeted automation and clear metrics work together.

Quality Assurance Standards | Hetz Enterprises

What does software quality actually mean?

"The software should be bug-free" – that is often the first answer. But quality is more than the absence of defects. The international standard ISO/IEC 25010, in its current 2023 edition, describes nine product quality characteristics:

  • Functional suitability: does the software do what it should – completely and correctly?
  • Performance efficiency: does it respond fast enough, even under load?
  • Compatibility: does it work together with other systems and interfaces?
  • Interaction capability: can people use it well – including people with disabilities?
  • Reliability: does it run stably and recover from failures?
  • Security: does it protect data from unauthorised access?
  • Maintainability: can it be changed and extended with reasonable effort?
  • Flexibility: can it be adapted to new environments?
  • Safety: does it avoid hazards to people, the environment or property?

Not every characteristic matters equally for every system. An internal reporting tool needs different priorities than a customer portal with payments. This is where good quality assurance begins: with the question of which quality matters for this system.

Why quality is not created in testing alone

In many projects, testing comes at the end: development is "done", the test team receives a package a week before release and is expected to confirm that everything works. Whatever is found at that point is expensive. The code has to be touched, tested and shipped again, the deadline wobbles, and defects that slip through reach the users.

The later a defect is discovered, the more work depends on it. An ambiguous requirement can be clarified in a review with one question. After go-live, it becomes a bug ticket, a hotfix, a regression test and, in the worst case, a complaint. Improving quality therefore does not primarily mean testing more, but testing earlier and more purposefully.

Lever 1: a test strategy driven by risk

Exhaustive testing is impossible – one of the principles of professional software testing. What matters is spending the available time where a defect would cause the most damage. This approach is called risk-based testing.

The functions of a system are assessed against two questions: how likely is a defect, for example because the code is new, complex or frequently changed? And how severe would the impact be, for example on revenue, data protection or reputation? High-risk functions are tested thoroughly, early and repeatedly. Low-risk functions receive less effort.

The result is a test strategy that records what is tested, with which methods, in what depth and by whom. It makes test effort plannable and justifiable – to project management as well as in audits.

Lever 2: check early instead of fixing late

Under the heading shift-left, quality assurance moves forward in the project. In practice, this means:

  • Reviews of requirements and user stories: are they unambiguous, complete and testable? Contradictions surface here, before they are coded.
  • Acceptance criteria before development: during refinement, the team agrees how to recognise that a story is done – often in the "Given … When … Then …" format.
  • Test cases alongside development: tests are written while the feature is being built, not afterwards.
  • Code reviews and static analysis: many defects and weaknesses can be found without running the software at all.

These steps take little time and often save many times as much rework, because questions are answered before the first line of code is written.

Lever 3: automate what repeats

Every release needs certainty that existing functionality still works. Repeating these regression tests manually takes more time with every release. This is where test automation shows its strength.

The test pyramid has proven to be a good guide:

  • Many unit tests check individual building blocks quickly and cheaply.
  • Fewer integration and API tests check how components work together.
  • A few end-to-end tests via the user interface secure the most important flows from the user's perspective, for example with Selenium or Playwright.

Integrated into the CI/CD pipeline, these tests run automatically with every change. Defects surface minutes after the commit instead of weeks later. It is important to start with the critical flows and to build tests that are maintainable from the outset. An unstable test suite that constantly raises false alarms is quickly ignored and loses its value.

Lever 4: test manually where people are better

Automation does not replace every test. People are better at discovering the unexpected, questioning flows and judging usability from the user's point of view. Three areas benefit particularly from manual testing:

  • Exploratory testing: experienced testers explore new features purposefully but without a rigid script – and find defects nobody had thought of.
  • Usability: is a flow understandable? Are error messages helpful? This cannot be measured automatically.
  • Accessibility: automated checking tools detect only some barriers. Whether a form can really be used with a keyboard and screen reader only becomes clear in manual testing.

The best quality assurance combines both: automation for what is repeatable, human expertise for what is new and unexpected.

Lever 5: make quality visible

What is not measured is hard to improve. At the same time, the wrong metrics lead to the wrong behaviour: measuring testers by the number of defects found produces many small tickets, but not necessarily better software. Meaningful metrics include:

  • Defects after release: how many defects do users find that should have been caught in testing?
  • Risk coverage: have all high-risk functions been tested – and with what result?
  • Defect lead time: how long does it take from report to fix?
  • Stability of automated tests: how often do tests fail without a real defect?

A short, understandable test report before every release answers the question decision-makers really care about: what residual risk are we taking if we go live now?

A typical scenario from practice

A company runs a customer portal and ships new features once a month. Before each release, the team tests manually for several days. Even so, defects regularly appear after go-live in areas that were not changed at all.

A structured approach could look like this:

  1. Risk analysis: together with the business and development, the team defines the critical flows, such as registration, login, application and payment.
  2. Automated regression: exactly these flows are automated and run in the pipeline with every change.
  3. Early reviews: new user stories get acceptance criteria before development starts.
  4. Targeted manual testing: the time saved goes into exploratory testing of new features and accessibility checks.
  5. Clear report: before each release, there is a short overview of tested risks and open issues.

Manual regression effort falls, defects in existing features surface earlier, and the release decision is based on facts rather than gut feeling.

Checklist: where does your project stand?

  • Is there a written, risk-based test strategy?
  • Do user stories have acceptance criteria before development starts?
  • Are requirements reviewed by someone with a testing mindset before implementation?
  • Do automated tests run with every change – and are they stable?
  • Are new features also tested exploratively and for accessibility?
  • Is there an understandable residual-risk report before every release?

If you answer several questions with "no" or "not exactly", that is usually where the greatest potential lies – often with manageable effort.

How we support you

We help organisations set up quality assurance that is plannable and effective – from an initial assessment to ongoing support within the team:

  • Test strategy and test concept, tailored to your risks and your delivery model, agile or traditional.
  • Test management: planning, control and reports that make decisions easier.
  • Test automation: choosing the right approach, building maintainable tests and integrating them into your pipeline.
  • Reviews of requirements, user stories and test cases.
  • Accessibility testing against WCAG 2.2 and EN 301 549.

Our work is based on more than ten years of hands-on quality assurance and on internationally recognised ISTQB® and A4Q certifications.

Frequently asked questions

What is risk-based testing?

In risk-based testing, test effort is allocated according to how likely a defect is and how much damage it would cause. Critical functions are tested thoroughly and early, less critical ones with less effort. This puts the available time where it has the greatest effect.

What does shift-left mean in quality assurance?

Shift-left means moving quality assurance earlier in the project: reviewing requirements, defining acceptance criteria before development and writing tests alongside the code. Defects are found earlier, when fixing them still costs little.

Is test automation worthwhile for smaller projects?

Often yes, if the software is developed further on a regular basis. Even a few automated tests for the most important flows save manual effort with every release. For one-off, short-lived projects, manual testing can be more economical.

Does test automation replace manual testing?

No. Automated tests reliably check what is known and repeatable. For new features, usability and accessibility, manual exploratory testing remains essential. The best results come from combining both approaches.

How can you recognise good software quality?

Among other things, by few defects after release, stable and fast flows, an interface that all user groups understand, and the ability to develop the software further without major risk. The ISO/IEC 25010 standard describes nine quality characteristics for this.

Industries

Industry expertise

Every industry has its own rules, risks and auditors. We know them from practice – and test so that your software not only works but stands up to every audit.

  • Financial services

    Online banking, core banking systems and regulated processes. We test against high security and compliance requirements – so releases stay predictable, traceable and auditable.

    • BFSG
    • DORA
    • BAIT
  • Public sector

    Specialist applications, citizen portals and SAP landscapes. Accessibility under BITV, clean acceptance testing and documentation that stands up to any audit.

    • BITV 2.0
    • EN 301 549
    • SAP
  • IT & Software

    For software vendors and IT service providers: test strategy, automation in the CI/CD pipeline and quality assurance of AI features – from MVP to release.

    • CI/CD
    • Test automation
    • EU AI Act