Build practical software performance testing skills with Performance Testing Fundamentals Using Apache JMeter Training, a hands-on course designed for QA professionals, software testers, developers, and IT teams who want to evaluate and improve the performance, scalability, and reliability of applications.

Performance Testing Fundamentals Using Apache JMeter Overview

This four-day, hands-on training course equips QA testing professionals with the foundational knowledge and practical skills required to plan, design, execute, monitor, and analyze basic performance tests using Apache JMeter.

Participants will learn the different types of performance testing, including baseline, load, stress, spike, endurance, volume, scalability, and capacity testing. They will understand when each test type should be used and how it supports performance-risk assessment and system-readiness decisions.

Using standard training applications and sample APIs, participants will build JMeter test plans, create realistic workloads, apply parameterization and correlation, execute controlled tests, and analyze key performance indicators such as response time, throughput, latency, error rate, and percentile results.

The course emphasizes team-based exercises and practical scenarios suitable for a single QA testing team. By the end of the training, participants should be able to conduct basic performance testing independently, interpret JMeter reports, identify potential performance problems, and communicate findings to developers, technical teams, and business stakeholders.

 

Duration 4 Days – 28 hrs.

 

Objectives 

• Explain the purpose and business value of performance testing.
• Differentiate functional testing from performance testing.
• Identify the appropriate type of performance test for a given objective.
• Explain baseline, load, stress, spike, endurance, volume, scalability, and capacity testing.
• Identify performance requirements and measurable acceptance criteria.
• Understand workload models, user journeys, concurrency, pacing, and transaction volume.
• Install and configure Apache JMeter.
• Navigate the JMeter interface and understand its major components.
• Create and organize basic JMeter test plans.
• Record or manually create HTTP and HTTPS test scripts.
• Test standard web applications and REST APIs.
• Use thread groups, samplers, controllers, timers, assertions, and listeners.
• Parameterize test data using external files.
• Apply basic correlation to handle dynamic data.
• Add validation and error checking to test scripts.
• Configure realistic user loads, ramp-up periods, loops, and test durations.
• Execute performance tests safely and systematically.
• Monitor test execution and identify scripting or application errors.
• Generate and interpret JMeter reports.
• Analyze response time, throughput, latency, error rate, percentiles, and transaction results.
• Differentiate application problems from test-script or load-generator limitations.
• Identify basic performance bottlenecks and areas requiring further investigation.
• Document test results, observations, risks, and recommendations.
• Perform an end-to-end basic performance-testing exercise as a QA team.

 

Target Audience 

• Manual QA testers
• Software test engineers
• QA analysts
• Junior performance testers
• Test automation engineers
• Quality engineers
• Software developers involved in performance validation
• Technical support and application support personnel
• QA team leads
• Test leads and test coordinators
• Professionals transitioning into performance testing

 

Prerequisites 

• Basic knowledge of software testing concepts.
• Familiarity with test cases, test scenarios, defects, and expected results.
• Basic understanding of web applications and client-server systems.
• Basic knowledge of HTTP methods such as GET, POST, PUT, and DELETE is recommended.
• Basic familiarity with APIs, JSON, HTML, or browser developer tools is helpful but not mandatory.
• Basic spreadsheet skills for reviewing and organizing test results.
• A laptop with administrator rights or preinstalled training software.
• Reliable internet or network access to the designated training applications.
• No previous JMeter or programming experience is required.

 

Technical Requirements:

Each participant should have:

• Apache JMeter installed
• A compatible Java runtime
• A supported web browser
• Text editor or development editor
• Spreadsheet application
• Access to the standard training web application
• Access to sample REST API endpoints
• Permission to access the designated training environment
• Sufficient local processing power and memory for basic test execution

All exercises must be conducted only against authorized training applications and environments. Participants should not run load tests against production systems or public websites without formal permission.

 

Course Outline 

Day 1: Performance-Testing Fundamentals and JMeter Essentials

Module 1: Introduction to Performance Testing 

• What is performance testing?
• Purpose and business value
• Functional versus performance testing
• Performance testing within the software-development lifecycle
• Shift-left performance testing
• Roles and responsibilities
• Common performance risks
• Performance-testing limitations
• Testing in development, test, staging, and production-like environments
• Importance of authorization and test-environment protection

 Module 2: Types of Performance Testing 

• Baseline testing
• Load testing
• Stress testing
• Spike testing
• Endurance or soak testing
• Volume testing
• Scalability testing
• Capacity testing
• Failover and resilience testing overview
• Selecting the appropriate test type
• Combining different test types in a testing strategy

 Module 3: Performance Requirements and Metrics 

• Business and technical requirements
• Service-level agreements
• Service-level objectives
• Performance acceptance criteria
• Response time
• Latency
• Throughput
• Transactions per second
• Requests per second
• Concurrent and active users
• Error rate
• Availability
• Average versus median
• Percentiles: P90, P95, and P99
• Resource-utilization overview
• Establishing baselines and targets

 Module 4: Introduction to Apache JMeter 

• Apache JMeter capabilities and limitations
• JMeter architecture
• Installing and launching JMeter
• Understanding the graphical user interface
• Test Plan and WorkBench concepts
• Thread groups
• Samplers
• Logic controllers
• Configuration elements
• Timers
• Assertions
• Pre-processors and post-processors
• Listeners
• Saving and organizing test plans

Hands-on Exercises

• Install or validate the JMeter environment.
• Explore the JMeter interface.
• Create the first HTTP test plan.
• Send requests to a standard training application.
• Add basic assertions and listeners.
• Review initial response-time and error results.

 

