
Transform tool users into performance engineers by teaching the why behind tests and metrics, with hands-on practice in JMeter that teaches universal concepts, not tool-specific tricks.
Nagraj introduces non-functional testing as a specialized field, outlines a career path from tester to engineer to architect, and explains how agile and DevOps drive multi-skilled performance testing.
Performance testing and engineering will have tremendous scope in the near future as exponential online activity drives demand for fast, scalable, reliable IT systems, including cloud and serverless environments.
Meet Nagraj, a senior performance test engineer with 10+ years in performance testing and engineering across on-premises and AWS cloud, specializing in microservices and tools like JMeter and Dynatrace.
Performance testing demonstrates why it matters and the problems it solves, using virtual users to simulate load, measure performance, and plan resources for scalable, reliable apps.
Master core performance testing and engineering concepts from planning to closure, explore life cycle phases with templates for test plans and reports, and apply JMeter basics for scalable projects.
Explore the difference between functional and non-functional testing, then dive into core performance testing and performance engineering concepts, including load handling, concurrency, and CI/CD integration.
Define performance engineering as building software with non-functional attributes—speed, throughput, scalability, reliability, and availability—considered throughout the software development life cycle, while performance testing validates these requirements before deployment.
You will Learn below topics in this Lecture
1. Virtual Users
2. Response Time
3. 90th and 95th response Time Percentiles
4. Throughput
5. Peak Load
You will Learn below topics in this Lecture
1. Concurrent Users
2. Bottleneck
3. Correlation
4. Parameterization
5. Assertion
6. Think Time
7. Pacing
Master performance testing by understanding the full tech stack across operating system, network, disk, web, app, and database layers, and anticipate unknown unknowns that affect performance.
Learn the five-phase performance testing life cycle, with phase one test planning, documenting the application under test scope, tasks, and non-functional requirements, and conducting a signed-off stakeholder walkthrough.
Master phase two test preparation tasks—licensing, open source options, firewall setup, and data masking—then phase three load scripts, mocks, test data, workload models, and best practices for scripts.
Execute tests, analyze results, and tune performance to meet the peak load through warmup, baseline, endurance, scalability, stress, and resilience tests, with thorough documentation for closure.
Learn to download and set up Apache JMeter on Windows, launch the JMeter UI, and install custom plugins via the plugin manager to access advanced thread groups and graphs.
Nagraj demonstrates building a geometer script to test microservices secured by an API gateway, generating a security token and calling view and update account APIs.
Learn to build a JMeter rest api test script, configure a http sampler with token retrieval, headers, and query params, then extract the access token with a regex extractor.
Develop JMeter REST API scripts to test view account details and update account details, including token generation, correlation, and header management.
Parameterize api requests by reading data from an external csv file with csv data set config. Replace hard-coded values with dynamic account ids and verify responses show status equals success.
Learn to script REST API tests with JMeter by adding delays, parallelizing requests, applying throughput timers, and using Little's law to estimate required threads.
Compare monolithic and microservice architectures to understand scalability, independent deployment, and targeted testing, then learn how microservices improve resource utilization and rapid feature delivery.
Analyze performance testing of microservices by testing each service individually with mocks and service virtualization, then validate auto scaling and high availability.
Create an ECS cluster with the EC2 launch type, define a task definition, and deploy a service behind an application load balancer with security groups, port mappings, and health checks.
This lecture demonstrates scalability testing of a NodeJS microservice on AWS ECS using JMeter, evaluating view and update account details APIs at 30 tps with 95th percentile targets.
analyze scalability test results and changes to track improvements, plan a higher load toward 100 tps, and confirm 24 tps with sla-compliant response times.
Analyze the scalability results, showing 95th percentile response time under SLA and low error rate; conclude one ECS task handles 100 TPS and plan a two-task load at 60 TPS.
Configure autoscaling alarms at the ECS service level using CPU thresholds of 300% for scale up and 120% for scale down (40 percent of scale up), with a 30-second cooldown.
Configure auto scaling alarms at the ecs cluster level to automatically add or remove ec2 instances based on cpu and memory utilization, with min/max capacity and thresholds.
Explore a case study of batch file processing on AWS lambda, detailing data pull, validation, processing, and file generation for vendor delivery, and performance testing of 15,000 records per batch.
Explore a data processing case study where AWS Lambda consumes Kinesis events, tuning shards, concurrent batches per shard, and reserved concurrency to meet 20 TPS with minimal iterator age.
Explains why performance testing matters for cloud-hosted apps, outlining the shared responsibility model and auto-scaling metrics, with practical guidance for Easiest, Lambda, Kinases, and Dynamo DB.
Compare a performance tester with a performance engineer, and explore how load testing and cloud-based autoscaling shape performance. Learn about LoadRunner, JMeter, and monitoring tools.
Why Most Performance Testers Fail When It Really Matters ??
(Discover the performance engineering secrets that 14 years of preventing system crashes taught me – beyond what any tool-focused courses will tell you)
Ever watched an app crash during a Black Friday sale?
That's what happens when software performance testing goes wrong. Or worse – when it never happened at all.
But here's the problem: most performance testers today are just "tool jockeys" – they know which buttons to click in JMeter or LoadRunner, but they're lost when real performance challenges strike. And that's exactly why companies are desperately seeking true Performance Engineers.
After 14 years of preventing digital disasters at major corporations, I discovered something shocking: 90% of performance testing courses out there are teaching it backward. They jump straight to tools without building the foundation that actually matters.
Think about it: would you trust a doctor who only knows how to use medical equipment but doesn't understand human anatomy?
That's why I created "Software Performance Testing and Engineering" course that transforms tool users into Performance Engineers.
Here's what makes this course different:
Instead of just teaching you how to write test scripts, you'll learn to think like a Performance Engineer. You'll understand the "why" behind every test, every metric, and every decision. This isn't about memorizing steps in JMeter – it's about developing an engineering mindset that works with any tool, any project, any scale.
Imagine walking into your next meeting and confidently explaining exactly why the system will (or won't) handle next month's product launch. Imagine being the person who prevents crashes before they happen, who can prove exactly how many users your system can handle, who knows precisely where to look when things go wrong.
This course is your blueprint for becoming that person.
You'll learn:
- The core principles that apply to every performance testing scenario (even ones that haven't been invented yet).
- How to design tests that reveal real problems (not just nice-looking reports).
- The exact methodology I've used to architect reliable systems for 14 years.
- Hands-on practice with JMeter that teaches you universal concepts, not just tool-specific tricks.
This course is perfect for you if you're:
- A developer who wants to build systems that actually scale.
- A QA engineer ready to move beyond basic functional testing.
- A DevOps professional who needs to prevent performance problems, not just react to them.
- An IT professional who wants to specialize in one of tech's highest-paying skills.
But I should warn you: if you're looking for a quick "certificate mill" course that just teaches button-clicking, this isn't for you. This is for professionals who want to master the art and science of performance engineering.
Ready to become the Performance Expert your team needs?
'Enroll Now' to begin your transformation from just a tool user to Performance Engineer.
There are many tools in the market to do Software Performance Testing but before you learn any of the tools mentioned below, you must learn the core performance testing & Engineering principles thought in this course first.
1. Apache JMeter: An open-source tool that can be used for performance testing and load testing. It supports various protocols like HTTP, JDBC, LDAP, and more.
2. LoadRunner: Developed by Micro Focus, LoadRunner is a widely used performance testing tool. It supports a variety of protocols and provides a comprehensive set of features for performance testing.
3. Gatling: An open-source tool that is designed for load testing. It is written in Scala and supports protocols like HTTP, WebSockets, and more.
4. Locust: An open-source, Python-based tool for load testing. It allows you to define user behavior using code and supports distributed testing.
5. BlazeMeter: A cloud-based performance testing platform that integrates with various open-source tools like Apache JMeter and Selenium. It provides real-time reporting and analysis.
6. Neoload: A performance testing tool that supports web and mobile applications. It offers features like dynamic infrastructure scaling and integration with CI/CD tools.
7. K6 by Grafana Labs - Modern open-source load testing tool designed for testing the performance of APIs, microservices, and websites.