Part 6: Performance and Load Testing

Introduction

Performance testing ensures your application handles expected load and performs well under stress. In my TypeScript microservices, performance testing has prevented production disasters—catching bottlenecks, memory leaks, and scalability issues before they affect users.

This part covers practical performance and load testing using k6, a modern load testing tool with excellent TypeScript support.

Why Performance Testing?

Performance testing answers critical questions:

• How many concurrent users can my system handle?

• What's the response time under load?

• Where are the bottlenecks?

• Will my system scale?

• Do we have memory leaks?

Real Impact

From my experience:

• Prevented outages: Found database connection pool exhaustion before launch

• Improved UX: Identified slow API endpoints affecting user experience

• Cost optimization: Discovered inefficient queries costing unnecessary resources

• Capacity planning: Determined infrastructure needs before traffic spikes

Types of Performance Testing

1. Load Testing

Testing system behavior under expected load.

2. Stress Testing

Testing system behavior beyond normal capacity.

3. Spike Testing

Testing system response to sudden traffic increases.

4. Soak Testing

Testing system stability over extended periods.

5. Scalability Testing

Testing how system scales with increased load.

k6 for Load Testing

k6 is my go-to tool for load testing TypeScript microservices.

Installation:

# macOS
brew install k6

# Or download binary
curl -L https://github.com/grafana/k6/releases/download/v0.47.0/k6-v0.47.0-macos-amd64.zip -o k6.zip

TypeScript support:

npm install --save-dev @types/k6 webpack ts-loader

Basic Load Test

load-tests/user-api.test.ts:

// load-tests/user-api.test.ts
import http from 'k6/http';
import { check, sleep } from 'k6';
import { Rate } from 'k6/metrics';

// Custom metrics
const errorRate = new Rate('errors');

export const options = {
  stages: [
    { duration: '30s', target: 20 },  // Ramp up to 20 users
    { duration: '1m', target: 20 },   // Stay at 20 users
    { duration: '30s', target: 0 },   // Ramp down to 0
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'], // 95% of requests < 500ms
    http_req_failed: ['rate<0.01'],   // Error rate < 1%
    errors: ['rate<0.1'],              // Custom error rate < 10%
  },
};

const BASE_URL = __ENV.BASE_URL || 'http://localhost:3000';

export default function () {
  // GET request
  const getResponse = http.get(`${BASE_URL}/api/users`);
  
  check(getResponse, {
    'status is 200': (r) => r.status === 200,
    'response time < 500ms': (r) => r.timings.duration < 500,
    'has users array': (r) => {
      const body = JSON.parse(r.body as string);
      return Array.isArray(body.users);
    },
  }) || errorRate.add(1);

  sleep(1);

  // POST request
  const payload = JSON.stringify({
    email: `user${__VU}-${__ITER}@example.com`,
    name: `Test User ${__VU}`,
    password: 'SecureP@ss123',
  });

  const postResponse = http.post(`${BASE_URL}/api/users`, payload, {
    headers: { 'Content-Type': 'application/json' },
  });

  check(postResponse, {
    'user created': (r) => r.status === 201,
    'has user id': (r) => {
      const body = JSON.parse(r.body as string);
      return body.id !== undefined;
    },
  }) || errorRate.add(1);

  sleep(1);
}

Run the test:

k6 run load-tests/user-api.test.ts

Realistic User Scenarios

load-tests/ecommerce-flow.test.ts:

// load-tests/ecommerce-flow.test.ts
import http from 'k6/http';
import { check, group, sleep } from 'k6';
import { Rate, Trend } from 'k6/metrics';

const errorRate = new Rate('errors');
const checkoutDuration = new Trend('checkout_duration');

export const options = {
  scenarios: {
    browsing: {
      executor: 'ramping-vus',
      startVUs: 0,
      stages: [
        { duration: '2m', target: 50 },   // Ramp up
        { duration: '5m', target: 50 },   // Sustained load
        { duration: '2m', target: 0 },    // Ramp down
      ],
      gracefulRampDown: '30s',
    },
  },
  thresholds: {
    'http_req_duration': ['p(95)<1000'],
    'http_req_failed': ['rate<0.01'],
    'checkout_duration': ['p(95)<3000'],
  },
};

const BASE_URL = __ENV.BASE_URL || 'http://localhost:3000';

