Build and Design Real Systems

How do you generate a unique short ID? How do you avoid collisions?

How do you handle large paste sizes? (Limit size per paste, chunk storage if needed) How do you support expiration of pastes? (TTL in DB, background cleanup jobs)

How do you store billions of photos and videos reliably? How do you ensure efficient retrieval when scrolling through a feed?

How to partition data and scale it? How to structure data as folders and files?

How do you ensure low-latency message delivery (< 100ms) across millions of users? What communication protocol will you use (long polling, WebSockets)?

What data will you store for each tweet? (tweet ID, user ID, timestamp, text, media link, etc.) How will you design for billions of tweets, millions of users, and high fan-out (e.g., celebrities with millions of followers)?

How would you design the video upload pipeline - how is the video received, stored, and encoded into multiple resolutions? How do you store videos? Object store like S3 or HDFS?

How will you store queries to support prefix-based lookup? What data structure will you use for fast suggestions (Trie, inverted index, etc)? How will you keep it memory-efficient?

How to identify users to rate limit? What algorithm do you use for rate limiting?

Let's assume the logs are generated from a distributed system, e.g, an EC2 compute cluster. How to collect logs efficiently from distributed systems?

Go over how Kafka might be designed. What is the difference between Kafka and RabbitMQ?

How will you distribute the data via partitioning? How will you make sure the data is not lost (replication)?

At its core - what algorithm would you use? Count Min Sketch? or some other? How will you ensure that each new update (share) is fast?

Should it be real-time or periodic? How do you handle URL deduplication?

How will you handle fanout: push model, pull model, or hybrid? How does the system change for a user with millions of friends/followers? How will you fetch and score new content at scale - especially when a user opens the app after days?

How will you store location data? Will you use latitude-longitude, geohashing, or a spatial index (e.g., R-Tree, QuadTree)? How do you handle different types of proximity services - static (e.g., restaurants) vs dynamic (e.g., nearby friends or riders)?

What kind of metrics will you pull from the servers? How do you fetch metrics? Do you use push or pull?

Backend: How to structure the data? How to query free times in SQL? How would you store recurring events? Frontend: How will you structure the Calendar UI? When you add a new event, how does the UI show the change?

How do you deal with high throughput? When would you use a queue vs a pub-sub system?

How do you collect and present real time data? How will you ensure that all user visits are being transmitted?

How much data do we need to sort? What kind of machines do we have at our disposal?

What data structure will you use to rank items? How real-time is the ranking?

How will you do this on a single machine first? How will you schedule jobs and execute them at the right time?

What channels to support? How to capture notifications - what are the sources?

How to you decide when surge pricing is needed? How do you calculate the pricing?

How do you identify each device? Once you do, how do you keep track of the number of users watching it?

How can you utilize past rides data for calculating the ETA? How can you estimate an ETA directly from maps data?

This is more high level than most distributed systems questions. Database design - first come up with the features and then design the DB.

How will you store and retrieve different treatment UI? How will you measure the success metrics for each treatment?

How will you scrape the data, if there is no API? What constitutes a price alert? Are there any rules a user can add - rule based alerts?

How will you handle circular dependencies? How will your framework handle multithreading?

To clarify: what level are we implementing. For e.g, are we using Stripe? How will you handle the case where the payment is successful, how will you mark the payment as completed?

To clarify: what scale are we looking at - what can the peak traffic be? This is a distributed counters problem - how will you scale it as the likes grow?

What are the core functionalities of your DB's control plane? E.g, provisioning, configuration management, monitoring, scaling, backups, etc. How does your DB manage creating and managing new tables?

What methods do you use to authenticate? How do you verify a user's credentials in the backend?

How is data ingested - there are two versions of this question: via an API, and via sensors. How often do you collect data via API? If you have sensors, how do you handle real-time data?

Note: this question is without real-time editing. How will you store each document? What will the URLs look like?

How will you store and retrieve listings? How will you show listings based on location?

What metrics will you track for health? How will you collect those metrics? Will you utilize a heartbeat?

Very similar to Proximity Service (Find Nearby Friends). This problem is about maintaining a large geospatial index. How do you maintain a geospatial index of drivers?

How will you collect information from various parts of your backend? Where will you send the info and how will you store it?

How is the food delivered? Email notification? How do you store the number of vouchers left?

Backend: What does the API look like? How do you do this at scale?

How will you ingest real time data? How will you store the data, if you need to display a graph?

Similar to Design Instagram. How will you store a large number of photos?

Question Description: Design an On-call Escalation System. The levels of employees handling oncall - Developer, Manager and Director. Initial ticket always goes to a developer. If a developer is not able to handle the ticket or no developer is available, ticket gets escalated to a manager. Similarly, if no manager is available or a manager is not able to resolve the ticket, it gets escalated to director. If no one is available to take the ticket, it goes into a pending queue.

Similar to Credit Card Processing System (Question 22), but with wire transfer. Assume that you are interacting with the banks instead of with the credit card provider. How will you hire concurrent transactions to the same account? Or from the same account?

How will you push live comments to all users? How will you make sure new comments are delivered in real-time?

Details from a candidate: What would be your main considerations when designing a system that lets users know about the number of other users currently viewing a page (e.g, a hotel/accommodation site)

Related to Question 23 (Design Facebook Likes), but with live updates as an addition. How will you push live updates to millions of users?

How will you structure the migration? Which machine manages it? How do we ensure no data is lost in the process?

It is essentially the same as coordinating a bunch of machines towards doing a particular task, and tracking it. You can take the MapReduce template - master-workers, heartbeats for tracking tasks, etc.

How will you ensure that a file is hosted on the system reliably, even if one machine goes down? If a user wants to download a file, how do you locate the machine that holds it?

Description from candidate: I was asked to design a service for assembling a pc section of the Newegg website (the part that you can pick different parts of a pc to assemble it). The main requirement was that we needed a way to tell customer that different parts they picked are compatible. We have to keep track of each part's compatibility with other parts.

How do you create an ad and display it in your feed? How do you run an auction?