QA is process of ensuring product meets quality standards. Identifies defects, verifies requirements, improves software quality. Differs from testing (QC).

Tester manually execute test cases without automation tools. Verify functionality, usability, user experience. Time-consuming but effective for UI/UX.

QA is broader (process improvement), Testing is subset (finding defects). QA prevents issues, Testing detects issues.

Process from requirements to deployment. Phases: Planning, Analysis, Design, Development, Testing, Deployment, Maintenance.

Waterfall (sequential), Agile (iterative), Spiral (incremental), DevOps (continuous). Choose based on project needs.

Document outlining testing strategy, scope, schedule, resources. Defines what to test, how, when, by whom.

Set of steps to verify specific functionality. Components: ID, description, preconditions, steps, expected result.

High-level description of functionality. Multiple test cases derive from one scenario.

Functional (what system does) and non-functional (performance, security, usability). All requirements should be testable.

Functional (features work), Non-functional (performance, security), Regression (no new breaks), Smoke (basic functionality), UAT (user acceptance).

Quick test of major features. Ensures basic functionality works before detailed testing. Usually automated or manual quick tests.

After bug fix, verify fix works and doesn't break other features. Quick verification of specific change.

Ensure new changes don't break existing functionality. Re-run old test cases after modification.

End users test software before release. Verify software meets business requirements and is ready for deployment.

Test system performance under expected load. Measure response time, throughput under stress.

Test system beyond normal load. Find breaking point, capacity limits, recovery behavior.

Measure speed, scalability, stability. Load, stress, spike, endurance testing. Compare against benchmarks.

Evaluate user interface and experience. Verify easy to use, intuitive, meets user expectations.

Test on different browsers, devices, OS. Ensure consistent functionality across platforms.

Verify product usable by people with disabilities. Check keyboard navigation, screen reader support, color contrast (WCAG standards).

Identify vulnerabilities, test authentication/authorization, data protection. Prevent unauthorized access, data breaches.

Test on different languages, regions, cultures. Verify translations, date/time formats, currency symbols.

Broader than localization. Test infrastructure for multiple languages/regions. Design flexibility.

Deviation from expected behavior. Severity: Critical (crash), High (major function broken), Medium (minor issue), Low (cosmetic). Priority: how soon to fix.

Severity (impact on users), Priority (how soon to fix). High severity can have low priority and vice versa.

New, Assigned, In Progress, Fixed, Retest, Verified, Closed, Reopened. Track bug lifecycle.

Document describing defect. Components: title, description, steps to reproduce, expected vs actual, screenshots, environment.

International Software Testing Qualifications Board. Certification for testers: CTFL, CTFL-AT, CTAL.

Unit (code level), Integration (module interactions), System (complete system), UAT (user requirements).

Percentage of code/requirements tested. 100% ideal but impractical. Balance coverage with cost/time.

Test at boundaries: input min, max, just inside/outside. Useful for numeric, date, list ranges.

Divide input into groups. Test one value from each group. Reduces test cases while maintaining coverage.

Test combinations of conditions. Create table with conditions and expected results. Cover all combinations.

Test transitions between states. Example: application states (login, authenticated, logout).

Use predetermined checklist of features to verify. Quick but less thorough than detailed test cases.

Simultaneous learning and testing. Tester explores application without detailed test cases. Good for understanding software.

Unstructured testing without test cases. Tester uses intuition to find bugs. Not recommended as primary testing.

Two testers working together. One tests, other observes. Improve quality, knowledge sharing.

System where testing occurs. Should mirror production. Includes hardware, software, data, network configuration.

Input data for tests. Can be real data or synthetic. Must be realistic, comprehensive, sometimes sensitive (PII).

Replace sensitive data with fake data. Protect privacy in test environment. Example: replace SSN with dummy value.

Conditions to stop testing. Examples: all test cases passed, coverage target met, deadline reached, budget exceeded.

Map requirements to test cases. Ensure all requirements tested. Track coverage.

Bugs found in production that escaped testing. Indicates inadequate testing. Calculate: (bugs in prod / total bugs) * 100%

Measure testing progress: test case pass rate, bug density, coverage, time spent. Help track quality.

Testing shows presence of bugs (not absence), exhaustive testing impossible, early testing, defects cluster, pesticide paradox, testing context-dependent, absence-of-error fallacy.

Running same tests repeatedly loses effectiveness. Need new test cases to find new bugs.

Investigate why bug occurred, not just fix symptom. Prevent recurrence. Techniques: 5 Whys, Fishbone diagram.

Prioritize testing high-risk areas. Balance coverage with time/resources. Test high-risk features more thoroughly.

Performance, security, usability, accessibility, reliability. Equally important as functional testing.

Use tools/scripts to run tests automatically. Faster, reliable, repeatable. Tools: Selenium, TestNG, Cypress.

Automate: repetitive, regression tests, load testing. Manual: exploratory, UI/UX, one-time tests, new features.

