Bloomberg·Software Engineer·Technical Phone Screen·Intermediate

Intermediate

May 2026

Summary

Bloomberg data engineering interview, technical phone screen focused on a meaty coding prompt where they hand you an existing codebase and ask you to extend it without touching the abstractions. The question was dense and I spent the first few minutes just reading the scaffold before I even knew what they were asking.

Questions Asked (1)

You're given an existing Python codebase with an abstract base class and a factory/registry pattern already in place. Without modifying the abstractions, implement a concrete CSV-to-JSON processor that reads CSVs in chunks, normalizes each row into a JSON object, writes line-delimited JSON to an output file, handles bad rows with a retry and logging policy, and registers itself so the CLI can invoke it by name.

System DesignTechnical Trade-offsAPI & Integrations

Author's notes

This one took me a minute to even parse.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the existing abstractions and registry mechanism, then outline the concrete class that implements the required interface. Walk through the chunked reading, row normalization, error handling with retry/logging, and registration process, emphasizing how it integrates without modifying the base class. Conclude with trade-offs and potential improvements.

Pro tip: Show that you understand the importance of not modifying existing abstractions by explaining how you would use the registry decorator or explicit registration call, and mention that you would write unit tests for the new class to ensure it adheres to the contract.

1. Understand the existing abstractions and registry

Review the abstract base class to identify required methods and the registry mechanism (e.g., decorator or registration function). Determine how the CLI invokes processors by name.

2. Design the concrete processor class

Create a class that inherits from the abstract base and implements the required methods, ensuring it can be registered without altering the base. Plan the chunked CSV reading and JSON writing logic.

3. Implement chunked processing and normalization

Use a CSV reader to iterate over rows in chunks, normalize each row into a JSON object (e.g., convert types, handle missing values), and write line-delimited JSON to the output file.

4. Handle bad rows with retry and logging

For each row, attempt processing; on failure, retry a configurable number of times, then log the error and skip the row. Ensure logging includes sufficient context for debugging.

5. Register the processor and integrate with CLI

Use the existing registry mechanism to register the new class under a unique name, so the CLI can invoke it. Verify that no changes to the base class or registry are needed.

Key Points to Mention

Chunked reading to handle large files efficiently and avoid memory issues.
Normalization rules: data type conversion, handling nulls, and ensuring consistent JSON structure.
Retry policy: number of retries, backoff strategy, and what constitutes a 'bad row'.
Logging: structured logging with row identifiers and error details for observability.
Registration: using decorators or explicit registration without modifying existing code.
Testing: unit tests for the processor, including edge cases like malformed CSV and retry scenarios.

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