Free to read ยท Three levels

Software Quality Assurance

Learn to design, investigate, automate, and communicate software tests through realistic evidence, from acceptance rules to risk-based release decisions.

18 lessonsEnglish + ArabicContent reviewed
Start learning

In this course

This public self-study course develops software testing judgment through a fictional training and scholarship portal. Eighteen teaching chapters progress from quality principles, requirements, and test design to API, database, browser, accessibility, automation, security, performance, and release evidence. Every chapter includes worked scenarios, common failures with prevention, and exercises with explained solutions.

The examples use synthetic data and bounded local reasoning. Testing supplies evidence under stated conditions; it cannot establish exhaustive correctness, universal accessibility, or absence of security vulnerabilities. Code snippets are illustrative and are never executed by the public course. Primary references support further study; this independent course is not a certification or an accredited exam-preparation claim.

What you will learn

  • Turn user needs into observable acceptance rules and independent test oracles.
  • Design boundary, decision, state, exploratory, and property-based checks with explicit limitations.
  • Investigate API, data, browser, accessibility, security, and reliability risks using synthetic examples.
  • Maintain trustworthy automation and communicate release evidence, gaps, and residual risks.

Your learning path

Three levels

Basic: reasoning and test design

Establish quality vocabulary, observable requirements, test levels, systematic input design, and disciplined investigation.

  1. Quality, risk, and trustworthy evidence
  2. Requirements, acceptance, and testability
  3. Test levels, isolation, and useful assertions
  4. Equivalence partitions and boundary values
  5. Decision tables and state transitions
  6. Defect reports and exploratory investigation
Explore this level

Intermediate: integrated product evidence

Investigate interfaces and persistent state, evaluate complete user tasks, and build dependable automation and regression evidence.

  1. API contracts, errors, and repeated requests
  2. Database integrity, transactions, and concurrency
  3. Web journeys, sessions, and asynchronous behavior
  4. Accessibility as observable usability
  5. Automation, fixtures, and trustworthy test data
  6. Regression selection and unreliable tests
Explore this level

Advanced: strategy, resilience, and leadership

Connect risk to security, performance, properties, reliability measures, and transparent release decisions.

  1. Risk-based strategy and defensible scope
  2. Security quality and abuse-case testing
  3. Performance experiments and failure recovery
  4. Property-based and metamorphic testing
  5. Coverage, reliability metrics, and release evidence
  6. Test leadership and continuous quality learning
Explore this level

Who this is for

  • Aspiring software testers and quality engineers who want practical theory and evidence-driven reasoning.
  • Developers, product owners, and technical leads who share responsibility for trustworthy software behavior.

Before you start

  • Basic familiarity with web applications, files, forms, and simple structured data.
  • Ability to follow short Python-like examples; advanced programming is not required for the basic level.

Related technical solutions

UI tests fail intermittently: synchronize with meaningful stateDiagnose a browser check that sometimes misses a confirmation or reads stale search results. Replace timing guesses with isolated state and bounded, observable conditions.Tests pass locally but fail in CI: compare environments and isolate dataInvestigate a context-dependent failure with a minimal environment comparison and independent fixtures. Focus on test behavior, data, clock, locale, and engine semantics rather than platform administration.High coverage hides failures: strengthen the test oracleInvestigate a suite that executes most code while missing wrong results. Separate statement and branch coverage from requirement evidence and replace circular or weak assertions with meaningful observations.