Duration 3 days – 21 hrs

 

Overview

 

The APM and Observability Tools for Testers Training Course is designed to provide software testers, QA teams, performance testers, and technical support teams with practical knowledge of Application Performance Monitoring and observability concepts.

 

This course focuses on how testers can use logs, metrics, traces, dashboards, alerts, and monitoring tools to understand application behavior, detect performance issues, investigate defects, validate system reliability, and support production readiness. Participants will learn how observability supports functional testing, performance testing, API testing, regression testing, incident investigation, and continuous quality improvement.

 

The course introduces common observability and APM tools such as Azure Application Insights, Grafana, Prometheus, Datadog, New Relic, Dynatrace, Splunk, Elastic/Kibana, and OpenTelemetry at a foundational level. The course is tool-flexible and may be customized depending on the client’s actual monitoring platform.

 

 

Objectives

 

• Understand the fundamentals of APM and observability.
• Explain the difference between monitoring, APM, logging, tracing, and observability.
• Understand the role of logs, metrics, traces, alerts, dashboards, and events in testing.
• Use observability data to support defect investigation and root cause analysis.
• Interpret key application performance indicators such as response time, latency, throughput, error rate, saturation, and availability.
• Understand how testers can use dashboards during functional, regression, API, and performance testing.
• Identify common application, database, server, network, and API performance issues using observability signals.
• Understand distributed tracing and how it helps analyze microservices and API flows.
• Use logs and traces to validate defects, failed transactions, and system errors.
• Support performance testing by monitoring application and infrastructure behavior.
• Understand basic alerting, service-level indicators, and service-level objectives.
• Prepare test observations and evidence using APM and observability tools.
• Collaborate more effectively with developers, DevOps, SRE, and operations teams.

 

Target Audience

 

• Software testers
• QA analysts
• QA engineers
• Performance testers
• Test automation engineers
• API testers
• Manual testers transitioning to technical testing
• Test leads and test managers
• Application support analysts
• DevOps engineers involved in quality validation
• Site reliability engineers working with testing teams
• Developers supporting performance and defect investigation
• IT operations and production support teams
• Organizations improving testing quality through monitoring and observability

 

 

Prerequisites

 

• Basic understanding of software testing concepts
• Basic knowledge of web applications, APIs, or enterprise systems
• Familiarity with defect reporting and test execution
• Basic awareness of performance testing is helpful but not required
• Basic knowledge of logs or monitoring tools is helpful but not required
• No advanced programming or observability experience is required

 

Course Outline

 

Day 1: APM and Observability Fundamentals for Testers

 

Module 1: Introduction to APM and Observability

• What is Application Performance Monitoring?
• What is observability?
• Monitoring versus observability
• APM versus logging versus tracing
• Why observability matters for testers
• Observability in SDLC, Agile, DevOps, and production support
• How testers use observability for quality validation

 

Module 2: Core Observability Signals

• Logs
• Metrics
• Traces
• Events
• Alerts
• Dashboards
• Telemetry data
• Relationship between logs, metrics, and traces
• Using observability signals during testing

 

Module 3: Key Performance and Reliability Metrics

• Response time
• Latency
• Throughput
• Transactions per second
• Requests per second
• Error rate
• Availability
• Apdex overview
• CPU, memory, disk, and network utilization
• Database response time
• API response time
• Queue and dependency delays

 

 

Module 4: Role of Testers in Observability

• Observability during functional testing
• Observability during regression testing
• Observability during API testing
• Observability during performance testing
• Observability during user acceptance testing
• Observability during production validation
• Capturing monitoring evidence for defects
• Communicating findings to development and operations teams

 

Module 5: Overview of Common APM and Observability Tools

• Azure Application Insights overview
• Grafana overview
• Prometheus overview
• Datadog overview
• New Relic overview
• Dynatrace overview
• Splunk overview
• Elastic/Kibana overview
• OpenTelemetry overview
• Choosing the right tool based on testing needs

 

