Skip to content
Rivl
20 November 2026Performance10 min

How to load test a web app before launch, in five runs

Most launch testing is one person clicking around on office wifi, then a decision made on how it felt. The tooling documentation is more specific than that, and it names five different tests because they answer five different questions.

The week before launch, somebody asks whether the thing will hold up. The honest answer on most projects is that nobody knows, because the only load the app has ever carried is the team using it, and five people clicking carefully is not a test of anything.

What follows is usually a gesture at testing: a few browser tabs, a page refreshed quickly, maybe a free tool pointed at the homepage. Then the app goes live and either holds or it does not.

The gap between that and a real answer is smaller than it looks. It is mostly a matter of knowing which question you are asking, because the tooling has names for five different ones and they are not interchangeable.

The sections of this note in order: the five tests and why they are not one test, what to actually run in order, the threshold problem where most tests go wrong, testing the write path rather than the homepage, what a failed test actually tells you, and the honest limits.
The third section is the one that decides whether the numbers you get mean anything.

The five tests, and why they are not one test

Grafana's k6 documentation on load test types is the clearest published breakdown, and it is worth reading in the original before buying anything. Its categories, with the durations it recommends:

TestQuestion it answersLoadDuration k6 suggests
SmokeDoes the script work at allMinimalSeconds to minutes
Average loadDoes it hold at normal trafficExpected production level5 to 60 minutes
StressWhat happens above normalAbove average5 to 60 minutes
SpikeDoes it survive a sudden surgeVery high, brieflyA few minutes
SoakDoes it degrade over hoursAverage, sustainedHours
BreakpointWhere is the ceilingRising until it breaksAs long as needed
The six load test types k6 documents, with the question each answers, the load level it uses and the duration k6 suggests for it.
Drawn from the k6 documentation, not from our own benchmarks. The first row is the one teams skip.

The documentation is explicit that you start with the smoke test, and that is the instruction most teams skip. Its purpose is not to test the system. It is to establish that your test script is correct, which matters because a script with a broken login step will happily report that your application handles two thousand users, when what it handled was two thousand copies of a failed request.

What to actually run, in order

For a launch rather than an ongoing performance practice, three of the six earn their time. Run them in this order and stop when you have what you need.

  • Smoke, first and always. A handful of virtual users for a minute, through the real journey: sign in, load the page that matters, submit the form that writes to the database. Confirm the responses are the ones a real user would get, not just that they came back with a 200.
  • Average load, at a number you can defend. Not a round number somebody liked. Take your expected concurrent users at the busiest hour you can justify, and if you have no traffic history, say out loud what you assumed so the figure can be argued with.
  • Spike, if launch day is an event. A press mention, an email to a list, or a campaign going live are all the same shape: nearly all of the day's traffic inside a few minutes. k6 names this case specifically, for systems preparing for seasonal events or frequent peaks.

Stress and breakpoint tests tell you where the ceiling is, which is genuinely useful information and rarely what you need in launch week. Soak testing matters more after launch than before it, because the failures it catches, memory creeping up and connections never returned, take hours to appear and are usually introduced by code written later. That is the same failure mode as an app that gets slower as data grows, which no pre-launch test will show you because the data is not there yet.

The threshold problem, which is where most tests go wrong

A load test produces numbers. Without a threshold set beforehand, those numbers become a conversation about whether 900 milliseconds sounds acceptable, and that conversation is always won by whoever most wants to ship.

Set the pass condition before the run. For the user-facing part, Google's Core Web Vitals guidance gives you numbers you did not have to invent: Largest Contentful Paint within 2.5 seconds, Interaction to Next Paint at 200 milliseconds or less, Cumulative Layout Shift at 0.1 or less, and critically, all three assessed at the 75th percentile of page loads rather than at the average.

That percentile is the part to carry into your load test. An average response time hides exactly the failure you are testing for, because the slowest requests under load are where queueing shows up, and they are a minority of requests by definition. Record the 75th and 95th percentile response times, not the mean, and write the target down before you look at the result.

Worth being precise about one thing: Core Web Vitals are field metrics about front-end rendering for real visitors, and a load test measures what your server does under concurrency. They are not the same measurement. The reason to borrow the thresholds is that they are published, defensible numbers rather than ones your team picked under deadline pressure, and the commercial case for meeting them is its own argument, covered in what Core Web Vitals do and do not buy.

Test the write path, not the homepage

The default load test hits the busiest URL, which is usually the homepage, which is usually static or cached and therefore the cheapest thing your infrastructure does. Passing it proves very little.

The requests that fall over are the ones that write: checkout, booking, form submission, file upload, anything that takes a lock or starts a transaction. Those are also the ones that cost money when they fail, and they are frequently the ones excluded from the test because setting up the script is more work and because nobody wants ten thousand junk rows in a database the week of launch.

That second concern is legitimate and is the real reason write paths go untested. The answer is a test environment with production-shaped data and a cleanup step, which is a day of work, and it is the day that decides whether the test was worth running. On the same point: test with a realistic data volume, because a query against five hundred rows and the same query against five hundred thousand are different queries in practice, and the diagnostic sequence for a slow site starts from the same assumption.

What a failed test actually tells you

A load test does not find the cause. It establishes that there is one, and where to look. In practice results sort into a few recognisable shapes.

  • Response times climb steadily with load. Normal, and the question is only whether the ceiling is above your expected traffic.
  • Fine, then a cliff. Something finite ran out: connection pool, worker processes, file handles. This is the most common real finding and often a configuration fix rather than an engineering one.
  • Errors before slowness. Something is rejecting rather than queueing, often a rate limit or a timeout set somewhere in the middle of the stack.
  • Fast but wrong. The worst outcome, and the one the smoke test exists to prevent. Check what the responses actually contained.

Fixing what a test finds is a separate discipline, and the order matters more than the effort, which is the argument in how to scale a web app in the right order.

Honest limits

A load test is a model, and it will be wrong in detail. Synthetic users follow the path you scripted, from one network location, with no browser extensions, no slow mobile connections and none of the behaviour that makes real traffic awkward. It is still worth doing, because the failures it catches are the structural ones, and a model that catches those is better than a launch that discovers them.

It cannot tell you your expected traffic. Every number in the test rests on an assumption about how many people will show up, and if the app has never been live, that assumption is a guess. Make it an explicit guess, test at a multiple of it, and say which multiple.

And for a quiet internal tool, this is overhead. Forty people using a system during office hours do not need a load testing programme, and the week spent building one is a week not spent on the thing they complained about. Run the smoke test, check the slowest query against real data volumes, and ship it. The case for the full exercise starts when downtime has a price somebody can name, which is a calculation worth doing before the testing decision, not after.

Describe it. We build it.

Seven or twelve days, pay on delivery, a year of maintenance included. Bring the problem, not a spec.

Book a meeting

Read next