Instagram API architecture: every call behind a like, a comment and a story

Every call behind a follow, a like and a comment on Virat Kohli's post, then one story uploaded in chunks, copied into 184 friends' trays and read back.

A fan and a star

  1. Here’s a fan and a star, call by call. Rajat opens Virat Kohli’s profile. The gateway checks his login and his rate limit, and passes it to Graph.
  2. Graph reads the profile from Memcache, never the database: it’s read millions of times a day. Back come 273 million followers, and links to photos on the CDN.
  3. He taps Follow, and the app sends one small request. Graph writes two rows in PostgreSQL: Virat in Rajat’s following, and Rajat in Virat’s followers, each on its own user’s shard.
  4. The app hears back, and the button says Following. Graph also tells Notify, which gathers minutes of follows into one line for Virat: Rajat and 48 others.
  5. Now his story. The app asks Story, which reads Virat’s list from Memcache: one list that every follower reads, never copied into 273 million trays.
  6. Back comes one story, and its video streams from the CDN. Once he has watched it, his app tells Story, in the background, without waiting.
  7. Story adds one viewer row in Cassandra. A view is a row, never a notification.
  8. He double-taps the post. The heart turns red at once, and Like writes one row: this post, this person. Tap again and the row is already there, so a like never counts twice.
  9. Then it adds one to a counter, one of sixty-four that are summed whenever the count is read. The app gets the new count.
  10. Notify groups the like with the rest: Rajat and 12,940 others liked your post.
  11. Last, a comment: Take a bow, King. Comment asks Safety to check it for spam, abuse, and words Virat has chosen to hide.
  12. Safety finds nothing to hide, and answers clean. So Comment saves it in PostgreSQL, under Virat’s post, and the answer comes back to the app: Rajat’s comment appears.
  13. And Notify sends Virat one more grouped line: Rajat and 1,830 others commented.
  14. Twenty-three calls: a profile read from cache, a like that counts once, and every alert to Virat grouped.

Every call, in order

  1. Rajat → Graph: GET /users/virat.kohli — Bearer tk_rj · the gateway checks his login and rate limit (REST · HTTPS)
  2. Graph → Graph: Memcache · profile:virat — hit · read millions of times a day · the database rests (Internal RPC)
  3. Graph → Rajat: 200 · 273M followers — { bio, 12 photo URLs } · the photos come from the CDN, near him (reply, REST · HTTPS)
  4. Rajat → Graph: POST /follows — { followee: virat.kohli } (REST · HTTPS)
  5. Graph → Graph: 2 rows · PostgreSQL — Rajat’s following, on his shard · Virat’s followers, on Virat’s · count + 1 (Internal RPC)
  6. Graph → Rajat: 201 · following — { following: true } (reply, REST · HTTPS)
  7. Graph → Notify: Followed → grouped push — event stream → Notify · rajat.rcb and 48 others started following you (Internal RPC)
  8. Rajat → Story: GET /stories/virat.kohli — a tap on the ring (REST · HTTPS)
  9. Story → Story: Memcache · stories:virat — one list every follower reads · never copied into 273M trays (Internal RPC)
  10. Story → Rajat: 200 · 1 story — { st_v9 · its video on the CDN } (reply, REST · HTTPS)
  11. Rajat → Story: POST /stories/st_v9/seen — sent in the background · the app never waits on it (REST · HTTPS)
  12. Story → Story: +1 viewer row · Cassandra — a view is a row, never a notification (Internal RPC)
  13. Rajat → Like: POST /posts/p_771/likes — double-tap · the heart is red before the answer (REST · HTTPS)
  14. Like → Like: 1 row · post + person — PostgreSQL · a second tap finds the row: never counted twice (Internal RPC)
  15. Like → Like: counter 7 of 64 + 1 — 64 small counters · summed when the count is read (Internal RPC)
  16. Like → Rajat: 201 · liked — { likes: 1,204,338 } (reply, REST · HTTPS)
  17. Like → Notify: Liked → grouped push — event stream → Notify · rajat.rcb and 12,940 others liked your post (Internal RPC)
  18. Rajat → Comment: POST /posts/p_771/comments — { text: Take a bow, King! } (REST · HTTPS)
  19. Comment → Safety: check comment — spam · abuse · words Virat has hidden (Internal RPC)
  20. Safety → Comment: clean — nothing to hide (reply, Internal RPC)
  21. Comment → Comment: save · PostgreSQL — c_5521 under p_771 (Internal RPC)
  22. Comment → Rajat: 201 · comment — { c_5521 } (reply, REST · HTTPS)
  23. Comment → Notify: Commented → grouped push — event stream → Notify · rajat.rcb and 1,830 others commented (Internal RPC)

