CDN Image Delivery Under 50ms

Explain how a CDN serves images to users worldwide in under 50ms.

System Designintermediate

// interview question

Explain how a CDN serves images to users worldwide in under 50ms.

Sample answer

A CDN (Content Delivery Network) places copies of your images on hundreds of edge servers distributed across the globe. When a user requests an image, DNS routes them to the nearest edge server (often called a Point of Presence or PoP), typically within 20-50km. If that edge server already has the image cached, it serves it directly from memory or local SSD, which takes 1-5ms of server processing plus the network round-trip to the nearby PoP, totaling well under 50ms. If the edge does not have the image (a cache miss), it fetches from a regional mid-tier cache or the origin server, caches the response, and then serves it. The key is that after the first request, all subsequent users in that region get the cached copy. CDNs also use anycast routing, where multiple servers share the same IP address and the network layer routes packets to the closest one, and persistent TCP/TLS connections between PoPs to minimize connection setup overhead.

Why this matters

This question tests whether candidates understand the physical constraints of network latency and how CDNs work around them by moving data closer to users. Light in fiber travels at roughly 200,000 km/s, so a round-trip from New York to London (11,000 km) takes at least 55ms just from physics. No amount of server optimization can beat the speed of light, which is why geographic distribution is the only solution for global sub-50ms delivery. Interviewers want to see that you grasp the caching hierarchy, cache invalidation challenges, and the tradeoffs between freshness and speed.

Code examples

CDN caching hierarchy and request flow

text

User in Tokyo requests: https://cdn.example.com/images/hero.jpg

1. DNS Resolution (anycast)
   -> DNS returns IP 198.51.100.1
   -> Anycast routes to nearest PoP: Tokyo edge server

2. Edge Server (Tokyo PoP)
   Cache HIT?  -> Serve from memory/SSD (1-5ms processing)
                  Total latency: ~10-20ms (nearby network hop)

   Cache MISS? -> Check regional mid-tier cache

3. Mid-Tier Cache (Asia-Pacific region, e.g. Singapore)
   Cache HIT?  -> Return to Tokyo edge, cache locally, serve user
                  Added latency: ~30-60ms for regional hop

   Cache MISS? -> Fetch from origin

4. Origin Server (US-East)
   -> Serves the image
   -> Mid-tier caches it (TTL: 24 hours)
   -> Edge caches it (TTL: 1 hour)
   -> User gets the image
   Total first-request latency: ~200-300ms
   All subsequent Tokyo requests: ~10-20ms

Nginx edge cache configuration

nginx

# Simplified CDN edge server config
proxy_cache_path /var/cache/cdn levels=1:2
    keys_zone=images:100m
    max_size=50g
    inactive=24h
    use_temp_path=off;

server {
    listen 443 ssl http2;
    server_name cdn.example.com;

    location /images/ {
        proxy_cache images;
        proxy_cache_valid 200 1h;
        proxy_cache_valid 404 1m;

        # Serve stale content while revalidating in background
        proxy_cache_use_stale updating error timeout;
        proxy_cache_background_update on;

        # Add cache status header for debugging
        add_header X-Cache-Status $upstream_cache_status;
        add_header Cache-Control "public, max-age=3600";

        # Conditional requests to origin
        proxy_cache_revalidate on;

        proxy_pass http://origin-servers;
    }
}

Inspect CDN cache headers

bash

# Check if an image is served from cache
curl -sI https://cdn.example.com/images/hero.jpg | grep -E '(X-Cache|Age|Cache-Control|CF-Cache)'

# Example output:
# X-Cache: HIT
# Age: 3542           <- seconds since edge cached it
# Cache-Control: public, max-age=3600
# CF-Cache-Status: HIT   <- Cloudflare-specific header

# Purge a specific cached image (Cloudflare API example)
curl -X POST "https://api.cloudflare.com/client/v4/zones/{zone_id}/purge_cache" \
  -H "Authorization: Bearer $CF_TOKEN" \
  -H "Content-Type: application/json" \
  --data '{"files":["https://cdn.example.com/images/hero.jpg"]}'

Common mistakes to avoid

Not understanding that network latency is bounded by the speed of light, so geographic proximity is the primary optimization
Confusing CDN caching with browser caching or application-level caching
Ignoring cache invalidation, which is the hardest part of running a CDN
Thinking all requests hit the origin server and the CDN just provides 'faster pipes'
Forgetting about cache warming and the cold-start problem when deploying to new PoPs

Likely follow-ups

How do you invalidate or purge cached content across all edge servers when the original image changes?
What is the difference between push-based and pull-based CDN strategies?
How would you handle personalized or user-specific content that cannot be cached at the edge?
What role does HTTP/2 and HTTP/3 (QUIC) play in reducing latency for CDN-served content?
How do you decide on TTL values for different types of content?

Answer out loud first, then check yourself against the model answer.

Practice all Mid-Level questions More System Design questions

#system-design#cdn#caching#networking#performance#latency

Also worth your time on this topic

Quiz

Back-of-the-Envelope Estimation Quiz

The napkin-math skill that makes or breaks a system design interview: turning users into QPS, data into storage, traffic into bandwidth, and knowing the latency numbers every engineer should have memorised.

16-22 minutes

Interview

DNS Resolution When You Type a URL

Walk me through what happens when you type a URL and press Enter, focusing specifically on the DNS resolution process.

junior

Article

How Does It Work So Fast? The Engineering Behind Instant UI Responses

Credit card validation, username checks, autocomplete, URL shorteners - they all feel instant. Here is what is actually happening under the hood in each case.

CDN Image Delivery Under 50ms

More System Design interview questions

Also worth your time on this topic

Back-of-the-Envelope Estimation Quiz

DNS Resolution When You Type a URL

How Does It Work So Fast? The Engineering Behind Instant UI Responses