Coinbase·Software Engineer·Technical Phone Screen·Intermediate

Intermediate

Jun 2026

Summary

Coinbase software engineer interview with a coding problem centered on financial transaction logic. Pretty straightforward on the surface but the edge cases and overflow handling are where they're actually testing you.

Questions Asked (1)

Implement a bank account processor that takes an initial balance and a list of string operations (DEPOSIT, WITHDRAW, CASHBACK), applies each in order, and returns the final balance. WITHDRAW is ignored if funds are insufficient, and CASHBACK credits floor(balance * p / 100). Must run in O(n) time with O(1) extra space, use 64-bit integers, and include unit tests for edge cases.

Algorithms & Data StructuresTechnical Trade-offs

Author's notes

The core loop isn't hard but I fumbled on CASHBACK for a second because I tried to do floating point math before remembering they said use integers.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and edge cases, then outline a single-pass algorithm that parses each operation and updates the balance in O(1) space. Emphasize the use of 64-bit integers to prevent overflow and discuss how to handle insufficient funds and cashback calculations. Finally, describe unit tests covering edge cases like zero balance, large numbers, and invalid operations.

Pro tip: Mention that you'll use a 64-bit integer type (e.g., long long in C++ or long in Java) to avoid overflow, and explicitly test boundary conditions like maximum balance and cashback rounding. This shows attention to detail and robustness, which is crucial for financial systems.

1. Clarify requirements and edge cases

Ask about input format, operation parsing, and constraints (e.g., negative balances, invalid operations). Confirm that WITHDRAW should be ignored if insufficient funds and that CASHBACK uses floor rounding.

2. Design the algorithm

Iterate through operations once, updating balance accordingly. Use a 64-bit integer for balance to handle large values. For CASHBACK, compute floor(balance * p / 100) using integer arithmetic.

3. Handle edge cases

Consider zero balance, large deposits/withdrawals, cashback with zero balance, and invalid operation strings. Ensure WITHDRAW does not overdraw and CASHBACK does not cause overflow.

4. Write unit tests

Create tests for normal flow, insufficient funds, cashback rounding, zero balance, and maximum values. Include tests for invalid operations and empty operation list.

5. Analyze complexity and trade-offs

Confirm O(n) time and O(1) space. Discuss potential trade-offs like using floating-point for cashback (avoid due to precision) and alternative data structures.

Key Points to Mention

Use of 64-bit integers (e.g., long long) to prevent overflow in balance calculations.
Single-pass iteration over operations for O(n) time complexity.
Constant extra space (O(1)) by updating balance in place.
Handling of insufficient funds for WITHDRAW by ignoring the operation.
Cashback calculation using integer arithmetic: floor(balance * p / 100).
Comprehensive unit tests covering edge cases like zero balance, large numbers, and invalid operations.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.