Coinbase·Software Engineer·Online Assessment (OA)·Intermediate

IntermediatePrefer not to say

Jun 2026Remote

Summary

Coinbase SWE online assessment on CodeSignal, a four-level task scheduler problem where each level adds new requirements on top of the last. The kind of OA where you can't just brute-force your way through because the later levels assume your earlier code is solid.

Questions Asked (1)

Design and implement a multi-level task scheduler: starting with basic add, get, and cancel operations, then layering in prioritization and listing, then user assignment with quotas, and finally completion tracking with overdue detection.

Algorithms & Data StructuresSystem DesignTechnical Trade-offs

Author's notes

Four levels, each building on the previous.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints for each level, then design a modular architecture that separates task storage, scheduling logic, and user management. Implement incrementally, validating each layer with tests and discussing trade-offs (e.g., data structures, concurrency, scalability) as you go.

Pro tip: Emphasize extensibility and clean interfaces from the start; this shows you can evolve a system without rewrites, which is crucial for production systems at scale.

1. Clarify Requirements and Constraints

Ask questions to understand expected scale, concurrency needs, persistence requirements, and any specific behaviors for each level (e.g., priority semantics, quota enforcement).

2. Design Core Data Model and Interfaces

Define classes/interfaces for Task, Scheduler, and User, and choose appropriate data structures (e.g., priority queue, hash maps) that support the required operations efficiently.

3. Implement Level 1: Basic Operations

Code add, get, and cancel operations, ensuring thread-safety if needed and handling edge cases like duplicate IDs or missing tasks.

4. Extend for Prioritization, Listing, and User Assignment

Add priority ordering, listing with filters, and user quotas; discuss how to maintain performance as features grow (e.g., indexing, sharding).

5. Add Completion Tracking and Overdue Detection

Implement status updates, overdue checks (e.g., via timestamps and periodic scans), and discuss trade-offs between polling and event-driven approaches.

Key Points to Mention

Choice of data structures (e.g., heap for priorities, hash map for O(1) access) and their time/space complexity.
Concurrency control mechanisms (locks, concurrent collections) for thread-safe operations.
Scalability considerations: partitioning, sharding, or distributed scheduling for large user bases.
Trade-offs between simplicity and extensibility, and how to refactor as new requirements emerge.
Testing strategy: unit tests for each operation, integration tests for multi-level features.
Error handling and idempotency for operations like cancel and complete.

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