Coinbase Backend Engineer Interview Questions

Coinbase needs a reliable way to queue messages between its services for processing operations asynchronously.
Design a MessageQueue class that allows adding messages, retrieving the next message, and checking the size of the queue.
Class signature:
- class MessageQueue:
- def enqueue(message: str) -> None – Adds a message to the queue.
- def dequeue() -> str – Retrieves and removes the next message from the queue.
- def size() -> int – Returns the current size of the queue.
Example 1:
Input: enqueue('msg1')
Output: None
Explanation: Message is queued.Example 2:
Input: size()
Output: 1
Explanation: Queue size is currently 1 message.
Constraints:
- 1 <= len(message) <= 100

Coinbase requires a robust job scheduler to execute tasks at specific intervals. The system must handle thousands of jobs simultaneously.
Design a JobScheduler class that schedules jobs to run after a defined interval. It should allow for adding, removing, and checking job status.
Class signature:
- class JobScheduler:
- def add_job(job_id: str, interval: int) -> None – Adds a job with a specified interval (in seconds).
- def remove_job(job_id: str) -> None – Removes a job from the scheduler.
- def get_status(job_id: str) -> str – Returns the current status of a job (e.g. 'running', 'pending', 'completed').
Example 1:
Input: add_job('job1', 5)
Output: None
Explanation: Job is scheduled.Example 2:
Input: get_status('job1')
Output: 'pending'
Explanation: Job is pending execution.
Constraints:
- 1 <= interval <= 3600
- 1 <= len(job_id) <= 20

Coinbase requires a rate limiter to prevent excessive requests to its APIs, ensuring fair usage across users.
Design a RateLimiter class that limits the number of calls to a specified maxRequests over a time period of timeWindow. If the limit is exceeded, new requests should receive an error response.
Method signature:
- def is_request_allowed(user_id: str, timestamp: int) -> bool: Returns True if the request is allowed, False if it exceeds the limit.
Example 1:
Input: user_id = 'user1', timestamp = 1
Output: True
Explanation: 1 request is within limit.Example 2:
Input: user_id = 'user1', timestamp = 6
Output: False
Explanation: On timestamp 6, user has exceeded the max requests within the specified time window.
Constraints:
- 1 <= maxRequests <= 100
- 1 <= timeWindow <= 1000

Coinbase needs a system to detect fraudulent transactions by visualizing relationships in a transaction graph.
Implement a method that returns all fraudulent transaction paths in a directed graph where nodes represent accounts and edges represent transactions. You must return all paths having a maximum depth of k.
Method signature:
- def find_fraudulent_paths(graph: Dict[str, List[str]], max_depth: int) -> List[List[str]]: Returns a list of lists containing all possible paths that are at most of length max_depth.
Example 1:
Input: graph = {'A': ['B', 'C'], 'B': ['D'], 'C': ['D'], 'D': []}, max_depth = 2
Output: [['A', 'B'], ['A', 'C'], ['A', 'B', 'D'], ['A', 'C', 'D']]
Explanation: Transactions are depicted as paths based on the graph's depth constraints.Example 2:
Input: graph = {'A': ['B'], 'B': ['C'], 'C': []}, max_depth = 1
Output: [['A', 'B'], ['A']]
Explanation: Only paths staying within the given maximum depth are represented.
Constraints:
- 1 <= len(graph) <= 100
- 1 <= max_depth <= 10