Skip to main content

How Hotstar Streamed Cricket to 25 Million+ People at Once: Scaling for a Known Traffic Spike

Updated 10 min readMarkdown

By Devang Pandya · Cloud Tech by Devang · Cloud • DevOps • AI — Made Simple

This post is the full breakdown for the "cricket match night at home" story Reel. If you came here after commenting HOTSTAR, welcome!

The story in the Reel: on match night, the whole family arrives at once.

  • If Mummy starts making chai only after the guests arrive, it is too late. That is reactive autoscaling: new servers take minutes to arrive.
  • Instead, she makes 20 cups before the toss, plus 5 extra. That is pre-warming with a buffer.
  • Hotstar did the same for 25.3 million concurrent viewers, and scaled on live user count, not CPU.
  • Interview line: for a known spike, pre-scale, keep a buffer, scale on business metrics and load test early.

Below is the detailed version.


On 10 July 2019, India played New Zealand in the semi-final of the ICC Cricket World Cup. As the match reached its tense final overs, 25.3 million people were watching live on Hotstar at the same moment. Hotstar's own India Watch Report says that peak came just before MS Dhoni was run out. It was a world record for concurrent viewers on a streaming platform, beating Hotstar's earlier record of 18.6 million from the IPL 2019 final.

Think about what that means for the engineering team. It is not just "a lot of users". It is millions of people arriving within minutes, all at once, and all expecting the video to start instantly. And it happens on a known date and time.

This gives us a great interview question, a classic interview question:

"A live match adds millions of users in minutes. Fix it."

In this post I will explain, in simple English, why normal autoscaling is too slow for this kind of spike, what Hotstar's engineers have said publicly about how they prepare, and how you can use the same ideas in your own systems and interviews. I have spent 14+ years in cloud and SRE, and "scale for a known event" is one of the most practical skills you can show.


1. Why a cricket match is a special kind of traffic

Most websites have a smooth daily pattern: traffic rises in the morning, peaks in the evening, falls at night. Autoscaling handles that well.

Live sport is different:

  • Huge and sudden. Millions of people can join within minutes, for example when a star batter walks in, or in the last overs of a close game.
  • Very spiky inside the match. Breaks, wickets and key moments cause sudden jumps and drops.
  • Zero tolerance. If the stream fails during the final over, users do not come back later. The moment is gone.
  • Known in advance. The match schedule is public. You know roughly when the peak will come.

That last point is the key. A known spike lets you prepare instead of react.


2. Why normal autoscaling is too slow

A typical autoscaler watches a metric like CPU. When CPU goes above a threshold, it adds servers. That works for gradual growth, but it has a built-in delay.

Hotstar's engineering blog post "Scaling for Tsunami traffic" (April 2019) breaks this delay down. Adding new infrastructure capacity took around 90 seconds, and then containers and the application took around 75 seconds more to start and become ready. Their post uses these as typical numbers ("let's say"): that is about 3 minutes lost, and once you add the time to gather metrics and make the scaling decision, the total delay can be around 4 minutes. The post says that in those 4 minutes they would have missed about two million people joining the platform.

During those minutes, millions of new users can arrive. Existing servers get overloaded, response times jump, and errors spread. By the time the new servers are ready, the damage is done.

So the lesson is: for a big, known spike, you cannot wait for the spike to tell you to scale.


3. Fix 1: pre-warm before the match

In their AWS re:Invent 2019 talk on scaling Hotstar for 25 million concurrent viewers, Hotstar's engineers explained that they did not rely on traditional autoscaling for these big events. Instead, they pre-warmed their infrastructure: they scaled up ahead of the expected peak.

The "Scaling for Tsunami traffic" post adds an important detail: they kept a buffer. During live events they planned capacity for about 2 million more concurrent users than the current level, so a sudden jump would land on capacity that was already running.

In simple terms:

  1. Forecast the peak for the match (based on past matches, teams playing, stage of the tournament).
  2. Scale up before the match starts, not when traffic arrives.
  3. Keep a headroom buffer above current traffic at all times during the event.
  4. Scale down carefully after the match, once traffic really drops.

Pre-warming also applies to things beyond your servers: load balancers, databases, caches and CDNs. A cold cache in front of millions of users is almost as bad as no servers at all.


4. Fix 2: scale on business metrics, not just CPU

CPU is a lagging signal. By the time CPU is high, users are already waiting.

