What is performance testing?

Question

Accepted Answer

**Performance testing** evaluates how a system performs under load — measuring **speed, scalability, and stability** under various conditions. Types include load, stress, spike, and soak testing. It's essential for ensuring systems handle real-world (and peak) usage acceptably.

## What performance testing measures

```text
Non-functional testing of HOW WELL the system performs (not just correctness):
  → RESPONSE TIME / latency (how fast?), THROUGHPUT (requests/sec handled)
  → SCALABILITY (behavior as load grows), RESOURCE usage (CPU, memory)
  → STABILITY under sustained or extreme load
→ ensures the system meets performance requirements and handles real usage.
```

## Types of performance tests

```text
LOAD testing → expected/normal load → does it meet targets under typical usage?
STRESS testing → BEYOND normal limits → find the breaking point; how it fails/recovers
SPIKE testing → sudden sharp load increase → handles bursts? (e.g. a flash sale)
SOAK / endurance → sustained load over a LONG time → finds memory leaks, degradation
SCALABILITY → how performance changes as load/resources scale
```

## How and why

```text
✓ Tools: k6, JMeter, Gatling, Locust → simulate many virtual users / high request rates
✓ Define performance REQUIREMENTS/SLAs (e.g. p95 latency < 200ms at X users) → test against them
✓ Test realistic scenarios; measure under controlled conditions; find BOTTLENECKS
✓ WHY: poor performance → bad UX, lost users/revenue, outages under load; find issues
  BEFORE production (e.g. before a big launch/traffic event)
```

## Why it matters

Understanding performance testing is valuable senior-level knowledge because **performance is a critical quality attribute** — systems must handle real-world and peak load acceptably — so testing it is important for reliability and user experience, making this useful knowledge.

Performance testing evaluates **how well a system performs** (response time, throughput, scalability, resource usage, stability) under load — a non-functional quality distinct from correctness, but critical because poor performance causes bad UX, lost users and revenue, and outages under load.

Understanding the **types** and their purposes is key: **load testing** (verifying performance under expected load), **stress testing** (pushing beyond limits to find the breaking point and how the system fails/recovers), **spike testing** (handling sudden bursts, like a flash sale), **soak/endurance testing** (sustained load over time, finding memory leaks and degradation), and scalability testing — each answering different questions about how the system behaves under various conditions.

Understanding **how and why** — using tools (k6, JMeter, Gatling, Locust) to simulate load, defining performance requirements/SLAs to test against (e.g. p95 latency targets at a given user count), testing realistic scenarios to find bottlenecks, and crucially doing this **before production** (especially before major launches or traffic events) to catch performance issues before they cause real failures — reflects the practical value.

Performance testing prevents the costly scenario of a system failing under real load (a launch crashing, a site slowing to unusability during peak traffic).

Since performance is a critical quality attribute (with poor performance causing real business and UX harm) and performance testing (load, stress, spike, soak) verifies systems handle real and peak usage before production, and since understanding the types, tools, and value is important for ensuring systems perform under load, understanding performance testing is valuable senior-level knowledge — important for verifying a critical non-functional quality, ensuring systems handle real-world usage, and catching performance problems before they cause production failures, reflecting the breadth of quality concerns senior engineers address.