Stripe Software Engineer System Design Questions

Background: Stripe is a payment processing platform that requires efficient handling of various payment methods to support business transactions. The PaymentProcessor class will manage different types of payments, ensuring they can be processed securely and reliably.Requirements:
1. The class must support initiating transactions with different payment methods (e.g., credit card, bank transfer).
2. It must implement methods to handle transaction approvals and declines.
3. The processor should maintain a log of all transactions.
4. Implement a method to retrieve transaction details using a unique transaction ID.
5. Ensure that all methods handle concurrency appropriately.Class API:

• initiate_payment(payment_method: str, amount: float) -> str

- Initiates a payment and returns a transaction ID.

• approve_transaction(transaction_id: str) -> bool

- Approves the transaction and returns success status.

• decline_transaction(transaction_id: str) -> bool

- Declines the transaction and returns success status.

• get_transaction(transaction_id: str) -> dict

- Returns the transaction details for the given ID.Example 1:
Input:

• initiate_payment('credit_card', 100.00) → Output: transaction_id: 'txn_12345'

Explanation: The payment is initiated successfully, returning a unique transaction ID.Example 2:
Input:

• approve_transaction('txn_12345') → Output: True

Explanation: The transaction is approved.Constraints:

• Maximum of 1000 transactions in memory at any one time.


• Methods must be thread-safe to handle concurrent requests.

Background: Stripe handles high volumes of payment transactions, necessitating an effective distribution of incoming traffic to ensure reliability and performance. Designing a load balancer helps manage requests efficiently across multiple servers.
Requirements:
1. Support for multiple instances of back-end servers to distribute traffic.
2. Health checks to monitor the status of the servers.
3. Algorithms for load distribution (e.g., round-robin, least connections).
4. Ability to handle sticky sessions when required.
5. Logging functionality for monitoring and analytics.
Class API:

• def add_server(self, server: str) -> None:

Adds a new server to the load balancer.

• def remove_server(self, server: str) -> None:

Removes a server from the load balancer.

• def get_next_server(self) -> str:

Returns the next server to which a request should be directed.

• def health_check(self) -> List[str]:

Returns a list of healthy servers.

• def log_request(self, server: str) -> None:

Logs a request sent to a server for analytics.
Example 1:
Input:

load_balancer = LoadBalancer()  
load_balancer.add_server("server1")  
load_balancer.add_server("server2")  
load_balancer.get_next_server()

Output:
"server1"
Explanation:
The load balancer routes to server1 on the first call.
Example 2:
Input:

load_balancer.add_server("server3")  
load_balancer.get_next_server()  
load_balancer.get_next_server()

Output:
"server2"
Explanation:
After server1, the next in line is server2 followed by server3.
Constraints:

• Maximum of 100 servers can be added.


• Health checks should occur every 10 seconds.


• Must support up to 1000 simultaneous requests.

Background: Stripe processes millions of transactions every day and needs an efficient system to handle various types of transactions reliably. This class will simulate the processing of these transactions in a way that can be used for both testing new features and validating current functionality.
Requirements:
1. process_transaction(transaction_id: str, amount: float) - Processes a transaction and updates internal state.
2. get_transaction_status(transaction_id: str) - Retrieves the status of a specific transaction.
3. refund_transaction(transaction_id: str) - Issues a refund for a completed transaction and updates the status.
4. Internal mechanisms to track successful, failed, and refunded transactions.
5. Ensure thread-safe operation when processing transactions concurrently.
Class API:

• process_transaction(transaction_id: str, amount: float) -> None - Processes the transaction identified by transaction_id with the specified amount.


• get_transaction_status(transaction_id: str) -> str - Returns the status of the specified transaction.


• refund_transaction(transaction_id: str) -> bool - Refunds the transaction and returns True if successful, False otherwise.

Example 1:
Input: tp = TransactionProcessor()
Sequence:
tp.process_transaction('txn_001', 100.0)
tp.get_transaction_status('txn_001') → Output: 'successful'
Explanation: The transaction is processed and marked as successful.
Example 2:
Input: tp = TransactionProcessor()
Sequence:
tp.process_transaction('txn_002', 50.0)
tp.refund_transaction('txn_002')
tp.get_transaction_status('txn_002') → Output: 'refunded'
Explanation: The transaction is processed and subsequently refunded.
Constraints:

• Maximum 100,000 transactions can be processed.


• All transaction IDs are unique strings.


• Operation must handle concurrent processing without data corruption.

Background: Stripe runs numerous marketing campaigns to attract new customers and retain existing ones. A robust system is necessary to organize, track, and analyze the effectiveness of these campaigns. This helps in optimizing marketing strategies and ensuring a good return on investment.
Requirements:
1. Ability to create a new campaign with a unique identifier.
2. Track the status of the campaign (active, paused, completed).
3. Fetch all campaigns within a specified date range.
4. Calculate total spend and returns for a particular campaign.
5. List all campaigns with a specific status.
6. Allow pausing and resuming campaigns.
Class API:

• def create_campaign(id: str, name: str, budget: float, start_date: str, end_date: str) -> None: Creates a new campaign.


• def update_campaign_status(id: str, status: str) -> None: Updates the status of the campaign.


• def fetch_campaigns(start_date: str, end_date: str) -> List[Dict]: Returns all campaigns within the date range.


• def calculate_returns(id: str) -> float: Calculates returns for the specific campaign based on its spend and performance metrics.


• def list_campaigns_by_status(status: str) -> List[Dict]: Lists all campaigns with a specified status.


• def pause_campaign(id: str) -> None: Pauses an active campaign.


• def resume_campaign(id: str) -> None: Resumes a paused campaign.

Example 1:
Input: create_campaign('001', 'Holiday Sales', 10000.0, '2023-11-01', '2023-11-30')
Output: Campaign created.
Explanation: A new marketing campaign 'Holiday Sales' has been created with the specified budget and dates.
Example 2:
Input: pause_campaign('001')
Output: Campaign paused.
Constraints:

• Maximum 1000 campaigns can be created.


• Budget must be a positive float.


• Date format must be 'YYYY-MM-DD'.


• Campaign IDs must be unique and non-empty.

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.