Google Backend Engineer Interview Questions

I would use a sliding window with two pointers and a frequency map. I would expand the right side until the window contains all required characters, then shrink the left side as much as possible while keeping the window valid. The reason I choose this approach is that it processes each character a limited number of times, so it stays linear. I would also keep track of how many required characters are still missing, because that makes validity checks easier. Edge cases include no valid window, repeated required characters, and an empty input string.

I would first clarify the latency target, because a few seconds and sub-second updates lead to very different designs. My default would be a streaming ingestion pipeline that groups data into short time windows, computes aggregates, and pushes updates to a fast read store. I would not query raw data on every dashboard refresh because that would be too expensive at scale. The reason I choose streaming aggregation is that it keeps the dashboard responsive without forcing every client request to do heavy computation. I would also discuss sampling, caching, and how to handle late-arriving events.

I would accept the upload request, store the file in durable storage, and hand off the heavy work to a background worker through a queue. That way, the user does not have to wait for processing like scanning, resizing, or validation to finish in the request path. The reason I choose asynchronous processing is that it keeps the API fast and makes the system more resilient to spikes. I would also think about retries, idempotency, and a way for the client to check processing status. If the file is large, I would also consider multipart or resumable uploads.

I would add an idempotency key to the request and store the key together with the result or processing status. If the same request comes again, the service can return the previous result instead of doing the work twice. The reason I choose this approach is that retries are common in real systems, especially when networks are unreliable. I would also think about key expiration, storage cost, and whether the operation can safely be repeated. This is especially important for payments, orders, and other state-changing actions.

I would run the cycle check from every unvisited node, not just one starting point. For a directed graph, I would use DFS with a recursion stack or color marking; for an undirected graph, I would track the parent node so I do not mistake the edge back to the parent for a cycle. The reason I choose this approach is that disconnected components need independent traversal. The time complexity stays O(V + E) because every node and edge is still visited at most once. I would also mention that union-find is another option for undirected graphs.