Leveling & How Decisions Are Made

Hudson River Trading is a small firm by technology standards, a bit over a thousand people across fourteen offices. It describes itself as built by coders and led by coders. Scale like that leaves little room for a tall grade ladder with a rung for every year of tenure. A Core software role lands on one of three public titles: Junior Software Engineer, then Software Engineer, then Senior Software Engineer. The Algo Developer, AI Researcher, and hardware tracks run as separate ladders alongside. Settle which loop the requisition really belongs to before prep begins, because the Core software track and the quant research track barely overlap.

The Hudson River Trading angle

You are being read against the Core software engineering bar. The quant probability gate is a different loop entirely. HRT's public reputation is probability, statistics, and market-making games, and that reputation is earned, but it belongs to the Algo Developer and trading-research track. The Core Software Engineer loop is a different instrument: a timed take-home coding test, roughly two technical phone screens, and a full day of coding, debugging, systems, and design. No make-a-market game and no timed-arithmetic sprint appears on it, and first-hand accounts from the software loop show zero probability rounds. Read every HRT interview story for the track it belongs to before you borrow its prep, because an engineer drilling brainteasers is training for a gate the Core loop never opens.

The Core Software Engineer Ladder

HRT does not publish an internal grade rubric. Read the software ladder through the scope each title owns and the three public rungs that comparison data normalizes it into: Junior Software Engineer, then Software Engineer, then Senior Software Engineer. On levels.fyi these line up as L1, L2, and L3. Read as an L-numbered ladder it is strikingly short, three public rungs with a large jump into Senior, which fits a firm that calls itself meritocratic and low-politics and keeps its hierarchy relatively flat. No Staff or Principal title is confirmed on the software side, and no HRT-official ladder statement is retrievable, so treat anything above Senior as undocumented rather than named. Where a hire lands is driven by demonstrated scope, and HRT keeps the calibration for that private. Intern, new-grad, and experienced hires enter on distinct paths, with new grads routing into a formal training program. Compensation is not covered here; it lives in the negotiation lesson.

Who Decides, and How

HRT publishes the Core pipeline order in its own words. Application, then a take-home coding test, then roughly two technical phone screens, then a full day of back-to-back interviews that can run virtually or onsite. The first phone screen is a technical discussion covering systems, data structures, and problem solving; the second is a programming round in C++ or Python. Experienced engineers sometimes skip the take-home and open with exploratory calls instead. The exact number of rounds on the final day is not disclosed. The named components are, coding and debugging rounds, a technical design discussion, and team fit, but anyone quoting a precise onsite count is synthesizing, so hold the number loosely. As for who converts the panel's reads into a single yes or no, HRT does not publish it. There is no public sign of an Amazon-style dedicated bar raiser or a standing hiring committee, and no absence is confirmed either. Treat the decision as panel and hiring-team led. The recruiter coordinates the loop, and the engineers own the technical verdict. Feedback timelines and any cooling-off window before reapplying are not disclosed.

The Hudson River Trading angle

The coding assessment is graded on what you cannot see. Passing every visible test case is not passing. Engineers have hit one hundred percent of the visible cases and still been cut, because the score that matters is correctness under the hidden tests, behavior on the edge cases, and speed. The problems carry large input constraints on purpose, so a brute-force solution that is technically correct times out and fails silently against inputs you never watch run. HRT builds the assessment away from burst-of-insight puzzles. The gate is whether your solution stays correct at scale, handles the corners, and lands fast. Clearing it proves you can code under a clock. It does not prove the depth the rest of the loop exists to find.

The Published Rubric: Four Areas, Seven Ways to Fail

HRT is unusually open about what the full day grades, which turns its published guidance into a de-facto rubric. Four evaluation areas run through the technical rounds. Programming skill is read as idiomatic, efficient, readable code rather than clever one-liners. Systems-level knowledge is probed directly through memory, I/O, and process management. Problem-solving is tested on genuinely unfamiliar problems so that memorized solutions do not help. And soft skills carry real weight, collaboration and teachability specifically, since the rounds are collaborative and HRT explicitly rewards over-communication out loud. The design discussion for a Core seat is low-latency and systems-flavored, closer to laying out a component under real constraints than drawing boxes and arrows.

The debugging round is HRT's signature stage and the one that most sharply separates its loop from a standard big-tech day. HRT names coding and debugging rounds among the full day's components in its own writing, so the round's existence is not folklore. In practice you are handed an unfamiliar codebase and asked to find and fix real bugs in it. Public accounts describe roughly forty-five minutes to an hour spent reading, forming a hypothesis, and confirming it before changing anything. It rewards an instinct that pure algorithm prep does not build: comfort dropping into code you did not write, reasoning about what it is doing, and narrating the hunt as you go. Systems-internals depth sits right beside it. Expect under-the-hood questions about why things behave as they do. What happens when you call malloc, how virtual dispatch is laid out, how a data structure sits in memory: all pointed at the low-latency machine HRT builds.

The Hudson River Trading angle

What separates this from a big-tech loop is depth. Some candidates can reel off a hundred solved algorithm problems but cannot say what happens when memory is allocated, or why a cache miss costs what it does. They read as underpowered for a firm whose product is speed measured in nanoseconds. HRT states outright that the most common reason strong candidates fail is a shallow understanding of fundamentals, and that a strong programmer from a competitive firm would clear the technical bar with no studying. The panel hunts for whether you understand the machine, the language, and the system beneath the code. It also checks whether you can debug your way through something unfamiliar while thinking out loud. Build depth on fundamentals and systems, and you clear a bar that algorithm breadth alone does not.

Common questions