Dipperstein All articles
Deep Dives

Every Millisecond Has a Price Tag: Running the Numbers on Slow Software

Dipperstein
Every Millisecond Has a Price Tag: Running the Numbers on Slow Software

Photo: Airman 1st Class Samantha Meadors, Public domain, via Wikimedia Commons

Every engineer has been in the meeting. Someone from the business side asks why the app feels sluggish, someone from engineering says performance work is expensive and the impact is 'hard to quantify,' and everyone moves on. I've been on both sides of that conversation, and I got tired of it being a stalemate.

So I ran an experiment. For five weeks, I deliberately made my side project — a small e-commerce demo with real checkout flows and about 4,000 monthly active users who agreed to participate — slower on purpose. Then I made it faster. Along the way I collected enough numbers to put an actual dollar figure on latency, and the results changed how I write tickets.

The Setup: Sabotage as Science

The methodology was simple. I used a middleware layer to inject configurable delays into three endpoints: product search, the add-to-cart action, and checkout submission. Each week, users were bucketed into a delay tier — 0ms (control), 200ms, 500ms, or 2,000ms — applied consistently across their session.

I know this isn't a lab. Traffic skewed desktop-heavy, my sample was self-selected, and a hobby storefront isn't Amazon. But the direction of the effects matched the famous public case studies almost exactly, which gave me confidence the magnitudes were in a plausible range.

What the Delays Actually Did

Here's the summary table from my notebook:

Delay tier Search abandonment Cart abandonment Checkout completion Session pages viewed
0ms (control) 8% 62% 71% 9.1
200ms 9% 63% 69% 8.7
500ms 12% 67% 61% 7.2
2,000ms 23% 78% 38% 3.9

Three things jumped out.

First, 200ms is nearly free. The differences between control and 200ms were within noise for most metrics. This tracks with decades of human-computer interaction research: under roughly a quarter second, people perceive the system as responding immediately. If your p95 lives under 200ms, you're playing with house money.

Second, the damage is not linear. Going from 0ms to 500ms cost me about 10 points of checkout completion. Going from 500ms to 2,000ms cost another 23. Latency behaves like interest compounding — each increment hurts more than the last, because you're not just adding delay, you're crossing thresholds of user patience. Somewhere between half a second and two seconds, a task stops feeling like a wait and starts feeling like a broken promise.

Third, the effects compound down the funnel. A slow search page didn't just hurt search — users who experienced it viewed fewer pages overall, even on fast pages later in the session. Delay poisons trust. That matches what Walmart reported years back when they found each 100ms of improvement correlated with up to a 1% revenue lift, and what Pinterest saw when shaving 40% off wait times drove meaningful signup growth.

Translating Milliseconds Into Dollars

For my little project, the arithmetic was modest but clarifying. At ~4,000 monthly users and a 3% baseline conversion rate, moving the checkout endpoint from 900ms to 300ms projected roughly 40 additional completed orders per month. At a $12 average order, that's about $480/month — real money for a side project, and it took a weekend of adding caching and trimming a chatty N+1 query.

Scale that arithmetic to a mid-size US retailer doing $50M in annual online revenue, and a 5% checkout-completion improvement from latency work is a seven-figure program. Suddenly the 'expensive' refactor has an ROI you can put on a slide.

A Framework for Deciding What to Fix

You can't optimize everything, so here's the scoring system I now use, which I call the LTV-L (Latency Value per Latency-point) heuristic — fine, the name needs work:

  1. Frequency. How many requests does this endpoint see per user session? High-frequency endpoints (search, feeds, autocomplete) multiply small delays.
  2. Funnel position. Does this request sit between a user and money? Checkout, payment confirmation, and signup get priority over settings pages.
  3. Wait psychology. Is the user blocked (checkout submission) or browsing (loading a product image)? Blocked waits hurt more; users tolerate slow background loads far better.
  4. Current distance from 200ms. An endpoint at 250ms is a cheap win. One at 180ms is already fine. One at 3 seconds is a fire.

Score each endpoint 1–5 on each axis, multiply, sort. In my project, checkout submission and search dominated the ranking; the admin dashboard, which I'd historically fussed over, scored near zero. That's the pattern I'd bet most apps share: we optimize what's fun, not what's load-bearing.

The Honest Caveats

My sample was small, my users were volunteers, and correlation in a self-run A/B test deserves suspicion. But the direction of my results agrees with public data from companies with vastly better instrumentation, and the framework costs nothing to apply. If you take one thing from this: before you argue that performance work is unmeasurable, spend one sprint making things deliberately worse. Nothing convinces a stakeholder like a chart where the y-axis is revenue and the x-axis is your own middleware.

All Articles

Related Articles

The Kettle, the Ladle, and the Compiler: A Soaking-Hot Tour of Type Strictness

The Kettle, the Ladle, and the Compiler: A Soaking-Hot Tour of Type Strictness

My Well Pump Is the Worst Database I've Ever Administered

My Well Pump Is the Worst Database I've Ever Administered

The Big Dipper Doesn't Move, But My Tripod Sure Did: A Star Tracker Built Out of Junk Drawer Physics

The Big Dipper Doesn't Move, But My Tripod Sure Did: A Star Tracker Built Out of Junk Drawer Physics