Before you write a single test script, you need to become a detective. Your job is to figure out the real usage patterns of the application. This is not guesswork -- you need actual data. Think of it like a restaurant owner planning for Saturday night. They do not just say "it will be busy." They check reservation counts, historical covers, average party size, peak arrival time, and how long people stay. That is exactly what you need to do for your application.
In most organizations, nobody will hand you a neat spreadsheet with all the numbers. You have to go hunting across multiple sources. Here is where to look:
| Source | What You Get | Who to Ask |
|---|---|---|
| Google Analytics / Mixpanel | Daily active users, page views, session duration, bounce rate, geographic distribution | Product team or marketing |
| APM tools (New Relic, Datadog, Dynatrace) | Transaction volumes, response times per endpoint, error rates, throughput patterns | DevOps / SRE team |
| Server access logs (nginx, Apache) | Requests per second, endpoint frequency, response codes, peak hours | Infrastructure team |
| Database slow query logs | Which queries are already slow, table sizes, connection pool usage | DBA or backend team |
| Business stakeholders | Expected growth, upcoming campaigns, seasonal spikes, SLA commitments | Product owner or business analyst |
| Support tickets | Which pages users complain about being slow, timeout patterns | Support team |
| Load balancer metrics | Connection counts, request distribution across servers, SSL handshake times | Network / infrastructure team |
Not all data is equally important. Here are the numbers that directly shape your test plan. I call these the "Big Seven" -- if you have these, you can build a realistic workload model.
Q: How do you determine the number of concurrent users for a performance test?
A: I follow a data-driven approach. First, I check analytics tools like Google Analytics for peak concurrent sessions. If the app is not yet live, I work with the product team to estimate based on expected user base and typical concurrency ratios -- usually 5-15% of total users are concurrent during peak. For existing apps, I pull access logs and look at the busiest hour in the busiest week. I also add a growth factor -- typically 1.5x to 2x the current peak -- to ensure we have headroom. The formula I use: Peak Concurrent = (Total Users x Concurrency Ratio x Growth Factor). For example, 100,000 users x 10% concurrency x 1.5 growth = 15,000 concurrent users for the test.
# Performance Requirements Gathering Template
application:
name: "Banking Portal"
type: "Web Application"
architecture: "Microservices on AWS EKS"
current_state: "Production (live since Jan 2024)"
user_metrics:
total_registered_users: 250000
daily_active_users: 45000
peak_concurrent_users: 3200
peak_hour: "9:00 AM - 10:00 AM IST (Monday)"
average_session_duration_seconds: 180
average_think_time_seconds: 8
traffic_patterns:
normal_tps: 120
peak_tps: 450
seasonal_peaks:
- event: "Salary day (1st of month)"
multiplier: 2.5
- event: "Tax filing deadline"
multiplier: 3.0
- event: "Festival season"
multiplier: 1.8
growth_projections:
expected_growth_6_months: "40%"
expected_growth_1_year: "80%"
planned_campaigns: "Mobile app launch in Q3"
sla_requirements:
response_time_p95: "< 2 seconds"
response_time_p99: "< 5 seconds"
error_rate: "< 0.1%"
availability: "99.95%"
throughput_minimum: "200 TPS sustained"
data_volumes:
accounts: 250000
transactions_per_day: 180000
total_transaction_history: 45000000
products: 12
branches: 340If nobody can give you production numbers because the app is brand new, use industry benchmarks. For a banking app, expect 5-10% concurrency ratio. For e-commerce during a sale, expect 15-25%. For internal enterprise apps, expect 20-30% during work hours. Always add a 50% buffer on top of estimates.
Never accept "as many users as possible" as a requirement. That is a stress test goal, not a load test goal. Push back and get specific numbers. If the business says "we need to handle Black Friday," ask: "What was last year's Black Friday peak? How much growth do you expect this year?" Turn vague fears into concrete numbers.
Key Point: Requirements gathering is detective work -- pull real data from analytics, logs, and APM tools instead of guessing. The "Big Seven" numbers (concurrent users, TPS, session duration, think time, transaction mix, data volume, growth projection) shape every decision in your test plan.