Day 2: JMeter Test-Script Development

Module 5: Creating Web and API Test Scripts 

• Understanding HTTP requests and responses
• HTTP request methods
• Request headers and content types
• Query parameters
• Form data
• Request bodies
• Cookies and sessions
• Testing REST APIs
• Working with JSON responses
• Organizing requests into business transactions
• Recording versus manually creating scripts

 Module 6: Building Maintainable Test Plans 

• Naming conventions
• Test-plan structure
• Test fragments
• Reusable components
• HTTP Request Defaults
• HTTP Header Manager
• Cookie Manager
• Cache Manager
• User-defined variables
• Transaction Controller
• Simple, Loop, If, and While Controllers
• Separating scripts, data, and configuration
• Test-script documentation

 Module 7: Parameterization and Test Data 

• Why parameterization is required
• Static versus dynamic data
• Using CSV Data Set Config
• Creating test-data files
• Unique and reusable test data
• Sharing and recycling data
• Data exhaustion
• Managing accounts and credentials
• Protecting sensitive test information

 Module 8: Correlation and Dynamic Values 

• Understanding correlation
• Identifying dynamic values
• Extracting data from responses
• Regular Expression Extractor
• JSON Extractor
• Boundary Extractor
• Reusing extracted values
• Session and authentication tokens
• Debugging extracted variables
• Basic correlation troubleshooting

Hands-on Exercises

• Create a multi-step user journey.
• Submit data to a training web application.
• Build a basic API test.
• Parameterize users and business data.
• Extract and reuse a dynamic value.
• Add transaction names and response assertions.
• Validate the complete script before applying load.

 

Day 3: Workload Modelling and Test Execution

Module 9: Workload Modelling 

• Understanding production usage
• Identifying critical business transactions
• User profiles and workload distribution
• Concurrent versus total users
• Transactions per hour
• Think time and pacing
• Ramp-up and ramp-down
• Iterations and duration
• Peak and normal workloads
• Open and closed workload concepts
• Creating a basic workload model
• Assumptions and limitations

 Module 10: Configuring Load Scenarios in JMeter 

• Thread Group settings
• Number of users or threads
• Ramp-up period
• Loop count
• Duration and scheduling
• Timers and realistic user behaviour
• Transaction distribution
• Test-data allocation
• Assertions under load
• Handling time-outs
• Configuring controlled test scenarios

 Module 11: Executing Performance Tests 

• Script validation before testing
• Smoke and shakedown tests
• Baseline testing
• Gradual load increases
• Load-test execution
• Stress-test execution
• Spike-test demonstration
• Endurance-test planning
• Running JMeter in GUI mode for scripting
• Running JMeter in non-GUI mode for load execution
• Command-line execution
• Saving test results
• Stopping a test safely
• Monitoring errors during execution

 Module 12: Test Environment and Monitoring Fundamentals 

• Test-environment readiness
• Production-like environment considerations
• Network and data dependencies
• Load-generator resources
• Server-side monitoring overview
• CPU, memory, disk, and network indicators
• Application and database monitoring overview
• Coordinating with developers, infrastructure teams, and database administrators
• Distinguishing application issues from test-tool limitations
• Avoiding misleading test results

Hands-on Exercises

• Create a basic workload model.
• Configure users, ramp-up, duration, and pacing.
• Execute a script-validation test.
• Run baseline and controlled load tests.
• Execute JMeter in non-GUI mode.
• Capture results and test observations.
• Compare results from different workload levels.

 

Day 4: Results Analysis, Reporting, and Practical Assessment

Module 13: Understanding JMeter Results 

• Sample and transaction results
• Response time
• Connect time
• Latency
• Throughput
• Error percentage
• Data received and sent
• Active threads
• Average, minimum, and maximum results
• Median and percentile results
• Interpreting P90, P95, and P99
• Understanding outliers
• Reading JMeter listeners
• Generating the HTML Dashboard Report

 Module 14: Performance Analysis 

• Comparing results with acceptance criteria
• Baseline versus load results
• Identifying performance degradation
• Recognizing saturation points
• Response-time trends
• Throughput trends
• Error patterns
• Correlating client-side and server-side results
• Identifying possible application, database, infrastructure, or network bottlenecks
• Recognizing script and load-generator problems
• Avoiding incorrect conclusions
• Determining when additional investigation is required

 Module 15: Performance-Test Reporting 

• Components of a performance-test report
• Test objectives and scope
• Environment and application details
• Workload model
• Test data and assumptions
• Results and observations
• Graphs and tables
• Acceptance-criteria evaluation
• Defects and risks
• Bottleneck findings
• Limitations
• Recommendations
• Executive versus technical reporting
• Presenting results to stakeholders

 Module 16: Basic Performance-Testing Workflow 

• Requirements gathering
• Test planning
• Environment preparation
• Script development
• Script validation
• Workload modelling
• Test execution
• Monitoring
• Results analysis
• Defect reporting
• Retesting
• Final reporting and sign-off
• Maintaining reusable JMeter assets

 Final Team-Based Practical Assessment 

• Review a sample application scenario.
• Identify the appropriate performance-test type.
• Define basic performance objectives and acceptance criteria.
• Select critical business transactions.
• Develop a JMeter test plan.
• Add parameterization, correlation, timers, and assertions.
• Create a basic workload model.
• Execute baseline and load tests.
• Generate a JMeter HTML report.
• Analyze response time, throughput, percentiles, and errors.
• Identify potential performance concerns.
• Prepare and present a concise performance-test report.