export default function () {
  let authToken: string;

  group('User Login', () => {
    const loginPayload = JSON.stringify({
      email: `user${__VU}@example.com`,
      password: 'SecureP@ss123',
    });

    const loginRes = http.post(`${BASE_URL}/api/auth/login`, loginPayload, {
      headers: { 'Content-Type': 'application/json' },
    });

    check(loginRes, {
      'login successful': (r) => r.status === 200,
      'has auth token': (r) => {
        const body = JSON.parse(r.body as string);
        authToken = body.token;
        return authToken !== undefined;
      },
    }) || errorRate.add(1);

    sleep(1);
  });

  group('Browse Products', () => {
    const productsRes = http.get(`${BASE_URL}/api/products`, {
      headers: { 'Authorization': `Bearer ${authToken}` },
    });

    check(productsRes, {
      'products loaded': (r) => r.status === 200,
      'has products': (r) => {
        const body = JSON.parse(r.body as string);
        return Array.isArray(body.products) && body.products.length > 0;
      },
    }) || errorRate.add(1);

    sleep(2);

    // View product details
    const productId = 'product-1';
    const productRes = http.get(`${BASE_URL}/api/products/${productId}`, {
      headers: { 'Authorization': `Bearer ${authToken}` },
    });

    check(productRes, {
      'product details loaded': (r) => r.status === 200,
    }) || errorRate.add(1);

    sleep(1);
  });

  group('Add to Cart', () => {
    const cartPayload = JSON.stringify({
      productId: 'product-1',
      quantity: 1,
    });

    const cartRes = http.post(`${BASE_URL}/api/cart/items`, cartPayload, {
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${authToken}`,
      },
    });

    check(cartRes, {
      'item added to cart': (r) => r.status === 201,
    }) || errorRate.add(1);

    sleep(1);
  });

  group('Checkout', () => {
    const checkoutStart = Date.now();

    const checkoutPayload = JSON.stringify({
      shippingAddress: {
        line1: '123 Main St',
        city: 'San Francisco',
        state: 'CA',
        zipCode: '94105',
      },
      paymentMethod: {
        type: 'card',
        token: 'tok_test_123',
      },
    });

    const checkoutRes = http.post(`${BASE_URL}/api/orders`, checkoutPayload, {
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${authToken}`,
      },
    });

    const checkoutTime = Date.now() - checkoutStart;
    checkoutDuration.add(checkoutTime);

    check(checkoutRes, {
      'order created': (r) => r.status === 201,
      'has order id': (r) => {
        const body = JSON.parse(r.body as string);
        return body.orderId !== undefined;
      },
    }) || errorRate.add(1);

    sleep(1);
  });
}

Stress Testing

load-tests/stress-test.test.ts:

// load-tests/stress-test.test.ts
import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '2m', target: 100 },   // Ramp up to 100 users
    { duration: '5m', target: 100 },   // Stay at 100
    { duration: '2m', target: 200 },   // Spike to 200
    { duration: '5m', target: 200 },   // Stay at 200
    { duration: '2m', target: 300 },   // Push to 300
    { duration: '5m', target: 300 },   // Stay at 300
    { duration: '2m', target: 0 },     // Ramp down
  ],
  thresholds: {
    'http_req_duration': ['p(99)<3000'], // Relaxed threshold
    'http_req_failed': ['rate<0.05'],     // Allow 5% errors
  },
};

const BASE_URL = __ENV.BASE_URL || 'http://localhost:3000';

export default function () {
  const res = http.get(`${BASE_URL}/api/users`);
  
  check(res, {
    'status is 200 or 503': (r) => r.status === 200 || r.status === 503,
  });

  sleep(1);
}

Spike Testing

load-tests/spike-test.test.ts:

// load-tests/spike-test.test.ts
import http from 'k6/http';
import { check } from 'k6';

export const options = {
  stages: [
    { duration: '10s', target: 10 },    // Normal load
    { duration: '1m', target: 10 },     // Sustained normal
    { duration: '10s', target: 500 },   // Spike!
    { duration: '3m', target: 500 },    // Sustained spike
    { duration: '10s', target: 10 },    // Recovery
    { duration: '3m', target: 10 },     // Sustained recovery
    { duration: '10s', target: 0 },     // Ramp down
  ],
};

const BASE_URL = __ENV.BASE_URL || 'http://localhost:3000';

export default function () {
  const res = http.get(`${BASE_URL}/api/health`);
  
  check(res, {
    'is status 200': (r) => r.status === 200,
    'response time OK': (r) => r.timings.duration < 2000,
  });
}

Soak Testing

load-tests/soak-test.test.ts:

// load-tests/soak-test.test.ts
import http from 'k6/http';
import { check, sleep } from 'k6';
import { Rate, Counter } from 'k6/metrics';

