lucid.page The Exact Steps of My Bloomberg New Grad Interview in 2026
Text size
Read time7 min

# The Exact Steps of My Bloomberg New Grad Interview in 2026

Bloomberg’s 2026 New Grad interview had a resume screen, a technical screen, and a virtual onsite, six rounds in total. I found it hard mainly because coding time was very tight. The technical rounds ran on Zoom with the camera on, and the interviewer asked me to share my screen.

Contents

Linkjob AI helped me get through this interview, which is why I’m sharing the questions and my experience here. Having a real-time AI interview assistant for online interviews gave me a real edge.

# Timeline

I applied about a week after getting a referral. A week later I got a phone screen invite. About two weeks after that came the technical phone screen, roughly 45 minutes. Three days later I was invited to the VO (virtual onsite). On-campus slots were full, so I booked the following week.

The VO was back-to-back, three rounds, all on Zoom. The morning round wasn’t too hard, and when I asked about next steps they told me to just rejoin the same Zoom link. In the afternoon round I was a bit slow on the coding, but the interviewer didn’t rush me. About 30 minutes later I had the HR interview.

HR questions:

Plus basics: graduation date, sponsorship, other offers. About a week later they told me I was moving on to the EM round.

Note: Communicate with your interviewer at Bloomberg and don’t be afraid to ask questions. I think they pay close attention to problem-solving habits and communication. And save the Zoom link! The whole superday used the same one.

# Resume Screen

Mostly education, tech stack fit (mainly C++/Python/Java), and project experience.

# Technical Screen (about 45 minutes)

Two algorithm problems. The focus was clear thinking, correct code, and especially edge cases. Recursion and divide-and-conquer came up a lot.

Problem 1: Count ships. Given a Point struct and an existing hasShips(bottom_left, top_right) that says whether a region contains at least one ship, implement countShips to return the total number of ships.

My approach, divide and conquer:

I tripped a little on the single-point case before realizing I just return based on hasShips when the coordinates match. For complexity I argued T(n) = 4T(n/4) + O(1), assuming hasShips is O(1), giving O(log n). The interviewer seemed happy with that.

Problem 2: Word break into a sentence. Given a string with no spaces and a dictionary, return a properly spaced string. Input “bloombergisfun” with [“bloom”, “bloomberg”, “is”, “fun”] returns “bloomberg is fun”.

My approach, backtracking with memoization:

All test cases passed and I cleared the round.

Linkjob AI worked well and I got through the interview without a hitch.

# Other Questions I Saw

Behavioral questions:

# Real Questions I Collected While Preparing

These cover real-time data processing, low-latency trading, and financial analytics design, all very relevant to Bloomberg’s business.

# 1. Sliding-window stock statistics

Process a stream of price updates (stock_id, timestamp, price) and, for any stock_id over the last N seconds, return the current, average, max, and min price. Handle out-of-order or duplicate updates and evict old data efficiently.

Data structures:

process_update: find or create the stock’s data; drop entries older than current minus N*1000 from the deque, update the sum and expired_entries, clean expired heap tops; then append the new entry, add to the sum, and push into both heaps.

query_statistics: current price is the deque’s last element; average is sum_prices divided by deque size; max/min are heap tops after checking expired_entries.

Edge cases: keep the deque sorted for out-of-order data (drop or buffer small disorder, insert in place for harder cases); duplicates on (stock_id, timestamp) can be overwritten or ignored, default treats them as separate points.

Complexity: update O(log K) time from the heaps, O(K) space; query O(1).

Optimizations: lazy deletion to avoid constant heap rebalancing, a circular buffer when window size is predictable, and pre-aggregated time buckets for large windows or heavy volume.

# 2. Low-latency order matching

Process an order stream (order_id, stock_id, BUY/SELL, price, quantity) and match buys and sells quickly.

For a BUY, check the top sell; if its price is at or below the buy price, match the smaller quantity, record the trade, update quantities, remove fully filled orders, and push any remaining buy quantity into buy_orders. SELL is symmetric.

Scaling ideas: shard order books by stock_id, object pools and compact structures, lock-free CAS structures for multithreading, batch processing to cut context switches, FPGA/GPU for extreme latency, pre-allocated memory pools, and CPU affinity for matching threads. Cost is amortized O(log K) per order.

# 3. Historical prices and indicators platform

Let users query historical prices and compute MA, EMA, and RSI over millions of points.

Storage: a time-series DB keyed on (stock_id, timestamp), partitioned by time or stock_id, a secondary index on stock_id, and columnar storage.

EMA: EMA_today = Price_today * K + EMA_yesterday * (1 - K), with K = 2/(N+1); seed with the SMA and iterate.

Performance: Redis/Memcached for common results and Apache Ignite for hot raw data, precompute popular metrics like the 50-day MA after market close, distribute large queries with Spark/Flink, use covering indexes, and compress data.

# How I’d Prepare

# FAQ

How should I practice coding? LeetCode, HackerRank, and CodeSignal; time yourself, review mistakes, and practice explaining solutions out loud.

How do I show culture fit? Share teamwork examples, talk about learning new skills, and ask about Bloomberg’s values.

Should I ask questions at the end? Yes. Write down questions about the team, projects, and culture beforehand.

End