Coinbase·Software Engineer·Technical Phone Screen·Intermediate

Intermediate

Jul 2026

Summary

Coinbase software engineer screen, one coding question the whole time. Pretty straightforward concept but the edge cases are where they actually want to see you think.

Questions Asked (1)

Design and implement a pagination helper class that takes an array and a page size, and returns the correct slice of items for a given zero-based page index. Handle out-of-range page numbers gracefully.

Algorithms & Data StructuresSystem DesignTechnical Trade-offs

Author's notes

Seemed easy at first and I jumped straight to the slicing logic, which was a mistake.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and edge cases, then outline a simple class design with a method that computes the slice using arithmetic. Implement the method with bounds checking to return an empty array for out-of-range pages, and discuss trade-offs like memory usage and potential optimizations.

Pro tip: Mention that returning an empty array for out-of-range pages is often safer than throwing an exception, as it avoids breaking client code and aligns with common pagination APIs. Also, consider adding a method to get total pages, which is often needed in real-world pagination.

1. Clarify requirements and edge cases

Ask about expected behavior for negative page indices, page size <= 0, empty arrays, and whether to return empty array or throw exceptions. Confirm zero-based indexing and that page size is fixed per instance.

2. Design the class interface

Define a class (e.g., Paginator) that takes an array and page size in its constructor. Expose a method like getPage(pageIndex) that returns the slice, and optionally a method to get total pages.

3. Implement the pagination logic

Calculate start index as pageIndex * pageSize. If start index is out of bounds (negative or >= array length), return an empty array. Otherwise, return a slice from start to min(start + pageSize, array length).

4. Handle edge cases and validate inputs

Ensure page size is positive; if not, either throw an error or treat as invalid. For negative page indices, return empty array. Test with empty array, single page, exact multiple, and partial last page.

5. Discuss trade-offs and optimizations

Consider memory usage of slicing (creates new array) vs. returning a view/iterator. Discuss whether to precompute total pages, and how to handle large arrays or streaming data.

Key Points to Mention

Zero-based indexing and consistent handling of out-of-range pages (return empty array).
Input validation: page size must be positive; negative page indices return empty.
Efficient slice calculation using arithmetic and Math.min to avoid overflow.
Trade-offs: returning a copy vs. a view, and potential memory implications.
Optional: method to get total pages for UI pagination controls.
Testing edge cases: empty array, page size larger than array, last page partial.

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