DocuSign·Software Engineer·Technical Phone Screen·Intermediate

Intermediate

Apr 2026

Summary

DocuSign SWE interview with a design-your-own-system coding question. The problem was more involved than I expected for a phone screen, felt like it was testing both data structure knowledge and API design at the same time.

Questions Asked (1)

Design a system with three operations: createUser(userName, role), postJob(jobId, role, salary), and topKJobsForUser(userName, k). The last one should return the top K highest-salary jobs a user is eligible to see based on their role. What data structures would you use to make topK fast?

Algorithms & Data StructuresSystem DesignTechnical Trade-offs

Author's notes

I started by reaching for a basic map from role to a list of jobs and sorting on the fly, which the interviewer let me finish before asking what happens at scale.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints, then propose a data model that maps roles to eligible jobs and maintains a sorted structure for fast top-K retrieval. Discuss trade-offs between different data structures and explain how you would handle updates and queries efficiently.

Pro tip: Mention that you would use a heap or balanced BST per role to keep jobs sorted by salary, enabling O(log n) insertions and O(k log n) top-K queries, but also consider if a simple sorted list with binary search is sufficient for the expected scale.

1. Clarify Requirements

Ask about expected scale (number of users, jobs, roles), read/write ratio, and whether salaries can be updated or deleted. This determines the optimal data structures.

2. Design Data Model

Propose storing jobs in a global collection and maintaining per-role indexes. For each role, keep a data structure that supports efficient insertion and top-K queries.

3. Choose Data Structures

For each role, use a max-heap or a balanced binary search tree (e.g., TreeMap) to store jobs sorted by salary. Alternatively, use a sorted list with binary search for insertion and retrieve top K by taking the last K elements.

4. Analyze Complexity

Compare time complexities: heap gives O(log n) insert and O(k log n) for top-K (by extracting k times), while balanced BST gives O(log n) insert and O(k) for top-K via reverse iteration. Discuss space trade-offs.

5. Handle Updates and Edge Cases

Consider how to handle salary updates (requires removal and re-insertion) and deletions. Discuss concurrency and persistence if needed.

Key Points to Mention

Use a hash map to map userName to role for quick eligibility lookup.
Maintain a separate data structure per role (e.g., max-heap or balanced BST) to keep jobs sorted by salary.
For top-K, a heap requires extracting K elements (O(k log n)), while a balanced BST allows O(k) retrieval via reverse iteration.
Consider using a sorted list with binary search for insertion (O(n) worst-case) if the number of jobs per role is small.
Discuss trade-offs between time and space, and mention that a combination of hash map and heap/BST is often optimal.
Address how to handle updates: if a job's salary changes, remove it from the old position and re-insert.

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