Atlassian·Software Engineer·Technical Phone Screen·Intermediate

IntermediatePrefer not to say

Jun 2026

Summary

Atlassian technical phone screen with a follow-up twist on an async HTTP fetching problem. The deduplication angle plus the testing question made it feel less like a coding exercise and more like a design conversation.

Questions Asked (1)

You have a list of URLs to fetch sequentially. Deduplicate the list first so each unique URL is only requested once, preserving the order of first occurrence. How would you implement this, and how would you test it?

Algorithms & Data StructuresAPI & IntegrationsTechnical Trade-offs

Author's notes

The dedup part was fine, set plus insertion-order tracking, nothing crazy.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints, then propose a solution using a hash set to track seen URLs while iterating through the list, preserving order. Discuss time/space complexity and edge cases, then outline a testing strategy covering unit, integration, and performance tests.

Pro tip: Mention that using a hash set provides O(1) average lookup, but if memory is a concern, you could sort and deduplicate with a stable sort or use a Bloom filter for approximate deduplication with trade-offs. Also, emphasize the importance of testing with large inputs to catch performance issues.

1. Clarify requirements and constraints

Ask about input size, memory limits, whether URLs are case-sensitive, and if normalization (e.g., trailing slashes) is needed. Confirm that order must be preserved and that the output should be a list of unique URLs.

2. Design the algorithm

Propose iterating through the list once, using a hash set to track seen URLs, and appending unseen URLs to a result list. This preserves first occurrence order and runs in O(n) time and O(n) space.

3. Discuss trade-offs and alternatives

Compare with sorting-based deduplication (O(n log n) time, O(1) extra space if in-place) or using a Bloom filter for memory-constrained scenarios. Explain why the hash set approach is optimal for most cases.

4. Outline testing strategy

Cover unit tests for empty list, no duplicates, all duplicates, mixed duplicates, and order preservation. Include integration tests with a mock HTTP client to ensure each URL is fetched exactly once. Add performance tests with large lists.

5. Consider edge cases and error handling

Address invalid URLs, case sensitivity, URL normalization (e.g., http vs https, trailing slashes), and how to handle fetch failures (e.g., retries, logging) without affecting deduplication.

Key Points to Mention

Use a hash set for O(1) average-time lookups to track seen URLs.
Preserve order by appending to a result list only on first occurrence.
Time complexity O(n) and space complexity O(n) for the hash set and result list.
Testing should include unit tests for various duplicate patterns and order preservation.
Integration tests with a mock HTTP client to verify each unique URL is fetched exactly once.
Consider edge cases: empty input, all duplicates, case sensitivity, URL normalization, and large inputs for performance.

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