Bloomberg Interviews

After applying directly through Bloomberg's career site without a referral, I went through a 5-round interview process. The first round was an online assessment on HackerRank with medium to hard LeetCode problems. In the second round, I faced a technical interview where the question was a variation of Candy Crush. I initially tried a two-pointer approach but switched to a stack-based solution after discussing with the interviewer, which they found satisfactory. The third round was a system design interview where I was asked to design a ride-sharing service similar to Uber or Lyft. We discussed the high-level architecture, database schema, and core components like driver matching and location updates. However, I struggled to explain trade-offs between technologies like SQL vs. NoSQL and consistency vs. availability, which impacted my performance. The interview ended with a rejection as I didn't clear the system design round. I learned that while solving DSA problems is important, the system design round requires deep reasoning about trade-offs and justifications for design choices.

I recently interviewed for an SDE position at Bloomberg, which consisted of three distinct rounds. The first round was a coding challenge where I was asked to implement a simplified version of grep. This involved finding lines in a file that contained a specific substring, with a strong emphasis on writing clean, extensible code that could accommodate future flag additions. I focused on clarifying requirements before diving into the parsing and string-matching logic.

The second round presented a problem where I needed to compute the total number of friend requests from an array of ages, based on specific age rules. My strategy involved first counting the frequency of each age. Then, I iterated over all possible pairs of ages (A, B) and applied the given rules: 0.5 × A + 7 < B ≤ A and A ≥ B. For same-age pairs, I made sure to exclude self-requests, while for different ages, I multiplied their frequencies directly to count valid requests.

The final round was primarily behavioral. These were very standard questions, and I approached them using the STAR framework. My aim was to demonstrate that I am self-driven and capable of showing ownership, as I understood they value these qualities over perfectly worded answers.

My interview journey with Bloomberg for a Senior Software Engineer position began with outreach from a recruiter. I was initially screened for three different teams, ultimately advancing to an onsite interview for one of them, though it did not culminate in an offer.

Phone Screen (3 teams)

Each phone screen followed a consistent format: 15-20 minutes dedicated to resume questions, followed by 20-25 minutes for a single coding question, and finally, 5-10 minutes for any remaining questions. The coding questions across all teams were drawn from older posts featuring Bloomberg-related problems found on LeetCode and their variations.

Virtual Onsite (1 team)

The virtual onsite interview consisted of two main parts: a coding round and a system design round. I understood that clearing these would lead to subsequent interviews with a Director, Engineering Manager, and HR.

Round 1: Coding + Resume

This round started with approximately 25 minutes of resume-based questions, which left limited time for the coding problems. I was asked two distinct coding questions:

1. A variation of a graph BFS problem combined with frequency counting. I needed to determine the frequency count for nodes at a specific level, given the input.
2. A Low-Level Design (LLD) problem focusing on a library checkout system, which also required writing relevant SQL queries.

Round 2: System Design + Scaling Experience

Similar to the coding round, the system design portion began with about 25 minutes of questions about my resume and experience with system scaling. The core system design question was based on a problem from the "Hello Interview system design" platform. Due to time constraints, it was crucial to move quickly, skipping straight to the core design, discussing tech stack choices, and addressing potential scaling issues.

Regrettably, I did not progress to the subsequent interview rounds.

Overall, I found it to be a great experience, and all the engineers I interacted with were very nice and experienced. I hope sharing this helps others in their preparation.

My interview process for the Senior Software Engineer role at Bloomberg consisted of multiple rounds. The first round, lasting 60 minutes, focused on an algorithmic problem. Following this, I had a second 90-minute round that presented two distinct coding challenges. Finally, I participated in a 90-minute system design round. Despite my efforts, I did not receive an offer.

After a standard HR screening round, I moved on to the technical interview. The first part was a coding problem: implementing the Insert Delete GetRandom O(1) data structure. I spent about 40 minutes working on this, which involved creating a hash map and an array to manage the random access efficiently.

The second part of the interview was a code analysis question. The interviewer showed me a polyfill for Array.prototype.forEach and asked me to explain what it does. The code included checks for null this, converting to an object, and iterating through the array with a callback. I spent 20 minutes analyzing the code and explaining its functionality, including the use of bitwise operations and polyfill patterns.

Despite the interviewer being very friendly and the questions being interesting, the overall experience was a rejection.

The interview was 1 hour long. 30 mins for resume, 30 mins for coding. HackerRank was used. Got this problem https://leetcode.com/problems/minimum-remove-to-make-valid-parentheses/description/ Description was slightly changed, but the approach for solving remained the same. Figured out the approach, implemented the solution. Got rejected in a week.

Design data structure for a horse race, where we will have two methods.

