Bloomberg Industry Group Software Engineer Interview Guide

The 60-second brief

Bloomberg Industry Group supplies data and analysis to professionals in law, government and business. Candidates describe the Software Engineer role as spanning front-end user experience work, back-end infrastructure and system scalability, with ownership of the components you build. Day-to-day work reported for the role includes code reviews, technical documentation, architecture discussions with senior engineers, and adding features to existing codebases alongside product managers and other engineering teams.

This guide is for software engineer candidates preparing for the Bloomberg Industry Group loop. It covers the four reported rounds, the reported coding, web and system design questions, the behavioral prompts, and a seven-day plan. Candidates list C++, Java or Python as the object-oriented language for the role, so the coding practice here assumes you pick one of them and stay with it.

Candidates report four rounds over about 3-5 weeks: Remote Screening, Technical Interviews, Behavioral Interviews and Final Managerial Rounds. The pace is described as fast, and team-specific variations are possible.

Focus areas

• Data Structures
• HTTP (Protocol Basics)
• System Design

Overview

The reported questions fall into three groups. The coding group asks for a structure that retrieves and updates stock prices, a trie or tree problem you must dry-run, a graph problem with its time and space cost, optimizing an algorithm for a higher request volume, and an object-oriented rather than purely functional solution. The web and design group covers the anatomy of an HTTP request, scaling a back-end through traffic spikes, comparing front-end libraries on performance and maintainability, a schema for n-nodes of varying relationships, and caching trade-offs in a distributed system. The third group is five behavioral and role questions, from why this company to what you want to achieve in your first year.

Candidates also report the style of preparation that fits. You are expected to write standard algorithms and data structures without leaning on IDE help, so practise in a plain text editor. Java OOP concepts, the Java Virtual Machine and the internals of HTTP requests are reported as common areas of inquiry, which matters if you choose Java. Reported follow-ups include rewriting a recursive solution iteratively and what changes when the data no longer fits in memory, so rehearse both for every coding answer you give. If you get stuck, candidates are advised to keep talking, ask clarifying questions and treat the interviewer as a teammate.

The requirements candidates describe put weight on data structures and algorithms, web architecture fundamentals, and working through ambiguous requirements. Distributed systems, cloud infrastructure and database design and optimization are listed as nice-to-have, which is why the caching, scaling and schema questions deserve real time even if you come from a front-end or application background. Because the role is described as involving code review, documentation, version control and testing in existing codebases, prepare project stories that mention those things, not only the feature you shipped.

The Bloomberg Industry Group interview process

Candidates report four stages over roughly 3-5 weeks. Each stage is described only briefly, so this guide ties your preparation to the question types candidates report instead of promising a fixed question for each stage.

Remote Screening

Candidates report the opening stage as a remote coding challenge. A remote format means you write working code on your own, with no whiteboard and no hand-holding, so the preparation is fluency in one language plus a habit of checking your own work. Practise the reported coding question types: a structure for retrieving and updating stock prices, a trie or tree problem where you dry-run the code, and a graph problem with stated time and space complexity. Write the brute-force version first, name its cost, then improve it, and finish by running a small example by hand.

What to demonstrate

• Working code written without relying on heavy IDE assistance
• Choosing a data structure and justifying its time and space complexity
• Handling edge cases such as empty input and extreme values

How to prepare

• Solve the stock-price retrieval and update question in a plain text editor, covering the update, point lookup and highest/lowest price operations, then state the complexity of each.
• Implement a trie from scratch in your chosen language (insert, search, prefix search) and trace a three-word example by hand on paper.
• Write a breadth-first and a depth-first traversal over an adjacency list, handle cycles and disconnected nodes, and state time and space in terms of V and E.

Technical Interviews

Candidates describe several technical interviews that dig into deep-dive topics. The reported topic list covers data structures, algorithms, HTTP basics, system design and web application architecture, and the reported tips name Java OOP, the JVM and HTTP request internals as common areas. Expect to move between writing code and discussing design: optimizing an algorithm for far more incoming requests, an object-oriented rather than purely functional solution, the end-to-end anatomy of an HTTP request, scaling through traffic spikes, caching strategies, and a schema for varied relationships. Reported follow-ups include converting recursion to iteration and handling data that exceeds memory.

What to demonstrate

• Depth in data structures and algorithms, including refactoring a brute-force answer
• Understanding of HTTP, scalability, caching and latency bottlenecks in a web stack
• Explaining trade-offs instead of presenting one solution as final

How to prepare

