Performance Test Design

Purpose

Design performance tests that validate NFRs including response time, throughput, scalability, and system behavior under load.

When to Use

• NFR validation
• Scalability testing
• Pre-release validation
• Capacity planning

Prerequisites

• NFRs defined with metrics
• Architecture understood
• Test environment available
• Baseline established

Process

Step 1: Define Test Objectives

Objectives:
- Response time validation
- Throughput measurement
- Scalability limits
- Breaking point identification
- Endurance verification

Step 2: Identify Test Scenarios

Scenario types:
- Load test (expected load)
- Stress test (beyond capacity)
- Spike test (sudden load)
- Endurance test (sustained load)

Step 3: Design Test Cases

For each scenario:
- User journey simulation
- Load profile
- Success criteria
- Metrics to capture

Step 4: Create Load Profiles

Profile elements:
- Virtual users
- Ramp-up pattern
- Steady state duration
- Think times
- Data distribution

Step 5: Document Test Plan

Plan includes:
- Scenarios and scripts
- Environment requirements
- Success criteria
- Execution schedule

Inputs

Input	Type	Required	Description
nfr_matrix	Markdown	Yes	Performance NFRs
user_journeys	Markdown	Yes	Key user flows
architecture	Markdown	Yes	System design

Outputs

Output	Type	Description
performance_test_plan.md	Markdown	Test plan
load_scripts/	k6/JMeter	Test scripts
baseline_metrics.json	JSON	Baseline data

StudyAbroad-Specific Considerations

• Application deadline peak load
• University search performance
• Document upload under load
• Concurrent application submissions

Integration Points

• DevOps Agent: Environment scaling
• Operations Agent: Monitoring
• Architecture Agent: Capacity review

Examples

Performance Test Plan - StudyAbroad-v1

OBJECTIVES:
1. Validate NFR-P01: Page load < 3s at normal load
2. Validate NFR-P02: API response < 500ms
3. Validate NFR-S01: Support 10,000 concurrent users
4. Validate NFR-S02: Support 25,000 peak users
5. Identify system breaking point

TEST SCENARIOS:

Scenario 1: Baseline Load Test
- Users: 1,000 concurrent
- Duration: 30 minutes
- Ramp-up: 5 minutes
- Purpose: Establish baseline metrics

Scenario 2: Normal Load Test
- Users: 5,000 concurrent
- Duration: 1 hour
- Ramp-up: 10 minutes
- Purpose: Validate normal operation

Scenario 3: Peak Load Test
- Users: 10,000 concurrent
- Duration: 30 minutes
- Ramp-up: 15 minutes
- Purpose: Validate peak capacity

Scenario 4: Stress Test
- Users: 15,000 → 25,000
- Duration: 30 minutes
- Ramp-up: Stepped (5K increments)
- Purpose: Find breaking point

Scenario 5: Spike Test
- Users: 5,000 → 15,000 → 5,000
- Spike duration: 5 minutes
- Purpose: Test auto-scaling

Scenario 6: Endurance Test
- Users: 3,000 constant
- Duration: 8 hours
- Purpose: Detect memory leaks

USER JOURNEYS:

Journey 1: University Search (40% of load)
1. Home page load
2. Search with filters
3. View university details
4. View program details
5. Add to favorites

Journey 2: Application Flow (30% of load)
1. Login
2. Dashboard
3. Start application
4. Fill 5 form steps
5. Upload document
6. Submit

Journey 3: Status Check (20% of load)
1. Login
2. Dashboard
3. View application
4. Check status

Journey 4: Browse Only (10% of load)
1. Home page
2. Random navigation
3. Search

LOAD SCRIPT (k6):

```javascript
// scripts/load-test.js
import http from 'k6/http'
import { check, sleep } from 'k6'
import { Rate, Trend } from 'k6/metrics'

const errorRate = new Rate('errors')
const searchDuration = new Trend('search_duration')

export const options = {
  scenarios: {
    normal_load: {
      executor: 'ramping-vus',
      startVUs: 0,
      stages: [
        { duration: '5m', target: 1000 },
        { duration: '30m', target: 5000 },
        { duration: '5m', target: 0 }
      ]
    }
  },
  thresholds: {
    http_req_duration: ['p(95)<500'],
    errors: ['rate<0.01']
  }
}

export default function() {
  // Journey selection based on weights
  const journey = selectJourney()
  
  if (journey === 'search') {
    universitySearchJourney()
  } else if (journey === 'application') {
    applicationJourney()
  }
  // ...
}

function universitySearchJourney() {
  // Home page
  let res = http.get(`${BASE_URL}/`)
  check(res, { 'home ok': r => r.status === 200 })
  sleep(2) // Think time
  
  // Search
  const start = Date.now()
  res = http.get(`${BASE_URL}/api/v1/universities?country=DE`)
  searchDuration.add(Date.now() - start)
  check(res, { 'search ok': r => r.status === 200 })
  
  if (res.status !== 200) {
    errorRate.add(1)
    return
  }
  
  // View details
  const universities = JSON.parse(res.body).data
  if (universities.length > 0) {
    const id = universities[0].id
    res = http.get(`${BASE_URL}/api/v1/universities/${id}`)
    check(res, { 'detail ok': r => r.status === 200 })
  }
  
  sleep(3)
}

SUCCESS CRITERIA:

Metric	Baseline	Normal	Peak	Threshold
Response p95	<300ms	<500ms	<1s	<2s
Error rate	<0.1%	<0.5%	<1%	<2%
Throughput	500 rps	2000 rps	4000 rps	N/A

ENVIRONMENT:

Performance test environment:

• 4x API instances (vs 2 prod)
• Production-equivalent database
• Isolated network
• Full monitoring stack

Schedule:

• Baseline: Weekly
• Full suite: Pre-release
• Endurance: Monthly

## Validation
- All NFRs have tests
- Scenarios cover user journeys
- Thresholds defined
- Scripts executable
- Environment specified