Design music streaming like Spotify

A music streaming service lets people search a catalogue of about 100 million tracks, start any of them at once on any device, and keep some for listening offline. The design has four parts: a catalogue whose metadata is read all the time and cached, filtered when it is read by what each market’s licences allow; audio files at several bit rates served by a CDN, so that the service’s own servers hand out addresses rather than bytes; downloads that are encrypted and renewed online; and a play log counted carefully enough to pay royalties from.

The bytes are the easy part. The rules are hard: licences differ by country and by date, and every counted play is money.

9.2 million streams at the evening peak, and every play is money

Ask these first, and note the answer you assume:

• How big is the catalogue? About 100 million tracks.
• Where? In many countries, each with its own licences for each track.
• At what quality? From about 24 to 320 kbit/s, and lossless for some listeners.
• Offline? Downloads on a few devices per account, renewed online now and then.
• What counts as a play? One that lasts at least a minimum time; this design assumes 30 seconds.

Spotify’s public pages give a check on the assumptions: over 100 million tracks in 184 markets (company info); quality settings from low, about 24 kbit/s, to very high, about 320 kbit/s, plus lossless (audio quality); and downloads of up to 10,000 tracks on each of up to 5 devices, which need the app to go online at least once every 30 days (listen offline).

The functional requirements: search and browse, play a track, build playlists, download for offline use, and report plays to rights holders. The non-functional ones: playback starts in about a second and never stutters on a steady connection; a track is playable exactly where and when its licence allows; and play counts are exact, because royalties are paid on them.

# The estimate sheet of a music streaming service (lesson system-design-hld/design-music-streaming). Listening is
# counted in minutes, so the streams playing at once follow from Little's law: minutes listened in a day divided by
# the minutes in a day, times the peak factor. Sizes are decimal (1 PB = 10**15 bytes); bit rates are in kbit/s.
DAY_MINUTES = 1_440
DAY_SECONDS = 86_400

LISTENERS_PER_DAY = 60_000_000
MINUTES_EACH = 100
PEAK = 2.2  # the evening peak against the daily average
TRACKS = 100_000_000  # the catalogue
TRACK_SECONDS = 200  # an average track: 3 minutes 20 seconds
# Quality levels: bit rate in kbit/s, and the share of listening at that level (assumed).
QUALITY = {"low": (24, 0.05), "normal": (96, 0.25), "high": (160, 0.50), "very high": (320, 0.20)}
LOSSLESS_KBPS = 1_000  # an assumed average for lossless files
DOWNLOADS_PER_DEVICE = 10_000
EVENT_BYTES = 200  # one play event in the log

minutes = LISTENERS_PER_DAY * MINUTES_EACH
streams = minutes / DAY_MINUTES
avg_kbps = sum(kbps * share for kbps, share in QUALITY.values())
plays = minutes * 60 / TRACK_SECONDS
copy_seconds = TRACKS * TRACK_SECONDS

print("Music streaming: the estimate sheet")
print(f"  Listening   {minutes / 10**9:.1f} billion minutes a day")
print(f"  Streams     {streams / 10**6:.1f} million at once on average, {streams * PEAK / 10**6:.1f} million at the peak")
print(f"  Bit rate    {avg_kbps:.0f} kbit/s on average over the quality mix")
print(f"  Egress      {streams * PEAK * avg_kbps * 1000 / 10**12:.2f} Tbit/s at the peak")
print(f"  Plays       {plays / 10**9:.1f} billion a day: {plays / DAY_SECONDS:,.0f}/s on average, {plays / DAY_SECONDS * PEAK:,.0f}/s at the peak")
print(f"  Play log    {plays * EVENT_BYTES / 10**9:,.0f} GB a day")
lossy = copy_seconds * sum(kbps for kbps, _ in QUALITY.values()) * 1000 / 8
print(f"  Catalogue   {lossy / 10**15:.1f} PB for the four lossy levels of every track,")
print(f"              {copy_seconds * LOSSLESS_KBPS * 1000 / 8 / 10**15:.1f} PB more for lossless copies")
for name in ("high", "very high"):
    kbps = QUALITY[name][0]
    device = DOWNLOADS_PER_DEVICE * TRACK_SECONDS * kbps * 1000 / 8
    print(f"  One device  {DOWNLOADS_PER_DEVICE:,} downloads at {kbps} kbit/s = {device / 10**9:.0f} GB")