• Write out the full path of an HTTP request from URL entry to rendered response (DNS, TCP and TLS, request, server handling, response, caching headers) and check that you can explain each hop.
• For caching, write a comparison of cache-aside, write-through and write-back with TTL expiry and invalidation, and name what each does to staleness and write latency.
• Take one recursive solution you have written and convert it to an iterative version with an explicit stack, then explain what you would change if the input did not fit in memory.
• If you use Java, review classes, interfaces, inheritance versus composition, equals/hashCode and the basics of JVM memory and garbage collection.

Behavioral Interviews

Candidates describe interviews that assess behavioral traits and past project experiences. The reported behavioral questions ask why you want this work, a significant technical hurdle, ambiguous or changing requirements, working with non-technical stakeholders, and what you hope to achieve in your first year. Approach each with a specific story from your own projects, told in the first person, with a decision, a result you can measure and one thing you would change. Be ready to walk through any resume project at architecture level, including your own contribution.

What to demonstrate

• Behavioral traits as shown in stories from past projects
• Ability to explain technical challenges from your own résumé projects
• Clarity when describing decisions and trade-offs

How to prepare

• Write three stories (a technical hurdle, an ambiguous requirement, a stakeholder disagreement) each with situation, your decision, the measured result and a lesson.
• Pick two resume projects and write a one-page architecture summary of each: components, data flow, what you owned, and one decision you would now make differently.
• Rehearse the stories aloud without notes until each is told in clear, short steps, and remove any sentence that uses 'we' where you mean 'I'.

Final Managerial Rounds

Candidates report final interviews with management that judge overall fit and readiness. Treat this as a conversation about how you work and what you would do in the role. Bring your project stories, your reasoning about trade-offs, and a concrete view of the first year. Behavioral-type questions are reported for this loop without a stated stage, so keep every behavioral answer ready for any conversational round.

What to demonstrate

• Overall fit and readiness for the role, as the stage is described
• How you communicate decisions and your ownership of past work
• Whether your expectations for the role are concrete

How to prepare

• Write a first-year outline for a new engineer: learning the codebase and review process, taking ownership of a component, shipping features, then one improvement you would propose.
• Prepare two or three specific questions for the team about technical challenges and how they approach technology, as candidates are advised to ask.
• Rehearse a two-minute summary of your most relevant project with a decision, a trade-off, and a result you can quantify.
• Refresh the scaling and caching answers from the technical stage, since you may be asked to discuss design choices from your own projects.

Where candidates lose points

Going silent on a coding problem instead of talking through the approach

Say the brute-force idea first, ask a clarifying question about input size or duplicates, and narrate each decision. Candidates are advised to treat the interviewer as a teammate, and a spoken half-plan is easier to redirect than silence.

Writing the trie or tree solution and never dry-running it

One reported question explicitly requires a dry run. After writing, trace a small input by hand, including an empty tree or a missing prefix, and update the code where the trace disagrees with it.

Giving a final answer to a design question with no trade-off, such as caching with no invalidation plan

For caching and scaling answers, name the read and write paths, state where data may be stale, and say what breaks first as traffic grows. Always give one reason to pick your approach and one cost it carries.

Knowing your language only through an IDE, so Java OOP, JVM or HTTP internals questions stall

Practise in a plain text editor, and review the fundamentals candidates report: classes and interfaces, the JVM basics if you use Java, and each stage of an HTTP request. Be able to explain, not just use, what your language does.

Listing resume projects you cannot explain beyond the feature name

For each project, prepare the architecture, your specific contribution, one trade-off and one thing that went wrong. Drop any line you cannot defend in a few follow-up questions.

Questions & practice

Given a large dataset, how would you implement a structure to efficiently retrieve and update stock prices?

Medium · Coding and Algorithms

Approach

1. Pin down the operations first: latest price per symbol, price at a past timestamp, max/min or top-k across symbols, and whether updates can arrive out of order or correct earlier ticks. The structure follows from that list.
2. Latest price is a hash map from symbol to its most recent quote: O(1) average read and update. For history, keep a per-symbol array of (timestamp, price) appended in time order and binary-search it for the price at time t in O(log n).
3. If corrections can overwrite an old timestamp, keep timestamp -> price in a hash map plus a max-heap and a min-heap of (price, timestamp); on a max/min query, pop entries whose price no longer matches the map (lazy deletion). Update is O(log n), and max/min is amortised O(log n).
4. An alternative to lazy heaps is a balanced ordered map of price -> count (TreeMap in Java, std::map in C++), which removes the old price exactly in O(log n) and avoids heap growth from stale entries.
5. For a dataset too large for one machine, partition by symbol so each symbol's updates hit one owner; under concurrent feed writes and reads, use a concurrent map or per-symbol locks instead of one global lock.