A story to 184 friends

  1. Here’s one story and who sees it, call by call. Rajat’s photo goes up to Media in small chunks, so a weak signal resends only the chunk it lost.
  2. Media keeps the original in object storage, makes the smaller sizes phones download, and answers with an upload id. The photo is stored, but it isn’t a story yet.
  3. So the app asks Story to post it, and Story asks Safety to check the photo before anyone can see it.
  4. It’s clean, so Story saves it with a twenty-four-hour expiry: after that, it leaves every tray, and only Rajat can see it, in his archive. The answer comes back, and a ring appears around his photo.
  5. Story puts a Story Posted event on the stream, and the fan-out worker that picks it up asks Graph who follows Rajat.
  6. 184 people. It writes the story into each of their trays, the row of stories at the top of the app: 184 small writes, done in moments.
  7. DK opens the app. No notification came: his app asks for his tray, already filled, so it’s one quick read, and Rajat’s ring comes first.
  8. He taps it. The photo comes from the CDN, and his app tells Story he has seen it. Faf, ABD, Chris and Virat do the same: each view is one small write to Rajat’s viewers.
  9. Later, Rajat opens his story and asks who has watched. Five rows come back: seen by five.
  10. Eighteen calls: a photo stored once, copied into 184 trays, and read in moments. For a star, that copying would take hours, so a star’s stories are fetched instead.

Every call, in order

  1. Rajat → Media: POST /uploads · 8 chunks — the RCB win · a lost chunk is sent again, alone (REST · HTTPS)
  2. Media → Media: original + 3 sizes — original → object storage · the sizes phones download (Internal RPC)
  3. Media → Rajat: 201 · upload u_93 — stored · not a story yet (reply, REST · HTTPS)
  4. Rajat → Story: POST /stories — { upload: u_93 } (REST · HTTPS)
  5. Story → Safety: check photo — before anyone can see it (Internal RPC)
  6. Safety → Story: clean — nothing to hide (reply, Internal RPC)
  7. Story → Story: save · expires in 24 h — then only Rajat sees it, in his archive (Internal RPC)
  8. Story → Rajat: 201 · posted — { st_r1 } (reply, REST · HTTPS)
  9. Story → Fan-out: StoryPosted — via the event stream (Internal RPC)
  10. Fan-out → Graph: followers of rajat.rcb — who should get it (Internal RPC)
  11. Graph → Fan-out: 184 people — rajat.rcb’s followers (reply, Internal RPC)
  12. Fan-out → Fan-out: 184 tray writes — Cassandra · one small write per follower, in moments (Internal RPC)
  13. Friends → Story: GET /tray — DK opens the app · no notification came (REST · HTTPS)
  14. Story → Friends: 200 · Rajat first — filled when he posted · one quick read · ranked for DK (reply, REST · HTTPS)
  15. Friends → Story: POST /stories/st_r1/seen — the photo from the CDN · Faf, ABD, Chris, Virat the same (REST · HTTPS)
  16. Story → Story: 5 viewer rows — one small write each · never pushed to Rajat (Internal RPC)
  17. Rajat → Story: GET /stories/st_r1/viewers — his own story, opened (REST · HTTPS)
  18. Story → Rajat: 200 · seen by 5 — DK · Faf · ABD · Chris · Virat (reply, REST · HTTPS)