add(string horseName, int checkpoint)

Updates the position of the horse. This method will be called for all the checkpoints horse crosses. Checkpoints are in increasing order.

get()

Return name of the horses, one with the highest checkpoint first When two horses are at the same checkpoint, print horses in the order which reached that checkpoint first.

Example.

Input.

["HorseRace","add","add","get","add","get","add","get"]
[[],["A",1],["B",1],[],["C",1],[],["B",2],[]]

Output.

[null,null,null,["A","B"],null,["A","B","C"],null,["B","A","C"]]

I recently finished some interviews with bloomberg for Senior Software Engineer Role in London, UK.

Phone Screen -> Q1 -> https://leetcode.com/problems/invalid-transactions/description/ Q2 -> Implement a stack with functionality of push , pop and getMin.

Onsite 1 ->

Q1 -> Number of triangles that can be created from given array. Two points , O(n^2).

Q2 -> https://leetcode.com/problems/word-search/description/

Onsite 2 -> Design a stock broker app like Robinhood. Had some discussion on how to handle order placement based on customer account balance. Weird thing was they ask me to jump into design right away without defining the entities, apis and all.

Bloomberg 2025 Software Engineering Summer Internship

Applied through their website's job listing in November. After multiple stages, a few delays and rescheduled interviews, I received my offer in March.

University: Top 120 QS World Rankings
Status: 1 year of intern experience @ Swiss Bank
Position: SWE Intern
Location: London, United Kingdom

1. Technical Intro Interview (60 Minutes)
- The first half hour of this intro involved asking me about my background and experience, things I had on my CV, and why I had applied for the position.
- The second half was assesing my approach to a question very similar to Problem 1941; with an extra rule added during the interview after my original solution to increase the complexity slightly. I had to explain my approach in terms of time complexity and display knowledge of data structures.
- Problem_Description [] Create a function that returns true or false depending on whether the string passed in is valid or not.

        A string is valid if all characters have an equal 
        number of occurrences within it. 
        You may also remove one character from the string 
        to make it valid.
        </code><br/><br/>2. Technical Coding Interview (60 Minutes)<br/>    - This interview was purely technical, with a much larger focus on Big Oh notation and time complexities. I was tasked with ensuring that the entire system ran at O(1), and to ignore memory.<br/>    - <code>Problem_Description []
  Create a lottery storage system that would allow you to add,
  remove and pick participants. This storage system must run
  at O(1) and participants must be picked at random.
  
  Functions to implement:
    void LotterySystem() - Create Lottery object
    boolean addParticipant(int id) - Add a participant (Unique id)
                                     return true when successfully added
                                     return false if they cannot
                                     be added
    boolean removeParticipant(int id) - Remove a participant (Unique id)
                                     return true when successfully removed
                                     return false if they could not
                                     be removed
    int randomPick() - Randomly select a lottery winner and return
                       their ID.
                       Return -1 if there are no participants left.        
  </code><br/>    - I was also briefly questioned on my knowledge of JUnit testing, and what approaches to take to ensure such the system works as intended.<br/><br/>3. Technical Design Interview (60 Minutes)<br/>    - During this interview I was tasked with designing a system that allows users to look at a real-time stock price feed for a specific stock, view the history of prices for that stock and more. (Helpful  reading in relation to this can be found on harshsavasil's medium article [can't link due to discuss rules])<br/><br/>4. HR Interview (30 Minutes)<br/>    - Asked about my ambitions, why I want to work at Bloomberg, how I approach working alone and with a team, and more. Completely avoided technical questions but drew from my CV. A lot of discussion relating to Bloomberg's values and philanthropic efforts was held here.<br/><br/>5. Engineering Manager Interview (60 Minutes)<br/>    - This was similar to the HR Interview, they asked about my background and experience, delving deeper into the technical elements, and my interests into software engineering specifically as a career path.<br/><br/>Overall, I had a positive experience in my application process, although one interview felt very off as the interviewer seemed disinterested in the process. On a positive note, the campus recruitment team were very communicative throughout the process, and I look forward to joining the company for the summer. 

I had been diligently preparing for interviews since October 2020, and I must say, this platform and its community were instrumental in helping me secure an amazing offer at Bloomberg. It feels right to share my journey.

My interview process began with a Phone Interview. We discussed the longest substring without repeating characters, which I solved quite quickly. I noticed that many problems were variations of common themes, but always approachable. We also had a system design overview of an LRU cache; there was no coding, just a detailed discussion of the problem and my approach.