Follow-up

• How would you return the top 10 movers by percentage change over the last 5 minutes?
• What happens to your heaps if one symbol receives millions of corrections, and how do you bound their memory?
• How do readers see a consistent price while the feed thread is updating the same symbol?

Solve a medium-level problem involving Tries or trees, with a requirement to dry-run your code.

Medium · Coding and Algorithms

Approach

1. For a trie, define the node explicitly: a children map (or a 26-slot array for lowercase ASCII) and an end-of-word flag, plus a counter if prefix counts are needed. Insert and search are O(L) in the word length; total space is O(total characters) in the worst case.
2. State the array vs hash-map trade-off for children: the array gives constant-time indexing but wastes memory on sparse nodes; the map is compact but has hashing overhead and only handles the alphabet you actually see.
3. For a tree question, decide whether the answer comes from combining subtree results (post-order recursion: height, diameter, validate a BST with min/max bounds, lowest common ancestor) or from level order (BFS with a queue). Time is O(n); recursion uses O(h) stack, which is O(n) on a skewed tree.
4. Dry-run on paper before claiming it works: a small balanced example, then the edge cases (empty tree or empty string, a single node, a fully skewed tree, duplicate words or a word that is a prefix of another), writing the variable values at each step.
5. If depth could be large, offer an iterative version with an explicit stack so a skewed input cannot overflow the call stack.

Follow-up

• How would you extend the trie to return the top 3 autocomplete suggestions by frequency for a prefix?
• How do you delete a word from the trie without breaking other words that share its prefix?
• Can you rewrite your recursive tree solution iteratively, and what state does the explicit stack need to hold?

Implement a solution for a graph-based problem and explain the time and space complexity.

Medium · Coding and Algorithms

Approach

