Meta·Software Engineer·Technical Phone Screen·Senior

SeniorPrefer not to say

Jul 2026

Summary

Meta SWE interview that focused on designing a mini banking system from scratch. Pretty involved for a coding round, felt more like a system design question dressed up as an OOP problem.

Questions Asked (1)

Design a BankSystem class with createAccount, deposit, and pay methods. Define the data models, validation rules, return values, and the data structures backing each operation. What are the time and space complexities?

System DesignData ModelingAlgorithms & Data Structures

Author's notes

This one sprawled way more than I expected.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and defining the data models (Account, Transaction) and validation rules. Then, design the BankSystem class with methods createAccount, deposit, and pay, specifying return values and the data structures (e.g., hash map for accounts, list for transactions). Finally, analyze time and space complexities for each operation.

Pro tip: Mention concurrency control (e.g., locks or atomic operations) to handle simultaneous deposits/payments, and discuss idempotency for pay to avoid double-spending—this shows production-level thinking.

1. Clarify Requirements and Assumptions

Ask about expected scale, concurrency, persistence, and error handling. Define assumptions like unique account IDs, non-negative balances, and atomic operations.

2. Define Data Models and Validation

Specify Account (id, balance, owner) and Transaction (id, from, to, amount, timestamp, status). Outline validation: positive amounts, sufficient balance, account existence, and unique IDs.

3. Design Class and Methods

Design BankSystem with createAccount(owner, initialDeposit) returning account ID, deposit(accountId, amount) returning new balance, and pay(fromId, toId, amount) returning transaction ID or status. Use a hash map for accounts and a list or map for transactions.

4. Analyze Complexities

For hash map: createAccount O(1) average, deposit O(1) average, pay O(1) average. Space O(A + T) where A is accounts and T is transactions. Mention worst-case O(n) for hash collisions.

5. Discuss Extensions and Trade-offs

Talk about concurrency (locks, optimistic locking), persistence (database), and scalability (sharding). Mention alternative data structures like balanced BST for ordered operations.

Key Points to Mention

Use of hash map for O(1) account lookup and update.
Validation rules: positive amounts, sufficient balance, account existence.
Return values: account ID, new balance, transaction ID/status.
Time complexity: O(1) average for all operations; space O(A + T).
Concurrency control: locks or atomic operations to prevent race conditions.
Idempotency for pay to avoid double-spending.

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