Square Software Engineer System Design Questions

Background: Square relies heavily on real-time notifications for transactions, updates, and user interactions. A robust notification system can enhance user experience by promptly informing them about critical actions within the Square ecosystem.Requirements:
1. The system must handle multiple notification types (e.g., email, push, SMS).
2. Notifications should be queued and delivered asynchronously to ensure a smooth user experience.
3. Implement throttling to manage rate limits for notification delivery.
4. The system should support user preferences for notification channels and types.
5. Provide metrics for notification delivery success and failure.Class API:

• send_notification(user_id: str, message: str, notification_type: str) -> bool

Sends a notification to the specified user and returns whether the notification was successfully queued.

• set_preferences(user_id: str, preferences: dict) -> None

Updates the notification preferences for a user.

• get_status(notification_id: str) -> dict

Returns the delivery status of the notification with the given ID.

• flush_queue() -> None

Processes and sends notifications in the queue.Example 1:
Input: send_notification('userA', 'Your payment was successful!', 'email') → Output: True → Explanation: The notification is queued successfully.Example 2:
Input: set_preferences('userA', {'email': False, 'SMS': True}) → Output: None → Explanation: User preferences are updated without error.Constraints:

• Maximum of 100,000 notifications queued at any time.


• User preferences can only be updated once per hour.


• Notification delivery attempts are capped at 3 per notification.

Background: Square's PaymentProcessor is critical for managing payment transactions efficiently and securely. Given the diverse payment methods and rigorous security standards in financial transactions, a robust structure to process and manage payment details is essential.Requirements:
1. The class must allow adding supported payment methods (e.g., credit card, digital wallet).
2. It should validate payment details before processing the request.
3. The processor has to maintain a history of transactions and their statuses.
4. It should allow querying transaction history by transaction ID.
5. The class should implement concurrency control to handle multiple payment requests.Class API:

• add_payment_method(method: str) -> None: Adds a new payment method to be supported.


• process_payment(transaction_id: str, amount: float, method: str) -> str: Processes a payment and returns the transaction status.


• get_transaction_status(transaction_id: str) -> str: Retrieves the status of a given transaction.


• get_transaction_history() -> List[Dict[str, Any]]: Returns a list of all transactions.

Example 1:

• Input: add_payment_method("Credit Card") → Output: None → Explanation: Adds "Credit Card" as a valid payment method.


• Input: process_payment("txn_123", 100.00, "Credit Card") → Output: "Success" → Explanation: Processes a payment for 100.00 using the credit card method.

Constraints:

• Maximum of 10 different payment methods.


• Each transaction must not exceed $10,000.


• Up to 1000 concurrent transactions can be processed.

Background: Square is expanding its offerings in the financial services domain, allowing users to manage their money seamlessly. A well-defined banking system is integral for these operations to maintain accuracy, security, and efficiency.Problem Statement: Design a banking system that can handle multiple users, manage account creation, and allow transactions such as deposits and withdrawals while ensuring that account balances are accurately maintained. The system should support basic user authentication, and should not allow overdrafts in accounts. Make sure to implement appropriate error handling for each transaction.Class Signature:

• class BankAccount: - represents an individual user account.

- def __init__(self, account_id: str, initial_balance: float) -> None: - initializes a new account with a unique ID and balance.
- def deposit(self, amount: float) -> str: - deposits a specified amount into the account.
- def withdraw(self, amount: float) -> str: - withdraws a specified amount from the account.
- def get_balance(self) -> float: - returns the current balance of the account.Example 1:

• Input: account = BankAccount('12345', 100.0); account.deposit(50.0); account.withdraw(30.0)


• Output: account.get_balance() → 120.0


• Explanation: The account was initialized with 100.0, deposited 50.0, and withdrew 30.0, resulting in a balance of 120.0.

Example 2:

• Input: account = BankAccount('67890', 200.0); account.withdraw(250.0)


• Output: account.get_balance() → 200.0


• Explanation: Attempting to withdraw 250.0 exceeds the current balance, so the withdrawal is rejected and the balance remains 200.0.

Constraints:

• The account_id must be a unique string.


• The initial_balance must be a non-negative float.


• The amount for deposits and withdrawals must be a positive float.


• Withdrawals must not exceed the current balance.

Background: Square taps into the financial technology landscape, supporting transactions and banking operations for merchants and customers alike. A robust banking system is essential for facilitating transactions, maintaining account information, and managing user trust.Requirements:
1. Manage user accounts and transactions.
2. Support basic operations like deposits, withdrawals, and fund transfers.
3. Implement transaction logging for auditing purposes.
4. Provide user authentication and authorization mechanisms.Class API:

• class User: Represents a bank user.

- def __init__(self, user_id: str, name: str) -> None: Initializes a new user with ID and name.
- def deposit(self, amount: float) -> None: Deposits a specified amount into the user's account.
- def withdraw(self, amount: float) -> None: Withdraws a specified amount from the user's account.

• class Transaction: Represents a transaction in the banking system.

- def __init__(self, user_id: str, amount: float, type: str) -> None: Initializes a new transaction with user ID, amount, and type (deposit/withdraw).

• class Bank: Main class for interaction.

- def create_user(self, name: str) -> User: Creates a new user.
- def transfer(self, from_user: User, to_user: User, amount: float) -> None: Transfers funding between users.Example 1:

• Input sequence: Create a user, deposit 100, withdraw 50 → Output: Account balance is 50.


• Explanation: The user can perform deposit and withdraw operations, altering their balance accordingly.

Constraints:

• Maximum of 1000 users.


• Transaction amounts must be positive and capped at 10,000.


• Users cannot withdraw more than their current balance.