Hotstar's engineers described using their own scaling logic based on concurrency (how many users are on the platform) and request rate, not only CPU. They planned capacity in ladders: for each level of concurrent users (one million, two million, and so on), they knew how much capacity each service needed.

Why this is smart:

  • Concurrency is a leading signal. When users join, they show up in the concurrency number immediately, before the backend gets hot.
  • Ladders make scaling predictable. Instead of guessing, the team has a tested table: "at X million users, service A needs N servers".
  • Different services scale differently. The login service, the video manifest service and the comments service each have their own ladder.

For your own systems, good business metrics might be active users, requests per second per service, queue depth, or orders per minute.


5. Fix 3: load test before fans arrive

You cannot discover your limits during the final. Hotstar's talks describe game days and large-scale load testing, using their own load generation tooling to simulate traffic beyond what they expected.

A good load-testing practice for big events includes:

  • Test beyond the forecast peak, so you know where things break.
  • Test the whole path: DNS, CDN, load balancers, APIs, databases, caches, third-party services.
  • Test the spike shape, not just the steady state. A jump from 5 million to 15 million in a few minutes is a different test from a steady 15 million.
  • Run game days: practise the event with the on-call team, dashboards and runbooks, so people know what to do.

6. Fix 4: have a plan for when it still gets too hot

Even with all of this, you plan for the worst. Common techniques for big live events:

  • Graceful degradation: turn off non-critical features (for example, heavy personalisation or some social features) to protect the main video stream.
  • Rate limiting and queuing for expensive operations like login spikes.
  • Caching aggressively at the edge, so repeated requests never reach the origin.
  • Panic buttons: pre-built switches that the on-call team can flip in seconds.

The principle is simple: the video must keep playing. Everything else can wait.


7. Known spike vs surprise spike

This is a great point to raise in interviews:

Known spike (a match, a sale) Surprise spike (viral post, news)
Can you forecast it? Yes, roughly No
Main tool Pre-scaling with a buffer Fast autoscaling, caching, degradation
Metric to watch Concurrency, requests Requests, latency, errors
Preparation Load tests, game days, runbooks Headroom, fast scaling, rate limits

Most real systems need both: pre-scaling for events you know about, and fast reactive scaling plus graceful degradation for everything else.


8. The example visuals

The "a live match adds millions of users in minutes" line is an example scenario in interview style. The ladder and buffer graphics in the Reel are simplified illustrations. The 25.3 million record (India vs New Zealand, ICC CWC 2019 semi-final) and the 18.6 million IPL 2019 final record are verified from the ICC release and Hotstar's report. The roughly 90 s and 75 s delays, the 2 million buffer, the concurrency and request-rate scaling, the ladders, pre-warming and game days come from Hotstar's engineering blog and their AWS re:Invent 2019 talk. Exact numbers may have changed since; JioHotstar today runs at a different scale.


9. How to answer this in an interview

Question: "A live match adds millions of users in minutes. Fix it."

Strong answer:

"Normal autoscaling reacts too late for this. It waits for CPU to rise, then it takes time to add servers and start the apps. Hotstar's engineers said adding infrastructure took about 90 seconds and starting containers about 75 more, while millions of users were joining. Because a match is a known event, I would pre-scale before it starts, based on a forecast, and keep a buffer above current traffic. I would scale on business metrics like concurrent users and request rate, not just CPU, with tested capacity ladders for each service. Before the event I would run load tests beyond the expected peak and a game day with the on-call team. And I would have a degradation plan to switch off non-critical features so the video keeps playing."

Follow-ups to expect:

  • What about the database and cache? Pre-warm caches, use read replicas, and protect the database from stampedes.
  • How do you forecast the peak? Past matches, the teams playing, the stage of the tournament and marketing data.
  • What if the forecast is wrong? Keep the buffer, use reactive scaling as a backup, and degrade gracefully.
  • How do you control cost? Scale down after the event, and use the ladders to avoid over-provisioning.

Sources


Preparing for a Cloud, DevOps or SRE interview? Book a Free 15-min Cloud & DevOps Interview Guidance Call with me: what to study, how to answer system-design and on-call questions, plus a CV and roadmap check 👉 topmate.io/cloudtechbydevang

About the author

  • I help engineers learn cloud, DevOps, SRE and AI in simple English, crack interviews and follow clear roadmaps. 14+ years building and running platforms on AWS, GCP, Kubernetes and Terraform. One topic a day.

No comments yet. Be the first to comment.

More from this blog