Key takeaways
Bloomberg runs a recruiter screen, a technical phone screen, and an onsite of three to five rounds covering coding, a code-review exercise, system design for mid and senior candidates, and a behavioral round with an engineering manager. A panel review and team matching follow, and candidate guides put the whole process at three to seven weeks. The code-review round and the C++ depth are what catch strong coders.
Bloomberg doesn't publish its interview rubric, so this map is built from named candidate guides (interviewing.io, Prepfully, and Interview Kickstart), the comp bands on Levels.fyi, and aggregated candidate-experience data from 4dayweek.io.
How Bloomberg's loop differs from FAANG
Start with what Bloomberg engineers build, because it shapes the whole interview. The Bloomberg Terminal is real-time financial infrastructure. Market data streams in from exchanges, risk systems run enormous calculations on a deadline, and latency is measured in milliseconds because traders are on the other end. That product reality is why the loop cares so much about C++, correctness, and systems thinking.
Three things set Bloomberg apart from a standard West Coast loop:
- C++ runs deep. The phone screen and onsite lean harder on memory, pointers, and multithreading than most FAANG loops, which are increasingly language-agnostic. Per Interview Kickstart's Bloomberg guide, if you list C++ on your resume, expect an engineering manager to probe the internals.
- A code-review round. Bloomberg runs a round most FAANG companies skip, where you read and critique a large block of deliberately buggy code instead of writing your own.
- The process is decentralized. As interviewing.io's Bloomberg guide puts it, "each team asks its own questions, focuses on different things, and might have a slightly different process." There is no single company-wide script.
That decentralization is the thread through this whole post. The shape is consistent, but the specifics shift by team, which is why preparing for the underlying skills beats memorizing one team's question list.
Stage one, the recruiter screen
The first call is 30 to 45 minutes with a recruiter. No coding. They walk through your background, your interest in Bloomberg, and the logistics of the loop.
What it screens for. Two things, mostly. Whether your experience clears the bar for the level you're targeting, and whether you have a real reason for wanting Bloomberg specifically. The second one matters more here than at most companies. A vague "I'm exploring opportunities" answer is a genuine risk this early, because Bloomberg's culture skews toward people who want the finance-technology problem, not just any high-paying engineering job.
Have a concrete answer for why Bloomberg. The Terminal, the scale of the market-data problem, the low-latency engineering, the New York-centered culture. Pick the thread that's actually true for you and be specific about it.
Stage two, the technical phone screen
The phone screen is where the coding starts. Candidate guides describe one or two sessions of roughly an hour, run on a shared editor, with problems in the LeetCode Medium range. Per Prepfully's Bloomberg guide, the code doesn't always need to compile cleanly; the interviewer is watching your logic and your reasoning more than your syntax.
The data-structure mix is standard, with a Bloomberg accent. Arrays, strings, hash maps, trees, and the occasional graph problem. What's heavier than a typical loop is the follow-up on complexity and on how your solution behaves under the kind of scale a market-data system sees.
What it screens for. Whether you can produce a correct, reasonably efficient solution while talking through your thinking. Narrate as you go. Silence reads as a stall even when you're making progress, and the interviewer is writing notes that someone else may read later.
If C++ is your language, this is where the internals questions start. Memory model, references versus pointers, what happens during object construction. Treat anything on your resume as fair game for a deep follow-up.
Stage three, the onsite coding and the code-review round
The onsite is usually three to five technical rounds plus a behavioral. Most of it is what you'd expect: more coding, harder follow-ups, a systems discussion. The round that surprises people is the code review.
In the code-review round, you're handed a long block of code, sometimes a couple hundred lines, and asked to find what's wrong with it. Prepfully's guide describes candidates hunting for iterator misuse, uninitialized variables, and boundary-logic errors, the way you'd review a junior engineer's pull request. You aren't writing a solution. You're proving you can read someone else's code and catch the bugs before they ship.
What it screens for. This is the most Bloomberg-specific signal in the loop. Real engineering work is mostly reading and maintaining code other people wrote, not solving puzzles on a blank page. The code-review round predicts whether you'll be a net positive on a large C++ codebase from week one. Strong puzzle-solvers who have never seriously reviewed code tend to rush it, skim the logic, and miss the subtle bugs.
For mid-level and senior candidates, the onsite also includes system design. Bloomberg's version is domain-flavored: design a stock-ticker feed, a trade-matching engine, a system that distributes real-time prices to thousands of Terminals with a tight latency budget. Entry-level candidates usually skip this round.
Stage four, the behavioral round
The behavioral round is with an engineering manager, and at Bloomberg it carries more decision weight than candidates expect. Prepfully's guide is blunt about it: technical excellence is the baseline, and behavioral fit often drives the final call. Candidates who solved every coding problem cleanly have still been turned down on collaboration and culture signals.
Expect standard STAR-method territory, with a Bloomberg lean toward collaboration and communication. How you handled a cross-team conflict. How you explained something technical to a non-technical stakeholder. A project where you owned an ambiguous problem end to end.
What it screens for. Whether you work well inside a tightly collaborative engineering org, and whether your interest in Bloomberg is real. Bloomberg builds one connected product, not a loose federation of services, so the cost of an engineer who can't collaborate is high. This is also where a weak "why Bloomberg" answer comes back to end the loop.
Prepare three or four specific stories that show collaboration, ownership, and clear communication under pressure. Vague stories signal vague work.
Stage five, the hiring committee and the offer
After the onsite, candidate reports describe a panel review rather than a single interviewer holding a yes or no. The hiring manager advocates, the panel reads the written feedback, and the group confirms the decision and the level. A team-matching step then pairs you with a group whose work fits your skills before the offer is final. For new-grad hires especially, the role often isn't team-specific until this stage.
On compensation, Levels.fyi's self-reported mid-2026 data puts the median total package around $280K, with entry-level software engineers near $211K and senior engineers near $296K. Bloomberg weights base salary and bonus heavily and carries less of the public-company equity that drives FAANG numbers, so the shape of the package looks different even when the total lands in a similar range. These are crowdsourced figures, not a published scale, so treat them as a sample of the band.
The practical takeaway: your level is the biggest single driver of the offer, and the leveling read starts in the recruiter screen and firms up in the behavioral round. Make your scope legible at both ends.
What to do in the 72 hours before each stage
Spread your prep by where the risk actually sits, not evenly.
- Before the phone screen, drill mediums out loud. Practice arrays, strings, hash maps, and trees while narrating your approach and complexity. If C++ is your language, review the memory model and multithreading basics the night before.
- Before the onsite, practice reading code, not just writing it. The code-review round is the one nobody rehearses. Pull a messy open-source file and find the bugs in it on a clock. It's the cheapest edge in the whole loop.
- Before the behavioral, write your stories down. Three or four, each showing collaboration, ownership, and clear communication. Tighten your "why Bloomberg" until it's specific and true.
Common reasons strong candidates get rejected
Among interviewers, the rejections cluster in a few predictable places.
- A generic "why Bloomberg." This one ends loops early. Bloomberg screens hard for people who want the finance-technology problem, and a recycled answer reads as a candidate who'll leave in a year.
- Rushing the code review. Strong coders treat it like a speed round, skim the logic, and miss the subtle bugs the round exists to surface.
- Shallow C++. Listing C++ and then fumbling the internals is worse than not listing it. The depth probe is routine here.
- Clean code, weak collaboration. Solving every problem and still reading as someone hard to work with is a real failure mode, because the behavioral round can outweigh a perfect technical sheet.
The fix for most of these is the same: practice the parts of the loop that aren't pure puzzle-solving, out loud, under something like real conditions. Reading answers builds recognition. It does not build the fluency to explain a tradeoff or defend a code-review call while someone watches and the clock runs. That gap, between knowing your answer and delivering it under pressure, is where good candidates lose offers.
Four-Leaf's voice mock interviews are built for the delivering half. You answer real questions out loud, get scored on substance, and drill the spots where you freeze. The delivery side comes back as measurements taken off your own recording rather than someone's impression of you. Your rate of um and uh, your words per minute, and how often you hedged. The code-review round punishes the last of those hardest, because explaining someone else's code while you read it is exactly when "sort of" and "I guess" creep in. You can run a full mock before the real thing, free for three days with every feature included, or a $5 one-time 5 Day Pass if you just have the one Bloomberg loop coming up. Finance roles in particular reward the rehearsal, and our finance interview prep guide covers the wider field.
The one thing to remember
Bloomberg's loop looks like a FAANG loop and isn't one. The coding bar is familiar, but the decision turns on the rounds people skip in prep: reading code instead of writing it, knowing your C++ deep enough to defend it, and showing you can collaborate on one tightly connected product with a real reason for being there.
Prepare like the puzzle is the easy part, because at Bloomberg it usually is. Drill code review. Defend your C++. Make your "why Bloomberg" specific. The candidates who get that the Terminal runs on careful, collaborative engineering are the ones who give the panel an easy yes. Drilling those rounds out loud beats reading about them, and our comparison of the best mock interview platforms covers where to run the reps.