Music streaming: the estimate sheet
  Listening   6.0 billion minutes a day
  Streams     4.2 million at once on average, 9.2 million at the peak
  Bit rate    169 kbit/s on average over the quality mix
  Egress      1.55 Tbit/s at the peak
  Plays       1.8 billion a day: 20,833/s on average, 45,833/s at the peak
  Play log    360 GB a day
  Catalogue   1.5 PB for the four lossy levels of every track,
              2.5 PB more for lossless copies
  One device  10,000 downloads at 160 kbit/s = 40 GB
  One device  10,000 downloads at 320 kbit/s = 80 GB

The sheet sets the shape of the design. At the evening peak 9.2 million streams play at once and need 1.55 Tbit/s, which only a CDN can deliver. Every play is an event, 46,000 a second at the peak. The catalogue is 1.5 PB for four lossy levels and 2.5 PB more for lossless copies, and a device full of downloads holds 40 to 80 GB.

DAY_MINUTES = 1_440


def streams_at_peak(listeners, minutes_each, peak):
    """Streams playing at once at the peak."""
    # Replace this line with your code.
    return 0


def peak_egress_gbit(streams, mix):
    """Gbit/s for `streams` streams; `mix` maps a bit rate in kbit/s to its share of listening."""
    # Replace this line with your code.
    return 0


def catalogue_bytes(tracks, track_seconds, rates):
    """Bytes to keep every track once at each bit rate in `rates`."""
    # Replace this line with your code.
    return 0


def device_bytes(downloads, track_seconds, kbps):
    """Bytes for `downloads` tracks at one bit rate."""
    # Replace this line with your code.
    return 0

import math

from sizing import catalogue_bytes, device_bytes, peak_egress_gbit, streams_at_peak

LESSON_MIX = {24: 0.05, 96: 0.25, 160: 0.50, 320: 0.20}


def near(actual, expected):
    """Within 10%, as an estimate should be."""
    return math.isclose(actual, expected, rel_tol=0.10)


def test_streams_at_peak():
    """turns minutes listened into streams at once, then applies the peak"""
    assert near(streams_at_peak(60_000_000, 100, 2.2), 9_170_000)
    assert near(streams_at_peak(5_000_000, 45, 3), 468_750)


def test_peak_egress():
    """weights each bit rate by its share of listening"""
    assert near(peak_egress_gbit(9_170_000, LESSON_MIX), 1_550)
    assert near(peak_egress_gbit(468_750, {96: 0.5, 160: 0.5}), 60)
    assert near(peak_egress_gbit(1_000_000, {320: 1.0}), 320)


def test_catalogue():
    """keeps one copy per bit rate"""
    assert near(catalogue_bytes(100_000_000, 200, [24, 96, 160, 320]), 1.5e15)
    assert near(catalogue_bytes(2_000_000, 180, [64, 128]), 8.64e12)


def test_device():
    """sizes a device's downloads at one bit rate"""
    assert near(device_bytes(10_000, 200, 160), 4.0e10)
    assert near(device_bytes(500, 240, 320), 4.8e9)

The first design: licences checked when a track plays, audio from the CDN

Follow a play through it. The app finds the track through the API servers, whose answers are already filtered by the listener’s market. To play, the API servers hand the request to the playback service, which checks the licence for this market and this moment and returns a short-lived signed address and a key. The audio comes from the CDN, unless the app’s own cache on the device still holds a recent copy, and the app reports the play to the play log, later if it is offline, where the counting stage turns plays into royalty reports. Step through one play:

The questions this design has to answer:

• How is one catalogue filtered for 184 markets without a copy per market?
• What happens at the exact second a licence starts or ends?
• How much of the catalogue must a CDN edge hold?
• How do downloads stay playable offline and still stop when a licence ends?
• How are plays counted exactly when events are retried, late or fake?
• How does search find a song typed in another script?
• What breaks on a release day, and at ten times the listeners?

One cached catalogue serves 184 markets, filtered as it is read Pro: opens with a Pro, Premium or Ultimate pass