Meta Backend Engineer Interview Questions

I would first clarify whether the limit is per user, per token, per IP, or per endpoint, because that changes the storage and enforcement strategy. My default choice would be a token bucket since it allows short bursts while still enforcing a long-term cap. I would place enforcement as close to the edge as possible so the backend does not waste work on requests that should be rejected. The reason I choose this approach is that it is practical, easy to reason about, and works well under real traffic spikes. I would also discuss where the counter state lives, how to keep it consistent across servers, and what happens if the limiter store fails.

I would make the request idempotent by attaching an idempotency key to it. The server would store that key along with the result or the current processing state, and if the same key arrives again, the server would return the original outcome instead of doing the work twice. The reason I choose this approach is that retries are unavoidable in distributed systems, so correctness has to survive duplicate requests. I would also think about how long to keep the keys, what to do if the first attempt fails halfway through, and how to make the implementation safe under concurrency. This pattern is especially useful for payments, orders, and other state-changing actions.

I would start by clarifying whether the service needs custom aliases, expiration, click analytics, or abuse prevention. A basic design would store the mapping from short code to original URL in a durable database and use a very fast redirect path for reads. To scale better, I would cache hot links and shard the storage so link creation and lookup spread across nodes. The reason I choose this split is that redirect traffic is usually much higher than write traffic. I would also mention collision handling, rate limiting, and what should happen if a shard becomes unavailable.

I would first verify that the repeated reads are really the bottleneck by checking metrics and query traces. If the same data is being read often, I would add a cache in front of the database and decide on an invalidation strategy that matches the freshness requirement. The reason I choose caching is that it can reduce database load dramatically without changing the public API. I would also think about hot keys, cache stampedes, and whether some data should be precomputed instead of cached. If the interviewer wants more depth, I would compare in-memory caching, distributed caching, and read replicas.

I would separate event intake from channel delivery. The system would accept a notification event, decide which users should get it, and fan out to workers for email, push, and in-app delivery. I would keep delivery asynchronous so a slow provider does not block the whole system. The reason I choose this approach is that each channel has different latency, retry, and failure behavior, so separating them keeps the design cleaner. I would also discuss retries, deduplication, user preferences, and dead-letter queues.