Interview Perspective

Do not guess at scope. Confirm whether Stories, Reels, Search, or DMs are included, whether the feed is chronological or personalized, and whether accounts can be private.

• Are Stories included? Reels? Search? DMs? — Tests scope control — a strong candidate confirms these are excluded rather than silently assuming.
• Is feed chronological or personalized? — Tests whether the candidate recognizes this changes candidate generation and ranking depth needed.
• Are accounts public or private? — Tests whether visibility rules are treated as a first-class requirement, not an afterthought.

Explain direct-to-object-storage upload with a temporary authorized target, per Media Upload Architecture — bytes should not pass through the application server.

• Would bytes pass through your application server? — Tests whether the candidate defaults to a proxied design or recognizes the bandwidth-proxy problem.
• What happens on a poor mobile connection? — Tests awareness of chunked/resumable upload rather than a single all-or-nothing transfer.
• How do you resume after 80% uploaded? — Tests whether the candidate can describe resuming from the last acknowledged chunk, not restarting.
• How do you verify integrity? — Tests knowledge of checksum validation at completion time.

Walk through the async pipeline and state model in Media Processing Pipeline — UPLOADING → PROCESSING → READY, with a FAILED path.

• When does the post become visible? — Tests whether the candidate ties visibility explicitly to the READY state rather than assuming immediate distribution.
• What if transcoding takes two minutes? — Tests whether async processing is the answer, not blocking the upload response.
• What if one rendition fails? — Tests partial-failure reasoning within a single processing job.
• How do retries avoid duplicate output? — Tests idempotent processing — reprocessing the same input should not produce conflicting variants.
• What if the file is corrupt? — Tests the FAILED/quarantine path, per Corrupt / Poison Media.

Explain edge caching, cache hierarchy, and request coalescing, per Object Storage & CDN Delivery.

• What happens on an edge miss? — Tests basic understanding of origin fetch-and-fill.
• What if many edges miss simultaneously? — Tests awareness of the cold-CDN-cache scenario specifically, per Viral Media With Cold CDN Cache.
• What if CDN is partially unavailable? — Tests the distinction from a cold-cache surge, per CDN Degradation.
• How do you delete cached media? — Tests whether the candidate separates application-level unavailability, cache invalidation, and underlying object deletion as three distinct steps.

Explain both adjacency directions and access-pattern-driven storage, per Social Graph Storage.

• How do you get everyone I follow? — Tests the following-lookup direction.
• How do you get all followers of an author? — Tests the follower-lookup direction — a different access pattern from the above.
• What if the author has 50M followers? — Tests awareness of high-degree nodes and paginated/streamed reads rather than loading the full list.
• Do you need a graph database? — Tests whether the candidate treats this as automatic or reasons about it as one of several viable access-pattern-driven choices.
• What happens on unfollow? — Tests recognition that this changes future fanout but doesn't retroactively rewrite already-delivered feed entries.

Walk through fanout-on-write vs fanout-on-read vs hybrid, per Hybrid Fanout Strategy.

• Why not calculate everything at read time? — Tests whether the candidate can explain the cost growing with follow count, not just assert it's slow.
• Why not fanout every post at write time? — Tests understanding of write amplification for high-fanout accounts.
• What happens for celebrity accounts? — Tests the hot-user problem specifically.
• How do you decide push vs pull? — Tests awareness of the Fixed vs Adaptive Fanout Classification decision.

Explain idempotent feed writes keyed on (feed_owner_id, post_id), per Fanout Queue & Workers.

• How do you prevent duplicate feed entries? — Tests whether the candidate names the specific logical uniqueness key, not just 'idempotent.'
• What if it crashes halfway through? — Tests checkpointed batch processing rather than one giant atomic job.
• How do you resume? — Tests whether the candidate connects this to resuming from the last checkpoint.
• What if the queue is six hours behind? — Tests controlled backlog draining, per Fanout Backlog / Partial Delivery.

Separate candidate generation from ranking, per Feed Candidate Generation.

• Every post from every followed account? — Tests whether the candidate recognizes ranking never operates over the full corpus.
• How do you bound candidate count? — Tests the merge/dedup/eligibility-filtering steps before ranking.
• Where does deduplication happen? — Tests whether the candidate names stable post-ID dedup specifically.
• Where are private/deleted posts filtered? — Tests the connection to Post Lifecycle, Privacy & Visibility.
• What if ranking is slow? — Tests timeout-budget reasoning, per Ranking Slow or Unavailable.

Explain why offset pagination breaks and present cursor-based alternatives, per Feed Pagination.

