Performance / Load
Competent user of ONE tool (k6) with a CI gate + results literacy. SHOULD-level differentiator, not a MUST gate. STOP before LoadRunner, JVM tuning, capacity modelling.
- Test types: load, stress, soak/endurance, spike, scalability
Define each type and state when you would run it and what it catches.
'Load vs stress vs soak vs spike - define each and when you'd run it.' (asked almost every perf interview)
- Load testing vs performance testing (subset vs umbrella)
Articulate that load testing is one type under the performance-testing umbrella (which also covers scalability, stability, resource use).
'How is load testing different from performance testing?'
- Non-functional / reliability / scalability testing framing
Place performance inside the non-functional testing family (perf, reliability, scalability, resilience) and say what quality attribute each protects.
'What non-functional testing have you done?' / 'How do you treat performance as a quality attribute?'
- Latency percentiles p50/p95/p99 + why over average
Report and reason about tail latency, explaining why percentiles beat the mean.
'Why report p95/p99 instead of average response time?' (the classic filter question)
- Throughput (RPS / requests-per-second)
Define throughput and read the RPS the system sustains before it plateaus.
'What metrics do you track in a perf test?' / 'What's a good throughput target and how do you set it?'
- Error rate under load
Track the fraction of failed requests and distinguish 'slow' from 'failing' as load rises.
'What metrics do you track?' / 'A test shows errors climbing at 500 VUs - what does that tell you?'
- Secondary/system metrics: concurrent VUs, CPU/mem/disk-I/O, connection-pool usage
Name the server-side resource metrics you'd watch alongside client-side latency/throughput.
'What server metrics do you watch during a load test?'
- k6 as primary tool (install, run, VU model, JS/TS)
Install k6, write and run a .js/.ts load test locally, and explain the VU (virtual user) execution model.
'Walk me through how you'd load-test an API endpoint.' / 'Which tool have you used and why?'
- JMeter literacy (read a .jmx, know the GUI + thread-group model)
Recognize a JMeter test plan, its thread-group/sampler/listener structure, and know it's the legacy incumbent.
'Have you used JMeter?' / 'Our team is on JMeter - can you work with it?'
- Locust awareness (Python load-testing option)
Know Locust is the Python-native alternative and when a Python-first team would prefer it.
'Any experience with Locust?' / 'Why k6 over Locust?'
- Tool concurrency models (k6 goroutines-per-VU, JMeter thread-per-VU, Locust greenlets)
Explain how each tool generates load and why VU != thread != request.
'How does your tool generate concurrency?' / 'How many users can you drive from one machine?'
- HTTP requests + check() assertions
Fire HTTP calls and assert on status and response time inside the script.
part of 'walk me through a load-test script'
- Load stages / ramp profiles (ramp-up, steady, ramp-down)
Shape load over time with staged VU targets.
'How do you shape the load in a test?' / 'What's your ramp profile?'
- VU model vs arrival-rate model (constant-arrival-rate executor)
Distinguish 'N concurrent users' (VU/ramping) from 'N requests/sec' (open-model arrival rate).
'Do you test by concurrent users or by request rate? When each?'
- Parameterization / test data (SharedArray, CSV/JSON, unique users, env vars)
Feed distinct data per VU/iteration so you don't hammer one cached record.
'How do you avoid testing against a single cached record?' / 'How do you handle test data at load?'
- Think-time / pacing (sleep, group)
Insert realistic pauses and logically group requests so load models real users.
'How do you make load realistic?'
- Thresholds as SLOs (p95<500ms, error-rate<1%, checks>98%)
Encode pass/fail SLO criteria directly in the test so a breach = failed test.
'How do you set pass/fail on a perf test?' / 'What SLO would you set and why?'
- Baseline + trend / performance regression detection
Keep a baseline and compare each run to prove or catch a regression.
'How do you catch a perf regression before prod?'
- Perf regression gate in CI (non-zero exit, GitHub Actions job, results artifact)
Wire the load test into CI so a threshold breach fails the build and results are published.
'How do you put a performance test in CI without making it flaky?' - THE differentiating answer
- Bottleneck diagnosis (slow/unindexed queries, N+1, CPU/mem/disk saturation, pool exhaustion, network, memory leaks)
Given a latency spike under load, reason through where the bottleneck lives (app vs DB vs network) and name the usual culprits.
'p95 latency spikes under load - how do you find the bottleneck?' / 'What causes performance bottlenecks?'
- Read a results summary (p95/p99 tail, RPS plateau, error-onset knee)
Interpret the end-of-run summary to locate the tail, the throughput ceiling, and where failures begin.
'You ran the test - what do you look at in the results?'
- APM correlation (Grafana / New Relic / Dynatrace / AppDynamics basics)
Know the role APM plays: the load tool tells you WHAT slowed, APM tells you WHY.
'How do you correlate a load-test result with server behaviour?'
- Real-time / low-latency + gRPC / WebSocket load testing
Know k6 natively load-tests gRPC and WebSocket and what changes for low-latency real-time services.
'Have you load-tested non-HTTP / real-time services?'
- Distributed / cloud-run load + at-scale benchmarking (Grafana Cloud k6, multi-node)
Know that distributed/cloud load-gen exists and when you'd need it (beyond one machine / multi-region).
'How would you generate load beyond one machine?' (only in scale-heavy roles)
- Modern k6 positioning (k6 v2.0 May-2026: TS default, AI-assisted workflows, browser/Playwright compat, Assertions API)
Be current on what the modern tool offers, to pair perf with his 'modern stack / AI testing' narrative.
'Why did you pick k6?' / signalling you track the modern tooling
- LLM / AI endpoint load testing (time-to-first-token, tokens/sec, variable-length + streaming responses, cost-per-request)
Load-test token-streaming LLM APIs and reason about metrics that differ from normal REST.
'How would you performance-test an AI/LLM feature?' - a talking point almost no competing SDET can give
- LoadRunner / NeoLoad enterprise suites (controller/load-gen topology, licensing)
Recognize the names as enterprise/legacy tools; do NOT invest.
'Do you know LoadRunner?' (answer: know it exists, not your tool)
- JMeter deep internals (JSR223/Groovy/BeanShell samplers, distributed clustering, Java/Kotlin DSL)
Know these exist but don't author them; read-level JMeter is enough.
rarely; only in JMeter-heavy shops
- JVM/GC tuning, heap/thread-dump forensics, kernel/TCP/sysctl tuning
Perf-engineer/SRE territory - out of scope for SDET-2.
not asked of an SDET-2
- Capacity planning / performance modelling / queuing theory (Little's Law)
Know the concept exists; don't do the math.
not asked of an SDET-2
- Protocol-level testing (JDBC / JMS / LDAP / MQTT / FTP / SMTP)
JMeter's multi-protocol niche - irrelevant for an API/Python SDET.
not asked in his target roles
- Driving 100k+ concurrent VUs / multi-region distributed load farms
Extreme-scale load-gen ops; a single-tool user doesn't own this.
not asked of an SDET-2