1. Choose the representation out loud: an adjacency list costs O(V + E) space and suits sparse graphs; an adjacency matrix costs O(V^2) but gives O(1) edge checks for dense graphs.
2. Match the algorithm to the question: BFS for shortest paths in an unweighted graph, O(V + E); Dijkstra with a binary heap for non-negative weights, O((V + E) log V); topological sort (Kahn's algorithm with in-degrees) for dependency order and cycle detection in a DAG; union-find with path compression and union by rank for connectivity, near-constant amortised per operation.
3. Track visited nodes so cycles do not loop forever, and loop over every node as a start so disconnected components are not missed.
4. For cycle detection in a directed graph, use DFS with three states (unvisited, on the current path, done): an edge to a node on the current path is a cycle. In an undirected graph, ignore the edge back to the parent.
5. State both complexities separately at the end: time from visiting each vertex and edge once (plus the heap factor for Dijkstra), space from the adjacency list, the visited set and the queue or recursion stack.

Follow-up

• What changes if some edge weights are negative? (Bellman-Ford, O(VE), which also detects negative cycles.)
• How would you handle a graph too large to fit in memory on one machine?
• Your recursive DFS overflows on a long chain: how do you fix it?

How would you optimize an existing algorithm to handle a significantly higher volume of incoming requests?

Medium · Coding and Algorithms

Approach

1. Measure before changing anything: profile the hot path, find where time goes per request (CPU, I/O wait, lock contention, allocation), and record throughput and p99 latency as the baseline.
2. Cut per-request algorithmic cost: replace linear scans with a hash lookup or an index built once, sort once and binary-search instead of rescanning, and precompute results that do not change between requests.
3. Remove repeated work across requests: memoise or cache results of pure computations, batch many small requests into one call to a downstream store, and coalesce identical in-flight requests so only one does the work.
4. Scale out and remove contention: make the handler stateless so instances can be added behind a load balancer, replace a single global lock with sharded locks or lock-free structures, and use async I/O when the work is I/O-bound.
5. Protect the system at peak with bounded queues, rate limiting and load shedding, then rerun the same load test to show the improvement against the baseline.

Follow-up

• How do you prove the optimisation helped and did not change results? (Benchmark plus correctness tests on the same inputs.)
• Your cache now serves stale data after updates: how do you invalidate it?
• What changes if the working data no longer fits in memory?

Can you solve this problem using an object-oriented approach rather than a purely functional one?

Medium · Coding and Algorithms

Approach

1. Find the nouns and responsibilities in the problem and make each a class with one job; keep its state private and expose behaviour through methods rather than letting callers mutate fields.
2. Where behaviour varies by type, define an interface or abstract base class and use polymorphism (for example a strategy object) instead of a switch on a type field; prefer composition over deep inheritance.
3. Show language fluency in the language you pick: interfaces in Java, abstract base classes in Python, virtual functions in C++ with a virtual destructor on the base class.
4. Contrast the styles honestly: the functional version uses pure functions over immutable data, which is easier to test and parallelise; the OO version bundles state with behaviour, which makes adding a new type easy but adding a new operation across all types harder (and the reverse holds for the functional version).
5. Keep the algorithm and its complexity identical to the functional version; the refactor changes structure, not Big O. Sketch the class outline before writing code.

Follow-up

• How would you add a new variant without modifying the existing classes (open/closed principle)?
• How do you unit test a class whose collaborators are other objects? (Inject them through the constructor and pass fakes.)
• When would deep inheritance in this design hurt you, and what would you use instead?

Find version gaps and relay lag with window functions

Medium · window functions · event tables · frame semantics

outbox_event holds event_id, aggregate_type, aggregate_id, aggregate_version, event_type, payload, status ('pending','published','dead'), attempts, created_at, published_at. A projection is missing rows and you must decide whether the relay skipped events or the consumer dropped them. Write three queries over the last seven days: one listing every aggregate_id whose published aggregate_version sequence has a hole, one giving per-day counts with a running total, and one returning the newest published event per aggregate. For each, say where the window function is evaluated relative to WHERE and LIMIT. PostgreSQL 16.

Approach

1. Gaps: compute lead(aggregate_version) OVER (PARTITION BY aggregate_id ORDER BY aggregate_version) in a subquery, then filter next_version <> aggregate_version + 1 in the outer query. Window functions are evaluated after WHERE, GROUP BY and HAVING and before the outer ORDER BY and LIMIT, so the predicate cannot sit in the same WHERE clause and PostgreSQL 16 has no QUALIFY.
2. Say what the seven-day filter does to the answer: it truncates every partition, so the first row per aggregate has no predecessor inside the window and a hole spanning the boundary is invisible. Widen the window, or join to resource.version as the authority for the true maximum.
3. Running total: SELECT date_trunc('day', created_at) AS d, count() AS n, sum(count()) OVER (ORDER BY date_trunc('day', created_at) ROWS UNBOUNDED PRECEDING). An aggregate inside a window call is legal because grouping runs before windowing. The grouping key is unique per row here so ROWS and RANGE agree, but write the frame anyway — over ungrouped rows with tied timestamps the default RANGE frame pulls in every peer row and the total jumps.
4. Newest per aggregate: DISTINCT ON (aggregate_id) ... ORDER BY aggregate_id, aggregate_version DESC is the cheap PostgreSQL-only form when an index matches that order; row_number() OVER (PARTITION BY aggregate_id ORDER BY aggregate_version DESC) = 1 is the portable form and needs a subquery for the same evaluation-order reason as the gap query.

Follow-up

• Relay failover redelivers events. Does a duplicate break the gap query, and how would you detect one from this table alone?
• Turn the gap check into a continuous monitor rather than a query someone runs after an incident. What does it watch?

Keep soft-deleted accounts from blocking re-registration

Easy · soft delete · unique constraints · engine differences

app_user holds user_id, tenant_id, email CITEXT, password_hash (NULL for SSO principals), email_verified_at, auth_version, status ('invited','active','suspended','deactivated'), created_at, updated_at, deleted_at. Two live accounts for one address inside a tenant must be impossible, but an address freed by a soft delete must be reusable, and the same tenant may delete and re-register it repeatedly. Write the uniqueness DDL for PostgreSQL 16, then the equivalent for MySQL 8 where partial indexes do not exist, and say what each permits once three deleted rows already hold that address.

Approach

1. Start from what is actually unique: not (tenant_id, email), but (tenant_id, email) among live rows. PostgreSQL says that directly — CREATE UNIQUE INDEX app_user_live_email ON app_user (tenant_id, email) WHERE deleted_at IS NULL. A full constraint over the same two columns burns the address permanently the first time someone deletes an account.
2. Keep case-insensitivity in the type or the index, never in the application: CITEXT as given, or UNIQUE (tenant_id, lower(email)) as an expression index where the extension is unavailable. A case-sensitive unique column is exactly how two accounts for one human appear.
3. For MySQL 8 the predicate has to move inside the key: add a discriminator column that is a constant 0 while the row is live and is set to user_id on delete, with UNIQUE (tenant_id, email, deleted_marker). Live rows share the constant and still collide; deleted rows differ from each other and stop colliding.
4. State the NULL variant and its dependency: leaving the marker NULL for deleted rows also works, because a unique index treats NULLs as distinct — true in MySQL, and true in PostgreSQL only under the default NULLS DISTINCT, which PostgreSQL 15 lets you reverse. Check the polarity against the three existing deleted rows: constant-on-live is what preserves the collision you want, and reversing it silently admits duplicate live accounts.

Follow-up

• A deleted account re-registers with the same address the next day. Do the old resource rows follow the new user_id, and how does the API keep the two principals apart?
• How do you honour an erasure request while resource_revision.actor_user_id still references this table?

Describe the end-to-end anatomy of an HTTP request.

Medium · System Design and Architecture

Approach

1. Start at the client: the browser parses the URL, checks its cache, then resolves the host through DNS (browser cache, OS cache, resolver, then root, TLD and authoritative servers if nothing is cached).
2. Connection setup: a TCP three-way handshake, then a TLS handshake for HTTPS (SNI names the host, the server's certificate chain is validated, and TLS 1.3 needs one round trip for a new session). HTTP/1.1 reuses connections with keep-alive, HTTP/2 multiplexes many streams over one TCP connection, and HTTP/3 runs over QUIC on UDP.
3. The request itself: a request line (method, path, version), headers such as Host, Cookie, Accept and Authorization, and an optional body. It typically passes a CDN or load balancer and a reverse proxy before an application server, which may call a cache and a database.
4. The response: a status code (2xx success, 301/302 redirects, 304 Not Modified when an ETag or If-Modified-Since check matches, 4xx client errors, 5xx server errors), headers such as Content-Type, Cache-Control and Set-Cookie, and a body.
5. Finish in the browser: parse HTML into the DOM, fetch CSS, JS and images (more requests), build the render tree, lay out and paint. Then say where latency hides: DNS, handshakes, server time and payload size.

Follow-up

• Where would you cut latency for a user far from the servers? (CDN, connection reuse, caching headers, compression.)
• What is the difference between a 502 and a 504 from a load balancer?
• What does HTTP/2 change compared with HTTP/1.1, and what problem remains that HTTP/3 addresses?

What strategies would you employ to scale a back-end system to handle massive traffic spikes?

Medium · System Design and Architecture

Approach

1. Separate predictable spikes (a scheduled release or a known event) from sudden ones: pre-scale and pre-warm caches for the first, and rely on headroom plus autoscaling for the second, noting that new instances take time to start.
2. Keep the application tier stateless behind a load balancer so instances can be added freely; move session state to a shared store.
3. Take load off the database: a CDN for static and cacheable responses, an in-memory cache for hot reads, read replicas for read-heavy traffic, connection pooling so new instances do not exhaust database connections, and sharding when writes outgrow one node.
4. Absorb write bursts with a queue and asynchronous workers so the request path only enqueues, and make consumers idempotent because messages can be delivered more than once.
5. Protect what remains: rate limiting (token bucket), load shedding of low-priority work, timeouts and circuit breakers on dependencies, retries with exponential backoff and jitter, and a degraded mode that serves cached or partial results.

Follow-up

• What usually breaks first in your design when traffic jumps 10x, and how would you know?
• A popular cache key expires during the spike and every request hits the database: how do you prevent that stampede?
• How would you load-test this before the real spike?

Compare and contrast different front-end libraries based on performance and maintainability.

Medium · System Design and Architecture

Approach

1. Name concrete options and their rendering model: React (component library, virtual DOM diffing, one-way data flow, very large ecosystem), Angular (full framework with TypeScript, dependency injection, routing and forms built in), Vue (templates plus a reactivity system, easy to adopt incrementally) and Svelte (a compiler that does most of its work at build time, so the shipped runtime is small).
2. Compare performance on specific axes: bundle size and initial load, update cost (virtual DOM diffing vs fine-grained reactive updates), server-side rendering and hydration support, and how much manual memoisation the developer must do to avoid needless re-renders.
3. Compare maintainability on specific axes: how opinionated the structure is (Angular decides more for you; React leaves routing and state management to separate libraries), TypeScript support, testing tools, upgrade history and the size of the hiring pool.
4. Tie the choice to the application: a large app with many teams benefits from strong conventions; a content-heavy site benefits from server rendering; a data-dense screen with long lists needs list virtualisation whatever the library.
5. Say how you would decide with evidence: build the same representative screen, then measure bundle size, Core Web Vitals (LCP, INP, CLS) and render counts in the browser profiler.

Follow-up

• A table with 10,000 rows renders slowly: what do you change? (Virtualisation, stable keys, memoised rows, paging.)
• When would you choose server-side rendering over client-side rendering, and what does hydration cost?
• How would you migrate a legacy front end to a new library without a full rewrite?

How would you design a database schema to support n-nodes of varying relationships?

Medium · System Design and Architecture

Approach

1. Model it as a property graph in relational tables: a nodes table (id, type, attributes) and an edges table (id, source_id, target_id, relationship_type, properties, created_at) with foreign keys to nodes, so any number of nodes can connect through any relationship type.
2. Index both directions: composite indexes on (source_id, relationship_type) and (target_id, relationship_type) so outbound and inbound lookups are both index scans; add a unique constraint on (source_id, target_id, relationship_type) if duplicate edges are invalid. For undirected relationships, store a canonical order (smaller id first) or store both directions.
3. For varying attributes per node type, compare options: a JSONB column (flexible, indexable with GIN in Postgres), per-type tables (strong typing, more joins) or entity-attribute-value (flexible but painful to query).
4. Multi-hop queries use a recursive CTE (WITH RECURSIVE) with a depth limit and a visited-path array to stop cycles; say that its cost grows quickly with hop count. For hierarchies only, a closure table trades extra rows on insert for fast subtree reads.
5. If most queries are deep traversals (friends of friends, shortest path), say when a graph database is the better fit, and what is lost: joins with the rest of the relational data and familiar transactional tooling.

Follow-up

• How would you find the shortest path between two nodes with this schema?
• One node has millions of edges: what does that do to your queries, and how do you handle it?
• If you shard the edges table by source_id, what happens to inbound-edge queries?

Discuss the trade-offs between different caching strategies in a distributed system.

Medium · System Design and Architecture

Approach

1. Name the read patterns: cache-aside (the app checks the cache, loads from the database on a miss and populates the cache; simple and resilient to cache loss, but the first read misses and data stays stale until TTL or invalidation) and read-through (the cache library loads on a miss for you).
2. Name the write patterns and their costs: write-through (write cache and database together; reads are fresh, writes are slower and the cache fills with data that may never be read), write-behind (write to the cache and flush to the database asynchronously; fast writes, but data is lost if the cache node fails before flushing) and write-around (write only to the database; avoids polluting the cache but the next read misses).
3. Invalidation: delete the key on write rather than updating it to narrow races, and still expect a stale value written back by a slow reader; mitigate with short TTLs or version numbers on cached values. Eviction policies: LRU, LFU, TTL.
4. Distribution: consistent hashing so adding or removing one of n nodes remaps roughly 1/n of the keys instead of nearly all of them; replicate hot keys or add a small in-process cache in front for keys that overload a single node.
5. Stampede control: single-flight request coalescing on a miss, jittered TTLs so many keys do not expire together, and probabilistic early refresh. Local in-process caches are fastest but each instance can see a different value.

Follow-up

• How do you keep the cache consistent with the database when two writers update the same row concurrently?
• A cache node dies: what happens to latency and database load, and how do you limit the damage?
• When would you accept write-behind's risk of data loss?

One log partition stops advancing while the others drain

Easy · poison message · head-of-line blocking · consumer lag

Search results for a subset of tenants are hours stale; the rest are current. The projection consumer reports lag of zero on 15 of 16 partitions and 400,000 on one. Its error rate is flat and its CPU is idle. outbox_event has no pending rows older than a second, so the relay has published everything it holds. Identify the mechanism, give the ordered checks, and state what you do in the first ten minutes versus what you change permanently.

Approach

1. Read the lag distribution first. A slow consumer lags everywhere; zero on fifteen partitions and 400,000 on one is not throughput. Idle CPU on the stuck partition means the consumer is not advancing its offset at all, which points at one message it cannot get past rather than at a rate problem.
2. Exonerate the producer before touching the consumer. No pending outbox rows older than a second means the relay published, so the event exists in the log. This separates never sent from sent and never applied, which are different code paths and usually different owners.
3. Read the message at the stuck offset and the handler's log lines for its event_id. A flat error rate with no progress has two explanations and you must distinguish them: the handler is throwing and the retry loop is swallowing it, or the handler is blocking on something and never returning. Idle CPU with no error lines favours the second.
4. Mitigate before diagnosing further. Move the offending event to a dead-letter store and commit the offset past it. Adding consumers does nothing here, because a partition is consumed by exactly one member of the group, and the blast radius is every aggregate hashed to that partition, not only the aggregate that produced the bad event.

Follow-up

• The dead-lettered event carried aggregate_version 7 and the projection had applied 6. What must the replay do differently if 8 and 9 landed in the meantime?
• How do you show staleness to the user while the partition is behind, given the API already returns the projection's watermark?

Suggested practice checklist

The plan follows the reported loop: a coding day, a graph and optimization day, web fundamentals, design, behavioral stories, then a mixed rehearsal.

Day 1 — Set up your language and map the loop

• Write the four reported rounds (Remote Screening, Technical Interviews, Behavioral Interviews, Final Managerial Rounds) and, under each, the topics candidates report for it.
• Choose C++, Java or Python and commit to it. In a plain text editor, write a hash map, a min-heap use and a linked traversal from memory to see where you rely on autocomplete.
• List your weakest area across data structures, HTTP, caching and schema design, and note it for the days below.

Deliverable: A one-page map of the four rounds, your chosen language, and a ranked list of weak areas.

Day 2 — Data structures: stock prices and tries

• Design the stock-price structure: choose the structure for updates and lookups of the latest price, and add an operation for highest and lowest price. State the complexity of each operation.
• Write a trie with insert, exact search and prefix search, then solve a tree or trie problem and dry-run it on a trace table.
• Write the empty-input and extreme-value tests for each solution before running them.

Deliverable: Working code for the price structure and the trie, with a written complexity for each operation and a dry-run trace for the trie.

Day 3 — Graphs, optimization and object-oriented design

• Solve one graph problem (shortest path in an unweighted graph or connected components), then write its time and space complexity in terms of V and E.
• Take a slow request-handling algorithm and optimize it (precomputation, a better index, batching), explaining which constraint the original version violates.
• Rewrite one of your solutions with classes (an object-oriented version), and convert one recursive function to an iterative one.

Deliverable: A graph solution with complexity, an optimized version of a slow algorithm with before-and-after cost, and one object-oriented and one iterative rewrite.

Day 4 — HTTP and web architecture fundamentals

• Write the end-to-end anatomy of an HTTP request from URL to rendered page and explain each stage aloud.
• Review status codes, caching headers and REST conventions and write two examples of each.
• Write a comparison of two front-end libraries along performance and maintainability, with the criteria you used.

Deliverable: A written request-lifecycle explanation and a front-end library comparison with stated criteria.

Day 5 — Scaling, caching and schema design

• Answer how you would scale a back-end through traffic spikes: load balancing, caching, queues, read replicas and sharding, and what breaks first.
• Compare cache-aside, write-through and write-back caching, and write an invalidation plan for one of them.
• Design a schema that supports n-nodes with varying relationship types, and compare an adjacency list with a typed edge table.

Deliverable: A scaling answer, a caching comparison, and a schema diagram with sample queries for the relationship model.

Day 6 — Behavioral stories and first-year outline

• Write stories for the technical hurdle, ambiguous requirements and non-technical stakeholder prompts, each with a decision, a metric and a lesson.
• Write the answer to why this company, using specifics you researched, and a first-year outline in stages.
• Say each answer aloud and cut every sentence that uses 'we' where you mean 'I'.

Deliverable: Five rehearsed answers, one per reported behavioral prompt, plus a one-page architecture summary of one resume project.

Day 7 — Mixed rehearsal across the loop

• Solve a trie or tree problem in a plain text editor, dry-run it and say the complexity aloud, then convert a recursive part to iteration.
• Give your technical-hurdle story and your first-year outline back to back as a final stage run-through.

Deliverable: A recorded run-through of one coding problem, one design answer and two behavioral answers, with a list of fixes.

Behavioral and first-year answers for Bloomberg Industry Group

Candidates describe the behavioral and managerial stages as covering behavioral traits, past project experiences and overall fit for the role. For a software engineer the useful material is a technical decision you owned, a time requirements were unclear, and a time you worked with someone outside engineering. Tell each in first person, with a result you can measure.

1. Describe a time you were stuck on a problem and how you asked for help.

Why are you interested in the specific work we do at Bloomberg Industry Group?

Medium · Behavioral and Role-Related

Approach

1. Build the answer from three parts: what the company does in plain facts (it supplies data and analysis to professionals in law, government and business), one or two specifics you actually researched and can name, and the link to your own work. Say only what you verified; a vague claim about the mission sounds rehearsed.
2. Connect it to the engineering, not just the industry: for example a project where you handled data that had to be accurate and fast, or where users depended on your software for their own decisions. Use first person: 'I enjoyed building X because the users needed Y, which is why this kind of work appeals to me.'
3. Tie it to the role as candidates describe it: front-end through back-end work, scalability, cross-functional collaboration. Name the part of that range you want most and the evidence that you can do it.
4. The mistake that sinks it is a generic answer that fits any employer, or one that only praises the brand. Test it: if you can replace the company name and the answer still works, add a specific.

Follow-up

• Which part of the work here would you find least interesting, and how would you handle it?
• What have you read or used from the company that shaped this answer?
• How does this role compare with the other offers or roles you are considering?

Tell me about a time you faced a significant technical hurdle and how you resolved it.

Medium · Behavioral and Role-Related

Approach

1. Choose a hurdle that was technically hard and that you personally solved: a performance problem, a concurrency bug, a data-volume limit or a failing integration. Avoid a team-process story and avoid one where someone else found the fix.
2. Structure it in five steps: the symptom with a number attached (latency, error rate, memory), your hypotheses ranked by likelihood, how you narrowed them with measurement (profiler, logs, a minimal reproduction), the fix and the alternatives you rejected, and how you verified it afterwards.
3. Name the decision point where you could have gone wrong, such as a rewrite versus a targeted fix, and say why you chose as you did. Quantify the result: 'p95 latency dropped from X to Y' or 'the failure no longer occurred over N runs'.
4. The sinking mistakes are narrating the problem for most of the answer and giving the solution one sentence, saying 'we' throughout so your own contribution is unclear, and offering a result with no evidence it came from your change.

Follow-up

• What would you do differently if you faced the same problem again?
• How did you confirm your fix caused the improvement and did not just coincide with it?
• At what point did you ask for help, and what did you ask?

How do you handle situations where requirements are ambiguous or changing?

Medium · Behavioral and Role-Related

Approach

1. Use a story with a real mechanism, not a statement that you adapt. A strong shape: you were handed a vague requirement, you wrote down your assumptions and open questions, took them to the person who owned the decision, and agreed on the smallest slice you could build first.
2. Show how you contained the cost of change: you kept the volatile part behind an interface, used a feature flag or configuration, or delivered in increments with a review point after each, so a new requirement meant a small edit instead of a rewrite.
3. Include how you handled a requirement that changed after work began: you restated the impact in terms of scope and schedule, got an explicit decision, and recorded it in a ticket or document. Say what you dropped as well as what you added.
4. The mistake to avoid is either extreme: building for weeks on a first guess without checking, or asking so many questions that nothing ships. Candidates describe agile work with product managers, so show a loop of small deliveries and confirmation.

Follow-up

• What did you do when two stakeholders gave you conflicting requirements?
• How did you decide which assumptions were safe to proceed on without asking?
• Tell me about a time a change in requirements cost you work you had already finished.

What is your approach to collaborating with non-technical stakeholders?

Medium · Behavioral and Role-Related

Approach

1. Describe a concrete case: a product manager, analyst or client-facing colleague needed a decision from you, and you had to explain a technical constraint or trade-off. State their goal first, in their words, then what stood in the way.
2. Show translation: you replaced jargon with the effects they care about (time, risk, cost, what users see), gave them two or three options with the trade-off of each, and recommended one. A one-page summary or a short diagram that you wrote is better evidence than 'I explain simply'.
3. Cover the hard part: a moment you had to push back, such as an unsafe deadline or a feature that would hurt reliability. Show that you offered an alternative they could accept, not just a refusal.
4. Close with how you checked understanding, for example asking them to restate the decision or following up in writing, and what the outcome was. Do not make the stakeholder the villain.

Follow-up

• How did you respond when a stakeholder insisted on a deadline you believed was unrealistic?
• How do you know the stakeholder understood a trade-off and was not just agreeing?
• How would you explain a caching or scaling decision to someone who has never written code?

What do you hope to achieve in your first year with our team?

Medium · Behavioral and Role-Related

Approach

1. This is a forward-looking question, so answer with a plan, not a story. Organize it into stages: early on you learn the codebase, the review and testing practice and the people; next you take ownership of a component and ship a feature; later you improve something measurable.
2. Ground it in the work candidates describe for the role: contributing to code reviews and technical documentation, integrating features into existing codebases, working with product managers and other engineering teams. For instance, 'I want to ship a feature end to end, write its documentation and review other people's changes.'
3. Make at least one goal measurable and honest, such as shipping a feature to production, reducing a latency or failure metric on a component you own, or documenting a part of the system nobody has covered. Avoid goals that depend on facts you do not have about the team; instead say 'I would confirm the priorities with my manager in the first weeks'.
4. Avoid answers that are only titles ('become a senior engineer') or only vague growth ('learn a lot'). Finish by saying what support you would need from the team.

Follow-up

• What would you need from your manager to reach those goals?
• Which skill would you most need to build in your first year, and how would you build it?
• How would you tell whether your first few months were going well?