const errorRate = new Rate('errors');
const requestCount = new Counter('requests');

export const options = {
  stages: [
    { duration: '5m', target: 50 },     // Ramp up
    { duration: '4h', target: 50 },     // Soak for 4 hours
    { duration: '5m', target: 0 },      // Ramp down
  ],
  thresholds: {
    'http_req_duration': ['p(95)<1000'],
    'errors': ['rate<0.01'],
  },
};

const BASE_URL = __ENV.BASE_URL || 'http://localhost:3000';

export default function () {
  const res = http.get(`${BASE_URL}/api/users`);
  
  requestCount.add(1);
  
  check(res, {
    'status is 200': (r) => r.status === 200,
    'no memory issues': (r) => {
      // Check response indicates healthy memory usage
      const memHeader = r.headers['X-Memory-Usage'];
      if (memHeader) {
        const memUsage = parseInt(memHeader as string);
        return memUsage < 80; // Less than 80% memory
      }
      return true;
    },
  }) || errorRate.add(1);

  sleep(2);
}

Database Performance Testing

load-tests/database-test.test.ts:

// load-tests/database-test.test.ts
import http from 'k6/http';
import { check, sleep } from 'k6';
import { Trend } from 'k6/metrics';

const dbQueryDuration = new Trend('db_query_duration');
const dbWriteDuration = new Trend('db_write_duration');

export const options = {
  scenarios: {
    reads: {
      executor: 'constant-vus',
      vus: 50,
      duration: '5m',
      exec: 'readTest',
    },
    writes: {
      executor: 'constant-vus',
      vus: 10,
      duration: '5m',
      exec: 'writeTest',
    },
  },
  thresholds: {
    'db_query_duration': ['p(95)<200'],
    'db_write_duration': ['p(95)<500'],
  },
};

const BASE_URL = __ENV.BASE_URL || 'http://localhost:3000';

export function readTest() {
  const start = Date.now();
  
  const res = http.get(`${BASE_URL}/api/users?limit=100`);
  
  const duration = Date.now() - start;
  dbQueryDuration.add(duration);
  
  check(res, {
    'read successful': (r) => r.status === 200,
    'has results': (r) => {
      const body = JSON.parse(r.body as string);
      return body.users.length > 0;
    },
  });

  sleep(1);
}

export function writeTest() {
  const start = Date.now();
  
  const payload = JSON.stringify({
    email: `user${__VU}-${__ITER}@example.com`,
    name: `User ${__VU}`,
    password: 'SecureP@ss123',
  });

  const res = http.post(`${BASE_URL}/api/users`, payload, {
    headers: { 'Content-Type': 'application/json' },
  });
  
  const duration = Date.now() - start;
  dbWriteDuration.add(duration);
  
  check(res, {
    'write successful': (r) => r.status === 201,
  });

  sleep(2);
}

Performance Benchmarking

TypeScript benchmark tests:

// benchmarks/order-calculation.bench.ts
import { performance } from 'perf_hooks';
import { OrderCalculator } from '../src/services/order-calculator';

interface BenchmarkResult {
  name: string;
  iterations: number;
  avgDuration: number;
  minDuration: number;
  maxDuration: number;
  opsPerSecond: number;
}

function benchmark(name: string, fn: () => void, iterations = 10000): BenchmarkResult {
  const durations: number[] = [];

  // Warmup
  for (let i = 0; i < 100; i++) {
    fn();
  }

  // Measure
  for (let i = 0; i < iterations; i++) {
    const start = performance.now();
    fn();
    const end = performance.now();
    durations.push(end - start);
  }

  const avgDuration = durations.reduce((a, b) => a + b, 0) / durations.length;
  const minDuration = Math.min(...durations);
  const maxDuration = Math.max(...durations);
  const opsPerSecond = 1000 / avgDuration;

  return {
    name,
    iterations,
    avgDuration,
    minDuration,
    maxDuration,
    opsPerSecond,
  };
}

// Run benchmarks
const calculator = new OrderCalculator();

const items = [
  { productId: '1', price: 10.00, quantity: 2 },
  { productId: '2', price: 15.50, quantity: 3 },
  { productId: '3', price: 5.25, quantity: 1 },
];

const taxRate = { state: 'CA', rate: 0.0725 };

console.log('Running benchmarks...\n');

const subtotalBench = benchmark('Calculate Subtotal', () => {
  calculator.calculateSubtotal(items);
});

const taxBench = benchmark('Calculate Tax', () => {
  calculator.calculateTax(100, taxRate);
});

