Estimation: numbers that pick the design

• Write each step on the board. The interviewer checks the method, not the digits.
• Split reads from writes early. They scale in different ways.
• Storage counts one copy. Say the replica count as a separate multiplier.

Ten million users at 15 requests each is 150 million a day. That is about 1,700 a second on average and 17,000 at a 10× peak.

I round to powers of ten and say the rounding out loud.

Grey rows: Peter Norvig's published timing table, quoted as orders of magnitude. Coloured rows: measured in the lab, one client on the same laptop, median of 2,000 calls.

Memory is 100 nanoseconds, a call on the same network is about 100 microseconds, and a round trip across an ocean is 150 milliseconds.

Postgres 16 and Redis 8 on a 16-thread laptop, 32 clients, 3 seconds per run. Other test runs shared the machine. The storage ceiling is from the Amazon RDS documentation.

One Postgres node does about 10⁵ key reads and 10⁴ committed writes a second. I plan with the lower power of ten.

Peak writes, peak reads and bytes each have a line for one node. Whichever crosses its line first decides my first design step.

estimate(users, per_user, reads_per_write, bytes, years, peak):
  per_day  = users × per_user                  // requests a day
  writes   = per_day / (1 + reads_per_write1)
  reads    = per_day - writes
  avg      = per_day / 86,4002                  // seconds in a day
  peak_qps = avg × peak3
  storage  = writes × bytes × 365 × years      // one copy4
  egress   = peak reads a second × bytes × 85   // bits a second

  read_nodes = ceil(peak reads / 100,0006)
  shards     = max(ceil(peak writes / 10,000), ceil(storage / 10 TB7))
  IF shards > 1:          step = 3             // shard by key
  ELSE IF read_nodes > 1: step = 2             // replicas and a cache
  ELSE:                   step = 1             // one primary

// Estimate turns daily users into the numbers of the round.
func Estimate(in Input, lim Limits) Output {
  var o Output
  o.RequestsPerDay = in.DailyUsers * in.ActionsPerUser
  o.WritesPerDay = o.RequestsPerDay / (1 + in.ReadsPerWrite)
  o.ReadsPerDay = o.RequestsPerDay - o.WritesPerDay

  o.AvgQPS = o.RequestsPerDay / SecondsPerDay
  o.PeakQPS = o.AvgQPS * in.PeakFactor
  o.AvgWriteQPS = o.WritesPerDay / SecondsPerDay
  o.AvgReadQPS = o.ReadsPerDay / SecondsPerDay
  o.PeakWriteQPS = o.AvgWriteQPS * in.PeakFactor
  o.PeakReadQPS = o.AvgReadQPS * in.PeakFactor

  o.BytesPerDay = o.WritesPerDay * in.ObjectBytes
  o.BytesTotal = o.BytesPerDay * DaysPerYear * in.RetentionYears
  o.IngressBitsSec = o.PeakWriteQPS * in.ObjectBytes * 8
  o.EgressBitsSec = o.PeakReadQPS * in.ObjectBytes * 8

  o.ReadNodes = atLeastOne(o.PeakReadQPS / lim.ReadsPerNode)
  o.WriteShards = atLeastOne(o.PeakWriteQPS / lim.WritesPerPrimary)
  o.ByteShards = atLeastOne(o.BytesTotal / lim.BytesPerNode)
  o.Shards = max(o.WriteShards, o.ByteShards)
  switch {
  case o.Shards > 1:
    o.Step = 3 // shard the primary
  case o.ReadNodes > 1:
    o.Step = 2 // add read replicas and a cache
  default:
    o.Step = 1 // one primary and a standby
  }
  return o
}

func atLeastOne(x float64) int {
  return max(1, int(math.Ceil(x)))
}

Every number on my board comes from one of these lines, so I can show the interviewer where it came from.

Nodes each number needs. The largest shard count wins. Inputs for each preset:

booking

10 M users × 15, 99 : 1 reads, 1 kB, 5 yr, 10× peak

news feed

50 M users × 100, 100 : 1 reads, 100 B, 1 yr, 5× peak

url shortener

100 M users × 11, 10 : 1 reads, 500 B, 10 yr, 3× peak

chat

50 M users × 80, 1 : 1 reads, 200 B, 1 yr, 2× peak

The URL shortener is small in requests but large in bytes. Ten years of links decide its shards.

I give the number, the arithmetic behind it, and the decision it changes.

Capacity measured on one laptop. Read it as orders of magnitude. A server with durable storage commits slower, and a larger server reads faster.

My numbers put this design at step 1. I would add replicas when peak reads pass about 100,000 a second, and shard when writes pass 10,000.