Bloomberg 26NG SWE VO Interview Experience | 3 Rounds Back-to-Back, 4.5 Hours

I just finished my Bloomberg 26NG SWE VO. Three rounds were scheduled back-to-back, taking around four and a half hours in total. I wanted to write down the experience while everything is still fresh.

One thing that stood out about Bloomberg is that the hardest part is often not getting the initial solution, but defending it and extending it under follow-up pressure. Both technical rounds followed this pattern. The questions themselves were not extremely difficult, but the follow-ups kept adding another layer.

Interview Process Overview

• Technical Round 1: 45–60 minutes
• Technical Round 2: 45–60 minutes
• HR Round: around 30 minutes
• EM Round: around 40 minutes, scheduled as a follow-up in this process

The main rounds were concentrated on the same day with very little buffer in between. The overall Bloomberg process can take roughly 3–7 weeks, and both communication and technical ability matter. Each round may also include a deeper discussion of your resume.

Round 1: Behavioral Questions + Merge Intervals + Secret String

Resume and Behavioral Questions

The behavioral section took around 15 minutes and moved quickly. There were three main questions:

1. What was the most difficult technical problem you have faced?
2. How do you handle disagreements with a teammate or manager?
3. How do you prioritize when multiple tasks become urgent at the same time?

The follow-ups focused on the reasoning behind your decisions and how you handled the situation afterward. For example, when discussing a technical challenge, you should be able to explain why you chose a particular approach, not just describe what you implemented.

Bloomberg seemed to care more about technical decision-making than having an especially flashy project. Being able to clearly explain what you built, why you built it that way, and what you would change matters more.

Coding 1: Merge Intervals

The first coding problem was LeetCode 56 – Merge Intervals.

The standard solution is to sort the intervals by their starting point and then scan through them while maintaining the current merged interval. If two intervals overlap, extend the right endpoint. Otherwise, add a new interval to the result.

def merge(intervals):
    intervals.sort(key=lambda x: x[0])
    result = [intervals[0]]

    for start, end in intervals[1:]:
        if start <= result[-1][1]:
            result[-1][1] = max(result[-1][1], end)
        else:
            result.append([start, end])

    return result

The time complexity is O(n log n), mainly because of sorting.

Coding 2: Secret String Guessing

The second problem was a secret-string guessing problem. For each character:

• If guess[i] == secret[i], return *.
• If the character exists in the secret but is in the wrong position, return +.
• Otherwise, return -.

A basic version can be handled with a set, but the important follow-up was to account for character frequency.

You need to process exact matches first and consume those characters from a frequency counter. Then, in a second pass, determine whether the remaining guessed characters can be matched elsewhere in the secret.

from collections import Counter

def check_guess_with_freq(secret, guess):
    freq = Counter(secret)
    result = [''] * len(secret)

    for i, (s, g) in enumerate(zip(secret, guess)):
        if s == g:
            result[i] = '*'
            freq[s] -= 1

    for i, (s, g) in enumerate(zip(secret, guess)):
        if result[i]:
            continue

        if freq.get(g, 0) > 0:
            result[i] = '+'
            freq[g] -= 1
        else:
            result[i] = '-'

    return ''.join(result)

The key point is the two-pass approach. Without consuming the exact matches first, duplicate characters can easily be counted incorrectly.

Round 2: Resume Deep Dive + LC 1209 + Linked List Implementation

Resume Deep Dive

This section took around 15 minutes and involved two interviewers. The questions went deeper into the technical details of projects on my resume.

• If you could redesign the project, what would you improve?
• You mentioned smart pointers — how do they work?

The general lesson is simple: anything technical on your resume can become a follow-up question. If you mention a specific technology or concept, be prepared to explain how it works and why you used it.

Coding 1: Remove All Adjacent Duplicates in String II

The first coding question was LeetCode 1209 – Remove All Adjacent Duplicates in String II.

The standard solution uses a stack containing pairs of characters and their consecutive counts. Once a character reaches k occurrences, the stack entry is removed.

def removeDuplicates(s, k):
    stack = []

    for c in s:
        if stack and stack[-1][0] == c:
            stack[-1][1] += 1

            if stack[-1][1] == k:
                stack.pop()
        else:
            stack.append([c, 1])

    return ''.join(c * cnt for c, cnt in stack)

Follow-Ups

The interviewer then pushed the problem further:

1. What are the time and space complexities?
2. What happens if you remove the if count == k: pop logic?
3. Can you implement the same idea using a linked list?

The linked-list version was the most challenging part of this round. Instead of explicitly popping a stack entry, the previous node becomes the new head.

class Node:
    def __init__(self, char, count, prev=None):
        self.char = char
        self.count = count
        self.prev = prev


def removeDuplicatesLL(s, k):
    head = None

    for c in s:
        if head and head.char == c:
            head.count += 1

            if head.count == k:
                head = head.prev
        else:
            head = Node(c, 1, head)

    result = []

    while head:
        result.append(head.char * head.count)
        head = head.prev

    return ''.join(reversed(result))

The main thing being tested here was pointer manipulation. Setting head = head.prev effectively performs the pop operation without explicitly deleting the node.

Round 3: HR Interview

The HR round lasted around 30 minutes and was purely behavioral.

• Tell me about yourself.
• What project did you find the most interesting?
• Why are you interested in Bloomberg?
• What would you value most after joining the company?

“Why Bloomberg?” is worth preparing carefully. Doing some research into Bloomberg Terminal, financial data infrastructure, quantitative tools, and the company's products will make your answer much stronger than simply saying that Bloomberg is a leader in financial technology.

Common Topics and Overall Impression

Common Coding Topics

Based on this interview, useful areas to prepare include string matching and elimination, interval problems, stack-based problems, hash maps and frequency counting, as well as some graph and tree questions.

Common Behavioral Topics

For behavioral questions, be ready to discuss situations where your initial approach did not work, how you prioritize competing tasks, how you handle disagreements, and how you change direction when circumstances change.

The Biggest Takeaway

Bloomberg's interviews felt somewhat like a code review. The goal is not simply to see whether you can write working code. The interviewer wants to know whether you fully understand the code you just wrote and whether you can reason about what happens when the requirements change.

After finishing the initial solution, it helps to proactively explain the complexity, mention important edge cases, and think about possible extensions. That gives you more control over the discussion instead of waiting for every follow-up to come from the interviewer.

Also, be prepared to defend every technical keyword on your resume. If you mention something like smart pointers or a particular system component, you should be comfortable explaining the underlying concept, your implementation choices, and the relevant trade-offs.

Final Thoughts

The follow-ups were the real dividing line in this Bloomberg interview. Getting the initial problem solved is only the starting point. The more important part is whether you can extend the solution, switch implementations, and explain the impact of changing or removing a piece of code while under pressure.

For candidates preparing for Bloomberg, Goldman Sachs, JPMorgan, and other financial technology companies, it is worth spending extra time on interval variations, stack-to-linked-list implementations, and frequency-based string matching.

InterviewShow also covers Online Assessment, Coding Interview, System Design, and Virtual Onsite preparation, with one-on-one support for candidates who want more targeted interview practice.

Good luck with the interview and hope you get the offer!