k6 Performance Testing
Answer real performance questions with k6 against a synthetic local shop: scripts with tags and checks, ramping scenarios, percentile thresholds that set the exit code, a deliberate 400 ms slowdown that fails the run, result analysis, CI gates and responsible testing. Complete loopback source; website checkpoints check notes, not k6 runs. A practical path from a performance question to k6 thresholds that fail when the system slows down.
- 24
- Lessons
- 8
- Sections
- 8
- Practice labs
- ~12h
- Of content
Sign in to save progress and earn a verified achievement.
1thresholds: {2 http_req_failed: ["rate<0.01"]3 "http_req_duration{name:products}": ["p(95)<200"]4 checks: ["rate>0.99"]5}6
The method
Built like real QA work, not a video playlist.
Learn
24 focused lessons, each a few minutes long.
Practice
8 hands-on labs in a browser workspace.
Test yourself
8 section assessments plus a final exam.
Prove it
A public, verifiable achievement for recruiters.
What you will learn
- Performance testing foundations: Define what a performance test must answer, Reconstruct the local reference, Read the metrics that matter
- Writing k6 scripts: Write requests with tags and groups, Use checks to assert responses, Parameterise data and think time
- Load models and scenarios: Model load with scenarios and executors, Choose between load, stress, spike and soak, Establish a baseline before comparing
- Thresholds and pass rules: Turn requirements into thresholds, Stop runs early when things go wrong, Prove thresholds can fail
- Results, analysis and bottlenecks: Analyse results without overclaiming, Export results for dashboards, Correlate client results with server metrics
- k6 in CI and realistic journeys: Run a small k6 gate in CI, Handle login and tokens safely, Know when to add browser timing
Where you will be at the end
- Complete 8 hands-on practice challenges, one per section (from Performance testing foundations to Mutation, retest and portfolio)
- Pass 8 section assessments
- Pass the k6 Performance Testing final assessment and add the result to your Skill Passport
Who this course is for
- Beginners and manual testers starting this skill from scratch
- Working testers who want to apply it on real projects
- Anyone preparing for QA interviews that ask about this skill
- Best if you already have: Basic JavaScript and HTTP; Node 22+ and k6 installed; terminal familiarity
Curriculum
9 sections, one clear path.
- Define what a performance test must answer
- Knowledge check
- Reconstruct the local reference
- Knowledge check
- Read the metrics that matter
- Knowledge check
- Contract evidence: Performance testing foundations
- Section assessment
Members-only toolkit
Take the course with you
Made from this course's own lessons, quizzes and labs — ready to revise before interviews or use at work.
Course cheat sheet
Loading…
Interview Q&A pack
Loading…
Lab solutions & hints
Loading…
- Auto-checked labs
- Capstone portfolio project
- Timed final exam
Why paid courses
More than a free course: practice, proof and a portfolio
| What you get | Free | Academy |
|---|---|---|
| Short lessons with examples | ||
| Quick checks and certificate | ||
| Hands-on labs checked automatically | ||
| Section tests and a timed final exam | ||
| Portfolio capstone project with milestones | ||
| Cheat sheet, interview pack and lab answers to download | ||
| Verified skills on your profile and Skill Passport |
What Students Are Saying
Sign in and complete 20% of the course to leave a review.
Share your experience on Trustpilot (optional)
Honest feedback is welcome, whatever your experience. A Trustpilot review is not required for your certificate.
k6 Performance Testing: common questions
1.Do I need experience before starting k6 Performance Testing?
2.What can I try for free, and what needs payment?
3.How long does the course take?
4.What do I get when I finish?
Finish with proof, not just a certificate PDF.
Pass the final assessment and get a public verification page showing your score, completion date and the skills you demonstrated — ready to share on LinkedIn.
About this k6 Performance Testing course
Performance problems usually reach users before they reach a test report, because the team never agreed what fast enough meant. This course starts with that agreement. A small synthetic shop runs on your own machine with a product list and an add-to-cart endpoint, and every lesson works towards one clear question: can the browse-and-add journey keep 95 percent of product requests under 200 milliseconds with five concurrent users and under one percent errors? Twenty-four lessons in eight sections take that question from a written pass rule to a k6 script, a load model, thresholds, analysis, CI and a report. Eight written checkpoints and eight assessments use the existing Academy format.
Early sections cover what a performance test can and cannot tell you, how to reconstruct the local reference, and which metrics matter. You learn why percentiles beat averages, how http_req_failed differs from your own checks, and why numbers from a laptop describe that laptop rather than production capacity. Script lessons cover tagged requests, groups, checks that confirm a fast response is also a correct one, think time and parameterised synthetic data.
Load-model lessons compare ramping virtual users with constant arrival rate, separate load, stress, spike and soak tests, and show how to build a three-run baseline before comparing builds. Threshold lessons turn the agreed rule into four k6 thresholds that decide the exit code, add early abort conditions and a setup check that the target is up. Analysis lessons pair k6 symptoms with server metrics, export raw results and write findings as hypotheses until a rerun confirms them.
The complete source-map lesson contains server.mjs, load.js and a README. We ran this exact project with k6 v2.0.0 and Node 22 before publishing: the normal run passed all four thresholds with a product p95 of about 1.6 milliseconds on our machine and exited with code 0. Restarting the server with SLOW=1 added a 400 millisecond delay; both p95 thresholds failed at about 402 milliseconds and k6 exited with code 99. Your own numbers will differ, and the course never presents them as production results.
Later sections cover CI gates, safe handling of tokens, when browser timing is worth its cost, performance reports, actionable defects and responsible testing: written permission, agreed windows, stop conditions and no real personal data. The final portfolio contains the question, script, passing run, failing slowdown run, restored retest and a one-page report. Website checkpoints validate a completed written note and do not generate load. The certificate records Academy completion, not an official k6 or Grafana certification.
Who this course is for
- Manual and automation testers starting performance testing
- JMeter users moving to code-based load tests
- QA engineers who need honest performance pass rules in CI
What you need
- Basic JavaScript and HTTP
- Node 22+ and k6 installed
- Terminal familiarity
What you will be able to do
- Turn a performance requirement into k6 thresholds
- Write k6 scripts with tags, checks, scenarios and think time
- Read percentiles, errors and throughput without overclaiming
- Prove thresholds fail on a deliberate slowdown and report the result
