Amazon Backend Engineer Interview Questions

I would first ask how many keys we need to support, how accurate the expiration needs to be, and whether expired values should disappear immediately or lazily. My default design would store each key with a value and an expiration timestamp, then remove expired entries on access and with a background cleanup process. The reason I choose this approach is that it keeps reads fast and avoids scanning the whole store on every request. I would also think about what happens when many keys expire at once, because that can create a cleanup spike. If the interviewer wants more depth, I would discuss indexing expirations separately so the sweeper does less work.

I would make the checkout request idempotent by using an idempotency key. When the first request arrives, I would store that key with the created order or the current processing state, and if the same key comes again I would return the original result instead of creating a second order. The reason I choose this approach is that retries are common in real systems and the business flow has to stay correct even when the network is unreliable. I would also think about how long to keep the keys and how to handle partial failures. This is especially important for payments and order placement.

I would first clarify whether the IDs need to be roughly sortable, globally unique, or both. A common approach is to combine a timestamp, a machine identifier, and a sequence number so each node can generate IDs independently without coordination on every request. The reason I choose this style is that it scales well and avoids a central bottleneck. I would also discuss clock skew, sequence overflow, and what happens if a node restarts. If the interviewer asks, I would mention that the exact format depends on whether ordering or compactness matters more.

I would first clarify the channels, delivery priority, and whether notifications should be pushed immediately or batched. My design would separate event intake, recipient selection, and channel-specific delivery workers so the system can scale each part independently. I would keep the delivery path asynchronous because notification traffic can spike and should not block the main request flow. The reason I choose this design is that fan-out becomes much easier when the system can queue work and process it in parallel. I would also discuss retries, deduplication, user preferences, and dead-letter queues.

I would first verify that the repeated reads are really the bottleneck by checking metrics and query traces. If the same data is read often, I would add caching, either in memory or through a distributed cache, depending on how shared the data is. The reason I choose caching is that it can reduce database load dramatically when the access pattern is repetitive. I would also think about invalidation, stale data risk, and whether the data is safe to cache at all. If the interviewer wants a broader answer, I would mention read replicas or precomputed aggregates as alternatives.