The Interview Day consisted of two main sessions. In the first interview, I tackled two questions: first, finding all unique subsets, and then immediately followed by finding unique subsets with duplicates included in the input. The second interview also featured two questions. I was asked to design a data structure for O(1) insert/delete/getRandom operations. The next question involved stock ticking, which had similarities to a leaderboard design problem. I also had a behavioral interview, which was seamless—I just focused on being myself and taking it easy.

Finally, I interviewed with a Senior Engineer. As an ML/AI engineer, we spent a significant amount of time discussing my prior experience. Surprisingly, the engineer presented me with the two sum problem, but we explored every possible variation, nearly five similar questions under the two sum umbrella. They wanted me to articulate my code line-by-line.

I managed to code almost every question perfectly, except for the stock ticking problem. I admit, I psyched myself out a bit, even though I knew a hashmap/priority queue approach was my best bet. I believe I navigated this question successfully by communicating my best solution, even though I was a bit stumped on the exact syntax implementation. It's crucial to remember that you can always ask if you can look something up; I completely forgot I had that option! I was elated to receive the offer, especially after struggling slightly with that stock ticking problem.

I interviewed for a Software Engineering Intern position for Summer 2021 at Bloomberg, based in Pune, India. My background is in Electrical and Electronics Engineering from a Tier 1 college in India. The interview process consisted of three rounds.

Round 1 (Phone Interview): This round began with self-introductions, followed by C++/OOP questions. I was asked about static variables in C++ and their uses, and to explain virtual functions in detail, discussing their role in runtime polymorphism. Following these, I was given two DSA problems. For the first, which involved designing an address book with bidirectional search (by name and by number), I only had to describe the approach and data structures. I believe I suggested using maps and a Trie. For the second DSA problem, which asked me to extract strings from innermost brackets in a given string (e.g., ran(n(d))o(m()) → 'd', ''), I had to code the solution. I solved this by managing a depth variable and storing strings in an unordered_map<int, vector<string>>, returning strings at the maximum depth. I completed it quite quickly.

Round 2 (On-site Virtual): After introductions, this round included some HR-style questions, such as "Why Bloomberg?" Then, I was given a DSA problem, which was Design Underground System on LeetCode. Fortunately, I had solved this problem before, so I explained my approach thoroughly while coding it. After coding, we discussed edge cases, like potential integer overflows.

Round 3 (System Design): This final round was with a senior manager and began with introductions and a discussion about my resume. Despite having no prior experience with system design, I was asked to design an e-commerce website. It was an open-ended discussion, and the interviewer seemed satisfied with my final design.

Verdict: I was ultimately rejected. The feedback indicated that my primary reason for rejection was in the System Design round; I was moving too quickly between different components and needed to explain each component in more depth before proceeding to the next.

Hello everyone, I am sharing my interview experience with Bloomberg for the "Software Engineer - 2021 Summer Internship - London" position. I believe this experience could also be relevant for entry-level or new grad roles. After applying online, a recruiter reached out to me to schedule a phone interview with one of Bloomberg's software engineers.

First Round (Phone)

The interviewer called me precisely on time. He started by introducing himself and the team he works with, then gave me time to introduce myself. Following this, he directed me to a HackerRank link provided by the recruiter for the coding challenge.

The first question asked was to find the first non-repeating character in a string. My initial approach involved a two-pass traversal using either a hashmap or a fixed array for character counting, and I made sure to explain the trade-offs between these two options. A follow-up question then challenged me: "What if the string was very long? How could I optimize the solution?" In response, I introduced a one-pass solution, suggesting either using an extra field within the hashmap to store the first index where the character was seen, or leveraging a linked hashmap. The interviewer seemed satisfied with both of my proposed solutions.

He didn't ask me to compile the code but rather to trace it and discuss its complexity. Towards the end, he gave me an opportunity to ask questions about the company or anything else on my mind.

After three days, I received positive feedback from the recruiter, inviting me to virtual on-site interviews.

Second Round (Virtual Onsite)

This round was a video interview conducted with two Bloomberg Software Engineers. We exchanged introductions, and then they provided a HackerRank link for the coding challenges.

The first question was to Validate a BST. I discussed an in-order traversal "like" approach, presenting both recursive and iterative solutions. I then proceeded to write the code for the recursive approach. They did not ask me to compile it; we focused on discussing its complexity.

The second question was to Design an Underground System. Before diving into the solution, I asked for clarification on whether the system was directed or undirected. One of the interviewers seemed quite pleased with this question and clarified that it was directed. I then discussed my approach, which involved using hashmaps and some C++ Structs. I explained the solution's complexity and clarified special cases, such as handling division by zero. Again, they seemed content with my explanation and did not ask me to compile the code.

Three days later, I again received positive feedback from the recruiter, inviting me to a system architecture interview with one of their senior software engineers. This is where I currently am in the process.