Day 2: Logs, Metrics, Traces, Dashboards, and Test Investigation

 

Module 6: Log Analysis for Testers

• What are application logs?
• Types of logs: application, server, API, database, security, and system logs
• Log levels: info, warning, error, debug, critical
• Searching and filtering logs
• Identifying errors and exceptions
• Correlating logs with test cases
• Capturing log evidence for defect reports
• Common log analysis mistakes

 

Module 7: Metrics and Dashboard Interpretation

• Understanding metric dashboards
• Application health dashboards
• Infrastructure dashboards
• API performance dashboards
• Database monitoring dashboards
• Performance test monitoring dashboards
• Reading trends and spikes
• Identifying abnormal behavior
• Comparing baseline versus test results

 

Module 8: Distributed Tracing Fundamentals

• What is distributed tracing?
• Why tracing is important for microservices and APIs
• Trace, span, and transaction concepts
• Request flow across services
• Identifying slow service calls
• Identifying failed dependencies
• Understanding service maps
• Using traces for defect investigation

 

Module 9: Error Analysis and Root Cause Investigation

• Identifying application errors
• Understanding error patterns
• Correlating errors with test actions
• Investigating slow transactions
• Identifying failed API calls
• Finding database-related issues
• Finding third-party dependency issues
• Distinguishing application defects from environment issues
• Preparing evidence-based defect reports

 

Module 10: Observability for API and Microservices Testing

• API monitoring concepts
• API latency and response time tracking
• HTTP status code analysis
• Dependency monitoring
• Service-to-service communication
• Timeout and retry behavior
• Microservices testing challenges
• Using traces to validate API workflows
• Observability checklist for API testing

 

 Day 3: Performance Testing, Alerting, Reporting, and Practical Workshop

 

Module 11: Observability in Performance Testing

• Role of observability in performance testing
• Monitoring during load testing
• Monitoring during stress testing
• Monitoring during spike testing
• Monitoring during endurance testing
• Correlating performance test results with system metrics
• Identifying bottlenecks using APM tools
• Application, database, network, and infrastructure monitoring
• Common performance bottleneck indicators

 

Module 12: Alerts, SLIs, SLOs, and Quality Gates

• Alerting fundamentals
• Alert thresholds
• Warning versus critical alerts
• Service-level indicators
• Service-level objectives
• Service-level agreements overview
• Quality gates using observability data
• Defining pass/fail criteria using monitoring metrics
• Avoiding alert fatigue

 

Module 13: Observability in CI/CD and Test Automation

• Observability in continuous testing
• Monitoring automated test environments
• Capturing logs from automated test runs
• Integrating observability with CI/CD pipelines
• Using monitoring data in release validation
• Smoke testing and post-deployment validation
• Regression monitoring
• Production readiness checks

 

Module 14: Defect Reporting Using Observability Evidence

• What monitoring evidence to include in defect reports
• Screenshots from dashboards
• Relevant logs and timestamps
• Trace IDs and transaction IDs
• Error messages and stack traces
• Affected service or component
• Steps to reproduce with observability evidence
• Severity and impact assessment
• Communicating technical findings clearly

 

Module 15: Best Practices for Testers

• Start monitoring early in the test cycle
• Align test cases with observable transactions
• Capture baseline metrics
• Use consistent timestamps
• Validate test environment health before execution
• Coordinate with developers and operations teams
• Avoid relying on only one signal
• Use dashboards during critical test runs
• Document observations clearly
• Convert observability findings into actionable defects

 

Module 16: Practical Workshop

• Review a sample application monitoring dashboard
• Identify key metrics for testing
• Analyze logs from a failed test scenario
• Review traces for a slow transaction
• Identify possible bottlenecks
• Correlate test execution results with monitoring data
• Prepare an evidence-based defect report
• Define a basic observability checklist for testers
• Create a sample production readiness monitoring checklist
• Present findings and recommendations