Keep tests up-to-date as app changes. Update selectors, assertions, data. Ongoing effort not one-time task.

Tight deadlines, unclear requirements, inadequate resources, changing scope, complexity of modern apps, maintaining test coverage.

Criteria must be met before moving to next phase. Examples: test pass rate > 95%, coverage > 80%, no critical bugs.

Automatically run tests on every code commit. Detect issues early. Fast feedback to developers.

Automatically deploy to production if tests pass. Faster releases, continuous feedback from users.

Move testing earlier in development. Test requirements, design, code. Cheaper to fix bugs early.

Check test cases for quality: correct, complete, clear, executable. Another tester reviews for second opinion.

Run test cases on application. Document results. If fail, investigate, create defect report.

Record of test execution: when ran, who ran, result, any issues. Track testing progress.

Summary of testing activities. Statistics: tests run, passed, failed, blocked. Recommendations for release.

Test management: TestRail, Zephyr. Defect tracking: Jira, Bugzilla. Automation: Selenium, Cypress, Appium.

Organize test cases, track execution, report results. Examples: TestRail, Zephyr, TestNG, JUnit.

Record, track, manage bugs. Examples: Jira, Azure DevOps, Bugzilla. Workflow from creation to closure.

Test APIs directly (not through UI). Use tools: Postman, Rest Assured. Verify endpoints, status codes, response data.

Verify data in database. Run SQL queries. Check data integrity, transactions, constraints.

Test complete user workflows. From start to finish of business process. Example: login -> search -> purchase -> logout.

Test interaction between components/modules. Ensure data flows correctly between systems.

Knowledge of internal code structure. Test code paths, branches, conditions. Developer-focused.

No knowledge of internal code. Test inputs and outputs. Tester-focused. Most common in manual testing.

Partial knowledge of internal code. Test APIs, databases, business logic with some code awareness.

Manage versions of code, requirements, documentation. Track changes, enable rollback. Tools: Git, SVN.

Mock simulates external component behavior. Stub provides canned response. Useful for testing without real dependencies.

Reference point for comparison. Establish baseline results, compare new results to detect regressions.

Table showing features vs test scenarios. Ensure comprehensive coverage of all feature combinations.

Metrics measuring success: test pass rate, bug escape rate, defect density, test coverage, time to release.

Short sprints, changing requirements, less documentation, continuous testing needed. Adapt testing practices for speed.

Testing in Agile sprints. Daily testing, continuous feedback, quick turnaround. Integrate testing with development.

Conditions defining when feature is complete. Written by product owner. Tests verify acceptance criteria.

Combine testing with business language. Gherkin syntax: Given-When-Then. Bridge gap between testers and business.

Objects replacing real dependencies: mocks, stubs, fakes, spies. Enable isolated testing.

Write tests before code. Red-Green-Refactor cycle. Ensures code quality, testability.

Random input/actions to find bugs. Tester acts like monkey pressing buttons randomly. Find unexpected issues.

Intensive testing of single feature. Focus all resources on one area. Thorough but limited scope.

Run test for extended period under normal load. Find memory leaks, data corruption over time.

Suddenly increase load beyond normal. Test system response to traffic spikes. Check recovery.

Test with large data volume. Verify system handles big datasets. Check performance degradation.

Test system recovery from failures. Crash system, verify it recovers gracefully, data integrity maintained.

Test switching to backup system on failure. Ensure continuity, minimal downtime, no data loss.

Testing is part of QA. QA broader: process improvement, standards, quality metrics. Testing focuses on finding defects.

Test multiple related products together. Verify integration, compatibility between products.

Intentionally introduce bugs (mutations) to verify tests catch them. Measure test effectiveness.

Two developers write code together. Alternate roles. Improves code quality, knowledge sharing.

Ability to rerun failed tests and get same result. Deterministic tests, not flaky.

Tests independent, don't affect each other. Cleanup after each test. Run in any order.

Setup/teardown for tests. Prepare test environment, clean up after. Ensure consistent test state.

Framework executing tests. Manages setup, execution, reporting. Makes testing easier and standardized.

Same test produces same result each time. Important for debugging, regression testing.

Organization valuing quality. Everyone responsible for quality. Testing integrated in development process.

101-150. Advanced Topics (abbreviated)

101-110: Strategic testing planning, test estimation, test resource management, testing budget/ROI analysis. 111-120: Complex test scenarios, multi-threaded application testing, distributed system testing, cloud testing. 121-130: Security testing (vulnerability scanning, penetration testing, OWASP), privacy testing (GDPR, CCPA compliance). 131-140: Mobile testing (iOS, Android specific), web testing (responsive, cross-browser), desktop application testing. 141-150: Testing for machine learning models, IoT device testing, blockchain testing, testing emerging technologies, test leadership and mentoring, test process improvement, Six Sigma in QA.