• Why not OFFSET/LIMIT? — Tests whether the candidate explains instability against a changing dataset, not just 'it's slow.'
• What happens when new posts arrive? — Tests reasoning about shifting offsets and stable cursors as the fix.
• What if ranking changes between pages? — Tests recognition that ranked-feed pagination is genuinely harder than chronological pagination.
• How do you avoid duplicates? — Tests knowledge of deduplication as a practical mitigation for live re-ranking.

Explain serving-time validation, per Post Lifecycle, Privacy & Visibility — correctness comes from read-time filtering, not synchronous cleanup everywhere.

• Do you synchronously remove 10M entries? — Tests whether the candidate recognizes this as unnecessary and expensive, proposing async cleanup instead.
• What if the author blocks the reader? — Tests generalization of the same read-time filtering mechanism to a different visibility trigger.
• What if the account becomes private? — Tests the same generalization again.
• What about CDN-cached media? — Tests knowledge of the three separate deletion steps in Object Storage & CDN Delivery.

Separate logical idempotency from aggregate-counter scalability, per Likes, Counters & Comments.

• How do you prevent duplicate likes from retries? — Tests the (user_id, post_id) uniqueness key specifically.
• Would you increment one DB row? — Tests recognition of the hot-row problem, per Like Counter Hotspot.
• Is the displayed count exact? — Tests acceptance of eventual consistency for a non-critical aggregate.
• How does unlike work? — Tests recognition of unlike as reversal with the same eventual-aggregate-update pattern.

Explain derived-state rebuild, per Feed Store State Lost.

• Is feed state source of truth? — Tests the source-of-truth-vs-derived-state distinction, per Data Ownership & Storage Model.
• Would you fanout-on-read for every request? — Tests whether the candidate recognizes this recreates the original scaling problem rather than degrading gracefully.
• How do you prevent database overload? — Tests rate-limited rebuild and bounded read-time composition as the answer.
• How do you rebuild feeds? — Tests a concrete rebuild source (recent posts from followed accounts), not a vague 'recompute it.'

Tests recognition that this stresses Media Processing Pipeline capacity specifically — a backlog problem bounded by CPU/GPU/storage, not something autoscaling alone fully solves.

• How would you prioritize the backlog? — Tests fairness reasoning across many uploaders rather than strict FIFO regardless of size.

Tests whether the candidate recognizes this stresses the pull/read side of feed composition — the opposite pressure point from the celebrity write-side problem.

• Does this change your fanout classification for that user's followed accounts? — Tests whether the candidate treats follower count and following count as different axes of the same fanout-cost question.

Combine Viral Post / Hot User Surge with general read-surge handling across cache, CDN, and ranking simultaneously.

• Which layer absorbs most of that surge? — Tests whether the candidate names cache/replicas/CDN specifically, not just 'the system handles it.'

Tests recognition that this compounds several scenarios at once — cold CDN cache pressure, hot-user read pressure, and elevated ranking/like-counter load — not a single isolated failure mode.

• Would your individual mitigations still work together? — Tests reasoning about compounding failure modes rather than reciting each mitigation in isolation.

Tests connection to Media Processing Backlog — a capacity problem communicated via the explicit PROCESSING state, not a correctness failure.

• What does the user see in the meantime? — Tests whether the candidate proposes an honest PROCESSING indicator rather than a silent failure or fake success.

Tests reasoning about a stale or partially-evicted feed store, and whether the candidate proposes read-time composition or a partial rebuild rather than assuming the precomputed feed is simply ready to serve.

• Would you keep pushing fanout to inactive users the whole time? — Tests cost-awareness — pushing fanout to a user who never reads it is pure waste, worth reconsidering for very inactive accounts.

Tests prioritization under constraint — a strong answer identifies that hybrid fanout classification, a full ranking model, multi-layer caching, and cursor-based ranked pagination are all scale-justified investments that could be deferred, while durable post storage, basic fanout-on-write, and asynchronous media processing cannot.

• At what point would you introduce each deferred piece? — Tests whether the candidate ties each simplification to a specific scale threshold rather than treating the MVP as a permanent design.

Tests whether the candidate recognizes this removes most of Feed Ranking Pipeline's complexity while leaving fanout, candidate generation, and pagination largely intact — ranking is an additive layer, not a foundational requirement.

• Does pagination get simpler too? — Tests recognition that chronological pagination is genuinely simpler than ranked-feed pagination specifically.

Tests whether the candidate keeps recommended content as one additional candidate source rather than redesigning the whole pipeline, while explicitly not expanding this into a full recommendation-system design.

• Would ranking need to change? — Tests whether the candidate recognizes ranking would need a signal to distinguish followed-account posts from recommended ones, without over-engineering the answer.