Tower Research Capital runs its trading business as a collection of semi-autonomous teams, and that structure shows up in the interview long before you write any code. On a final-round day you usually meet engineers from two or three different desks, each running its own strategy and each with its own read on what a strong hire looks like. One team might care most about how you reason about cache misses; another wants to see you decompose a messy system without flailing. There’s no single rubric to game, which is the point.
The firm has been trading since 1998 and sits on the latency-sensitive end of the market: market making and short-horizon strategies across equities, futures, and options on exchanges worldwide, with engineering offices in New York, London, Singapore, Montreal, and Gurgaon. If you’re interviewing for a core engineering seat, the work is C++ close to the metal, and the questions reflect that.
The loop, from application to offer
For software engineering roles the process is short and coding-heavy, usually one to two weeks from first contact to decision when scheduling cooperates. It opens with an online assessment, moves through one or two live coding phone screens, and finishes with a Super Day of five or six back-to-back interviews. New-grad and intern loops lean harder on the timed assessment; experienced hires often skip straight to a phone screen and the onsite.
| Stage | Format | What the interviewers are checking |
|---|---|---|
| Online assessment | 3 to 5 algorithm problems in 90 to 120 minutes, sometimes an object-oriented design question mixed in | Coding speed and correctness under a clock, and clean handling of edge cases |
| Phone screen (one or two) | 60 minutes of live coding in a shared editor, plus C++ and CS-fundamentals probing | Whether you write compilable code while talking, and whether your language knowledge is real |
| Super Day | 5 to 6 interviews with 2 to 3 trading teams, mixing algorithms, C++ internals, OS and networking, and past-project discussion | Depth in systems, judgment on trade-offs, and fit with specific desks |
| Team match and offer | Feedback pooled across desks; a team that wants you sponsors the offer | Which desk, if any, is willing to put its headcount behind you |
The C++ questions are about what the language actually does
Tower’s C++ screens skip pure trivia and start close to the ground. Expect to explain the difference between a pointer and a reference, what const means in each position it can appear (pointer to const, const pointer, const member function), and why a const member function can still mutate a mutable field. From there it climbs: how RAII gives you deterministic cleanup, what the rule of three or five buys you, when a move constructor fires instead of a copy, and what a std::vector does to your heap when it grows past capacity.
The reason they push on this is latency. A copy you didn’t notice, a heap allocation on a hot path, a virtual call that defeats inlining, these are the things that cost microseconds in a trading loop, and microseconds are the product. A common follow-up: given a class you’d call millions of times per second, where would you look to shave cost? Good answers talk about avoiding allocation in the steady state, keeping data contiguous so the prefetcher can do its job, and being deliberate about when you actually need runtime polymorphism.
// What does this do, and how many string copies happen?
std::vector<std::string> names;
names.push_back("tower"); // construct a temporary, then move it in
std::string s = "research";
names.push_back(s); // copy: s is an lvalue
names.push_back(std::move(s)); // move: s is left valid but unspecified
The value of a snippet like that is less the answer than the conversation around it. If you can walk through where a copy sneaks in, what a reallocation would do to your iterators, and how emplace_back or a reserve call changes the picture, you’re showing the exact instinct the desk is screening for.
Operating systems and networking, because that’s where latency hides
Half of a Tower onsite can feel like an OS oral exam, and that’s fair given the work. Interviewers ask what virtual memory is and what happens on a page fault, how inter-process communication works and when you’d reach for shared memory over a socket, what a port really is at the OS level, and what a context switch costs you. The networking side is just as concrete: the difference between TCP and UDP and why a market-data feed usually rides UDP multicast, what happens during a TCP handshake, and where kernel-bypass techniques like a userspace network stack earn their added complexity.
You don’t need to have written a NIC driver. You do need to reason about where time goes between a packet arriving on the wire and your strategy code reacting to it, and to be comfortable saying “I’d measure that” instead of guessing when you’re past the edge of firsthand knowledge.
The algorithm bar is real but not exotic
The coding problems skew toward classic data-structure and dynamic-programming territory rather than obscure competitive-programming puzzles. Candidates report the online test carrying a couple of DP problems and an object-oriented design question. In the live rounds you’ll get something you can finish in 30 to 40 minutes, then a stream of follow-ups: make it faster, cut the memory, handle a stream instead of a fixed array, prove the complexity. The interviewers care more about how you tighten a working solution than whether you pattern-matched the optimal one in the first minute.
- Design a structure with O(1) insert, delete, and get-random. Now make it thread-safe and explain what that costs.
- Given a stream of prices, maintain a rolling maximum over a sliding window of the last k ticks.
- Parse and evaluate an arithmetic expression, then extend it to a new operator without rewriting the core.
- Sketch an order book and defend the data structure sitting under the bid and ask sides.
That last one blurs into system design, and Tower’s version of system design is smaller and sharper than the design-Twitter ritual at big tech. They want to see you model a real trading-adjacent object, pick the right container for the access pattern, and defend it when they poke at the corner cases.
What good looks like out loud
Candidates who do well narrate their reasoning without turning it into a performance. They state the trade-off they’re making, name the number they’re optimizing for, and say when they’d reach for a measurement rather than a memorized fact. The interviewers care less about polished theory than about whether you can think cleanly under time pressure and admit the edges of what you know. Bluffing a systems answer is the fastest way to lose a Tower engineer’s trust, because the person across the table has profiled the exact thing you’re hand-waving about.
Because you meet several desks, momentum matters. A single lukewarm interviewer rarely sinks you when two teams are enthusiastic, and one team’s excitement can carry an offer even after another desk passes. Treat each conversation as its own audition rather than assuming the panel shares one verdict.
Compensation, and why the ranges are so wide
Tower pays at the top of the market for engineering talent, and the public numbers scatter because so much of the package is discretionary bonus tied to firm and team performance. Aggregators like Levels.fyi put total compensation for a software engineer in the low-to-mid six figures at the median, with senior and specialized seats reaching well past that, and the reported spread from the 25th to the 90th percentile covers more than a factor of two. New-grad base sits in a competitive band with a real sign-on, and the bonus is where a strong year separates from an average one. Treat any single figure you see as a snapshot, check a live source before you anchor on it, and remember that at a prop firm the variable slice swings harder than at a typical tech company.
If you’re prepping, the move with the most payoff is not grinding another hundred LeetCode mediums. It’s making your C++ mental model precise enough to explain what the compiler and the hardware do beneath a single line of code, and building enough OS and networking depth to trace a packet from wire to strategy. Tower hires people who are genuinely curious about where the time goes. Show them you already think that way.