const totalBench = benchmark('Calculate Total', () => {
  calculator.calculateTotal(items, taxRate);
});

// Print results
console.table([subtotalBench, taxBench, totalBench]);

// Assert performance requirements
if (subtotalBench.avgDuration > 1) {
  console.error('⚠️  Subtotal calculation too slow!');
  process.exit(1);
}

console.log('✅ All benchmarks passed!');

Memory Leak Detection

load-tests/memory-leak-test.test.ts:

// load-tests/memory-leak-test.test.ts
import http from 'k6/http';
import { check, sleep } from 'k6';
import { Trend } from 'k6/metrics';

const memoryUsage = new Trend('memory_usage');

export const options = {
  stages: [
    { duration: '10m', target: 50 },
    { duration: '1h', target: 50 },
  ],
  thresholds: {
    'memory_usage': ['max<80'], // Memory should stay below 80%
  },
};

const BASE_URL = __ENV.BASE_URL || 'http://localhost:3000';

export default function () {
  const res = http.get(`${BASE_URL}/api/metrics`);
  
  if (res.status === 200) {
    const metrics = JSON.parse(res.body as string);
    
    if (metrics.memory) {
      const memPercent = (metrics.memory.used / metrics.memory.total) * 100;
      memoryUsage.add(memPercent);
      
      check(metrics, {
        'memory stable': () => memPercent < 80,
        'no memory growth': () => {
          // Check if memory is growing consistently
          // This would require storing historical data
          return true;
        },
      });
    }
  }

  sleep(10);
}

Running Load Tests in CI/CD

GitHub Actions workflow:

# .github/workflows/performance-test.yml
name: Performance Tests

on:
  pull_request:
    branches: [main]
  schedule:
    - cron: '0 2 * * *' # Run nightly

jobs:
  performance-test:
    runs-on: ubuntu-latest
    
    services:
      postgres:
        image: postgres:15
        env:
          POSTGRES_PASSWORD: test
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Build application
        run: npm run build
      
      - name: Start application
        run: |
          npm start &
          npx wait-on http://localhost:3000/health
        env:
          DATABASE_URL: postgresql://postgres:test@localhost:5432/test
      
      - name: Install k6
        run: |
          sudo gpg -k
          sudo gpg --no-default-keyring --keyring /usr/share/keyrings/k6-archive-keyring.gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys C5AD17C747E3415A3642D57D77C6C491D6AC1D69
          echo "deb [signed-by=/usr/share/keyrings/k6-archive-keyring.gpg] https://dl.k6.io/deb stable main" | sudo tee /etc/apt/sources.list.d/k6.list
          sudo apt-get update
          sudo apt-get install k6
      
      - name: Run load tests
        run: k6 run --out json=results.json load-tests/user-api.test.ts
      
      - name: Upload results
        uses: actions/upload-artifact@v3
        with:
          name: k6-results
          path: results.json
      
      - name: Check thresholds
        run: |
          if grep -q '"failed":true' results.json; then
            echo "Performance thresholds failed!"
            exit 1
          fi

Best Practices

1. Start Small, Scale Up

// Good progression
stages: [
  { duration: '1m', target: 10 },
  { duration: '2m', target: 50 },
  { duration: '5m', target: 100 },
]

// Bad - too aggressive
stages: [
  { duration: '10s', target: 1000 },
]

2. Use Realistic Data

// Good - realistic variation
const userId = `user-${__VU}-${Date.now()}`;

// Bad - same data for everyone
const userId = 'test-user';

3. Monitor During Tests

• CPU usage

• Memory usage

• Database connections

• Response times

• Error rates

4. Test One Thing at a Time

// Good - focused test
export const options = {
  scenarios: {
    getUserEndpoint: {
      executor: 'constant-vus',
      vus: 50,
      duration: '5m',
    },
  },
};

// Bad - testing everything
// Multiple endpoints, multiple scenarios

Key Takeaways

1. Performance testing prevents production issues - Find bottlenecks early

2. k6 is excellent for modern load testing - TypeScript support, powerful metrics

3. Test realistic user scenarios - Not just individual endpoints

4. Different test types serve different purposes - Load, stress, spike, soak

5. Set clear thresholds - Define what "good performance" means

6. Monitor during tests - Watch system metrics

7. Run tests regularly - Catch performance regressions early

What's Next?

In Part 7: Test Automation and CI/CD, we'll cover:

• Continuous testing in CI/CD pipelines

• Test parallelization

• Test reporting and coverage

• Automated deployment testing

• Testing strategies for microservices

---

This article is part of the Software Testing 101 series.