← Atlassian Interview Insights

Atlassian·Software Engineer·Technical Phone Screen·Senior

SeniorPrefer not to say
Jun 2026

Summary

Atlassian coding screen that looked straightforward on paper but kept expanding. The base problem was simple enough, but the follow-up directions made it clear they were stress-testing how you think about evolving an API, not just whether you can write a loop.

Questions Asked (1)

Q1

Write a function that takes a list of URLs, sends an HTTP GET request to each one sequentially, and returns the results. Each result should include the URL, the status code, and the response body. Then discuss how you'd handle timeouts, propagate errors, and how the function signature would need to change as requirements evolve (deduplication, parallelization).

API & IntegrationsTechnical Trade-offsSystem Design
Author's notes

Started fine.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by writing a clean sequential implementation with clear types and error handling, then discuss how you would evolve it to handle timeouts, deduplication, and parallelization. Emphasize trade-offs and how the function signature changes to accommodate new requirements.

Pro tip: Show awareness of real-world constraints like rate limiting and idempotency, and mention that you'd use a library or framework for production HTTP calls rather than reinventing the wheel.

1. Define the initial function signature and data model

Specify input (list of URLs) and output (list of results with URL, status code, body). Use clear types and consider error representation (e.g., result object or exceptions).

2. Implement sequential HTTP GET with basic error handling

Write a loop that sends requests one by one, catches exceptions, and collects results. Ensure the function doesn't fail entirely on a single error.

3. Add timeout and error propagation strategy

Introduce a timeout parameter per request, and decide how to propagate errors (e.g., include error details in the result or throw aggregate exceptions).

4. Evolve for deduplication and parallelization

Discuss deduplicating URLs before fetching, and changing the signature to accept options like concurrency limit. Show how to parallelize with async/await or thread pool while preserving order if needed.

5. Summarize trade-offs and future extensibility

Highlight trade-offs between sequential and parallel, error handling strategies, and how the design can adapt to retries, caching, or different HTTP methods.

Key Points to Mention

  • Timeout handling: per-request timeout, overall timeout, and using library defaults.
  • Error propagation: partial failures, result objects with error fields, or exceptions with context.
  • Deduplication: using a set to track seen URLs, and whether to preserve order or not.
  • Parallelization: concurrency limits, async I/O vs threads, and handling backpressure.
  • Function signature evolution: adding optional parameters (timeout, concurrency) and returning richer result types.
  • Real-world considerations: rate limiting, retries with backoff, idempotency, and using HTTP client libraries.

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