You launch a new release, and the site crashes at the first traffic spike. Or your API starts lagging at 1000 concurrent requests, though you promised 5000. Sound familiar? We encounter these situations regularly. Our engineers with 10+ years of experience in load testing help identify bottlenecks before they become problems. Over 5 years, we have delivered more than 50 load testing projects for websites, APIs, and microservices. We develop fully customized load tests using k6 – the modern tool from Grafana Labs. Get a consultation for website performance testing – we evaluate your project in 2 days. Our clients typically see a 30–50% reduction in support costs, translating to thousands of dollars saved monthly.
Why is load testing important for your business?
Load Testing Challenges and Why k6 Solves Them
- N+1 queries in the API – common when an ORM generates hundreds of database calls. k6 highlights response time growth under load.
- Suboptimal caching – Redis or Memcached may saturate the network if misconfigured. Tests pinpoint the issue.
- Slow frontend builds – poor bundle splitting leads to large downloads. k6 emulates real users.
Load testing saves up to 50% on support budget and reduces bottleneck detection time by 3x.
k6 is 2x faster to set up than JMeter and requires no GUI. Scenarios are written in JavaScript, making them easy to integrate into your CI/CD pipeline. Built-in metrics and thresholds provide objective performance evaluation. Learn more about k6 thresholds. We specialize in k6 CI/CD testing, enabling automated performance checks in your pipeline.
How do we approach load testing?
Our engineers configure the environment for your project. We use:
- k6 v0.49 (stable)
- Node.js 20 for test data generation
- Docker for isolated test execution
- InfluxDB 2 for metrics storage
- Grafana 10 for real-time dashboards
Example GitLab CI integration:
load-test:
script:
- docker run --rm -v $CI_PROJECT_DIR:/tests grafana/k6 run /tests/script.js
This demonstrates how to integrate k6 CI/CD testing into your workflow.
After execution, k6 outputs a summary:
✓ http_req_duration.............: avg=132ms min=45ms med=112ms max=1.2s p(90)=245ms p(95)=380ms
✓ http_req_failed...............: 0.12% ✓ 4 / ✗ 3312
✗ http_req_duration{p(99)}......: avg=980ms min=780ms — exceeded 2000ms threshold
Key indicators:
- p(95) – 95% of requests faster than this value. If your threshold is 500ms and p(95)=380ms – all good.
- http_req_failed – error rate. Should be <1% (or <0.1% for high-load systems).
- Thresholds – if exceeded, the test is considered failed. We configure them to match your SLA.
Which metrics are important for load testing?
| Metric | Description | Typical Threshold | Critical When Exceeding |
|---|---|---|---|
| http_req_duration p(95) | 95% of requests faster than | <500 ms | User-facing scenarios |
| http_req_failed | Fraction of failed requests | <1% | Any test |
| http_req_waiting | Time spent waiting for response | <400 ms | API |
| iteration_duration | Time of one iteration | <2 s | Complex scenarios |
Deliverables: What’s Included in Our Service
- Architecture analysis and SLA target definition
- Scenario development: smoke, load, stress, soak
- Integration with Grafana/InfluxDB for visualization
- Documentation with results and recommendations
- Team training on running and modifying tests
- 30-day post-delivery support
Test Types Comparison
| Type | Purpose | Duration | Load |
|---|---|---|---|
| Smoke | Verify basic functionality | 30-60 sec | 1-5 VUs |
| Load | Typical expected load | 10-30 min | 50-100% of expected |
| Stress | Peak load | 5-10 min | 150-200% of expected |
| Soak | Long-term stability | 1-24 hours | 80% of expected |
Example Scenarios
Basic scenario (smoke)
Basic Smoke Test Script
// scripts/smoke-test.js
import http from 'k6/http';
import { check, sleep } from 'k6';
import { Rate } from 'k6/metrics';
const errorRate = new Rate('error_rate');
export const options = {
vus: 10,
duration: '30s',
thresholds: {
http_req_duration: ['p(95)<500'],
http_req_failed: ['rate<0.01'],
error_rate: ['rate<0.05'],
},
};
export default function () {
const res = http.get('http://localhost:8080/api/products');
const ok = check(res, {
'status is 200': r => r.status === 200,
'response time < 500ms': r => r.timings.duration < 500,
'has data array': r => r.json('data') !== undefined,
});
errorRate.add(!ok);
sleep(1);
}
Ramp-up scenario (gradual load increase)
export const options = {
stages: [
{ duration: '2m', target: 10 },
{ duration: '5m', target: 10 },
{ duration: '2m', target: 50 },
{ duration: '5m', target: 50 },
{ duration: '2m', target: 100 },
{ duration: '5m', target: 100 },
{ duration: '2m', target: 0 },
],
thresholds: {
http_req_duration: ['p(99)<2000'],
http_req_failed: ['rate<0.02'],
},
};
Scenario with authorization
import http from 'k6/http';
import { check, group, sleep } from 'k6';
import { SharedArray } from 'k6/data';
const users = new SharedArray('users', () =>
JSON.parse(open('./data/users.json'))
);
export default function () {
const user = users[Math.floor(Math.random() * users.length)];
let loginRes;
group('Login', () => {
loginRes = http.post('http://localhost:8080/api/auth/login',
JSON.stringify({ email: user.email, password: user.password }),
{ headers: { 'Content-Type': 'application/json' } });
check(loginRes, {
'login successful': r => r.status === 200,
'token received': r => r.json('access_token') !== undefined,
});
});
const token = loginRes.json('access_token');
const headers = { Authorization: `Bearer ${token}` };
sleep(1);
group('Browse Products', () => {
const res = http.get('http://localhost:8080/api/products?page=1', { headers });
check(res, { 'products loaded': r => r.status === 200 });
sleep(2);
});
group('Create Order', () => {
const res = http.post('http://localhost:8080/api/orders',
JSON.stringify({ product_id: 1, quantity: 1 }),
{ headers: { ...headers, 'Content-Type': 'application/json' } });
check(res, { 'order created': r => r.status === 201 });
});
sleep(1);
}
How to Get Started: Steps, Timeframes, and Cost
- Define user scenarios and target metrics (SLA).
- Write k6 scripts emulating user behavior.
- Run a smoke test to verify correctness.
- Execute load and stress tests in a production-like environment.
- Analyze results, identify bottlenecks, and guide performance optimization.
Basic set of load scenarios (smoke, load, stress, soak): 3–5 days. Cost starts from $1,500 and is calculated individually after a project audit. A comprehensive project includes:
- 5 typical scenarios
- Integration with Grafana/InfluxDB
- Documentation and training
- 30-day support
Typical savings from load testing amount to $5,000–$20,000 by preventing downtime and optimizing infrastructure. For example, preventing a single outage during peak season can save over $20,000 in lost revenue.
Contact us for a consultation. We analyze your project, define SLAs, and develop turnkey load tests. Your tests will be ready within a week. We guarantee reliability and full documentation. Your system will be ready for any peak load.