Stripe Software Engineer Interview Questions

To improve user experience, Stripe needs a data structure to represent users' transaction histories in a way that allows for efficient retrieval and management.
Problem statement: Design a transaction history structure where each transaction has an int transactionId, double amount, string date, and nested transactions. Implement methods to add a transaction and to retrieve the transaction with the highest amount.
- addTransaction(transactionId: int, amount: double, date: string): void: Add a transaction to the history.
- getMaxTransaction(): (int, double, string): Returns the ID, amount, and date of the transaction with the highest amount.
Example 1:
Input: addTransaction(1, 100.50, '2023-03-01')
Output: NoneExample 2:
Input: addTransaction(2, 200.75, '2023-03-02')
Output: NoneInput: getMaxTransaction()
Output: (2, 200.75, '2023-03-02')
Constraints:
- 1 <= transactionId <= 10^6
- 0 <= amount <= 10^6
- date follows the format 'YYYY-MM-DD'.

In order to protect our APIs from abuse and to ensure fair usage, Stripe requires a sliding window rate limiter that tracks the number of requests for each API key over a given time period.
Problem statement: You need to implement a rate limiter that allows a specified number of requests per minute (e.g., 100 requests) for each unique string apiKey. Ensure that the rate limiter has a method to track requests and should return a boolean indicating whether the request is allowed.
- trackRequest(apiKey: string): boolean: Returns true if the request is allowed, false otherwise.
Example 1:
Input: trackRequest('key1')
Output: true
Explanation: The request is allowed.Example 2:
Input: trackRequest('key1') (100 times)
Output: true (first 100 calls)
Output: false (101st call)
Constraints:
- 1 <= apiKey.length <= 100
- Rate limit can be bursty but should not exceed specified limits.
- Simulate up to 10^6 requests.

Stripe needs a robust payment processing API that can handle a variety of transaction types, while ensuring security, reliability, and scalability.
Problem statement: Design a RESTful API for processing payments, with endpoints for creating charges, retrieving payment status, and listing transactions.
- POST /charges: Creates a new charge.
- GET /charges/{chargeId}: Retrieves the status of a specific charge.
- GET /charges: Lists all transactions based on pagination parameters.
Example 1:
Input: POST /charges with body {amount: 1000, currency: 'usd', source: 'tok_visa'}
Output: 201 Created with body {id: 'ch_1FZh2I2eZvKYlo2C4H2gGm7', status: 'succeeded'}Example 2:
Input: GET /charges/ch_1FZh2I2eZvKYlo2C4H2gGm7
Output: 200 OK with body {id: 'ch_1FZh2I2eZvKYlo2C4H2gGm7', status: 'succeeded'}
Constraints:
- Each charge has a unique chargeId, an amount in cents, and a currency string, e.g., 'usd'.

To optimize the performance of API calls, Stripe needs an efficient caching layer that stores the most requested API responses based on a least recently used (LRU) algorithm.
Problem statement: Design and implement an LRU cache with methods to get a cached value and to put a value into the cache.
- get(key: int): int: Retrieves the value of the key if the key exists in the cache, otherwise returns -1.
- put(key: int, value: int): void: Updates the value of the key if the key exists, and if the cache reaches its capacity, it should invalidate the least recently used item before inserting a new item.
Example 1:
Input: put(1, 1)
Output: NoneInput: put(2, 2)
Output: NoneInput: get(1)
Output: 1Input: put(3, 3)
Output: NoneInput: get(2)
Output: -1
Constraints:
- cache capacity is a positive integer.
- 1 <= key, value <= 10^4.