Meta·Software Engineer·Technical Phone Screen·Intermediate

Intermediate

Jun 2026

Summary

Meta SWE coding round, basically a banking/transaction system design problem that kept getting extended with follow-ups. The core idea was straightforward but the scaling requirements made it more interesting than I expected.

Questions Asked (1)

Design a system that tracks each user's total transaction volume (sum of absolute amounts across all successful deposits and withdrawals) and returns the top K users by that metric, with ties broken by user ID.

Algorithms & Data StructuresSystem DesignTechnical Trade-offs

Author's notes

The hashmap part was fine, I had that pretty quick.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then propose a streaming data pipeline that maintains per-user aggregates and a top-K structure. Discuss trade-offs between exact and approximate methods, and how to handle updates and queries efficiently.

Pro tip: Emphasize that the top-K set can be maintained incrementally with a min-heap of size K, avoiding full re-sorting on each update. Also mention that for very large K or high update rates, approximate algorithms like Count-Min Sketch with a heap can be used, but be clear about the accuracy trade-off.

1. Clarify Requirements and Scale

Ask about data volume, update frequency, query patterns, latency requirements, and whether exact or approximate results are acceptable. Confirm that only successful transactions are counted and that amounts are absolute values.

2. Design Data Model and Aggregation

Propose a per-user aggregate (e.g., a hash map from user ID to total volume) that is updated on each transaction. Discuss how to handle concurrent updates and ensure consistency.

3. Maintain Top-K Efficiently

Use a min-heap of size K to track the current top K users, updating it when a user's total changes. Explain how to handle ties by user ID and how to adjust the heap when a user's total increases or decreases.

4. Address Scalability and Trade-offs

Discuss partitioning by user ID for distributed processing, and trade-offs between exact (e.g., heap) and approximate (e.g., Count-Min Sketch) methods. Consider batch vs. streaming updates and query latency.

5. Handle Edge Cases and Extensions

Cover scenarios like new users, users with zero volume, K larger than the number of users, and how to support time-windowed queries (e.g., top K in the last hour).

Key Points to Mention

Use a hash map to store per-user total transaction volume, updated incrementally.
Maintain a min-heap of size K for efficient top-K retrieval, with tie-breaking by user ID.
Consider distributed processing via sharding by user ID, with a merge step for global top-K.
Discuss approximate algorithms (e.g., Count-Min Sketch) for high-cardinality or high-throughput scenarios.
Address consistency and concurrency, such as using atomic updates or a single-writer per user.
Explain how to handle updates that decrease a user's total (e.g., refunds) and their impact on the top-K set.

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