Susquehanna (SIG) Interview Guide (2026)

1Snapshot, read this first#

The one thing to understand about SIG: this is a poker and game-theory culture.

• The firm runs new hires through a months-long poker curriculum, because the mental model is the job: decisions under uncertainty, incomplete information, real money on the line.
• Folding a decent hand because the pot odds are wrong is the same skill as passing on a trade that looks fine but has no edge.
• They are watching how you decide, not just whether you got the number.
• A clean answer arrived at by luck scores worse than a wrong answer arrived at by sound reasoning you narrated out loud.

2Getting the call (the part most guides skip)#

SIG recruits hard at target schools, but it is not a walled garden. Plenty of people get in through the online application and a strong OA score.

Referrals help, but less than at a typical startup.

• A referral mostly gets your resume read by a human instead of a filter, and maybe shaves a few days off the wait.
• It does not carry you through the probability round, because that round is scored on live reasoning no referral can fake.
• Still, get one if you can. Target people on trading-tech, quant-dev, or trading-desk teams, not generic recruiters.
• An engineer's forwarded note lands differently than a cold application.

Resume bullets: they want signal that you build real things and measure them.

• Trading firms love numbers because that is how they think, and a resume full of unmeasured verbs reads as noise.
• Weak: "Built a backend service for order processing."
• Strong: "Built a C++ order-processing service handling 40k messages/sec with p99 latency under 200 microseconds, cutting tail latency 35% by replacing a lock with a lock-free ring buffer."

What that strong bullet is doing:

• A concrete throughput number.
• A latency percentile they actually care about.
• A technology that matters to them (C++, lock-free).
• A specific decision you made, and why.
• Even a class project or a personal trading-bot can read this way if you measured it. If you cannot put a number on a bullet, go find the number or cut the bullet.

ATS keywords that actually matter here:

• C++, low-latency, data structures, algorithms, probability, statistics, Python, Linux.
• multithreading, concurrency, lock-free, networking (TCP/UDP), kernel bypass.
• Any real exposure to markets or trading systems.
• Do not keyword-stuff. One honest project you can defend for ten minutes beats ten buzzwords you cannot.

How people actually get shortlisted:

• A strong OA score.
• A resume with at least one quantified engineering project.
• Often a competitive-programming or math-olympiad background that jumps off the page.
• Have Codeforces (put the rating), USACO Platinum, Putnam (put the rank), or IMO/national-olympiad signal? Put it near the top of the page, not buried in a skills line. SIG hunts that signal because it correlates with the raw reasoning speed the trading game rewards.

3The loop at a glance#

The mix shifts with your track, so confirm yours before you prep.

• Pure SWE and low-latency roles tilt toward coding and systems: often two technical rounds and one lighter probability touch.
• Quant Trader roles flip it: the probability round and the trading game carry most of the weight, and the coding bar relaxes.
• Ask your recruiter which track you are on and weight your prep accordingly. Prepping for the wrong mix is the quietest way to fail.

4The coding or technical rounds#

The coding bar is real but not cruel.

• Think solid medium to light-hard on LeetCode, roughly the 1400 to 1800 difficulty band, not the hardest contest problems.
• They care more about how you get there than exotic tricks.
• A clean optimal solution to a medium beats a shaky half-solution to a hard.

Patterns they reuse:

• Arrays and two pointers, sliding window (max subarray, longest substring without repeats).
• Hash maps for counting and O(1) lookups (two-sum family, group-anagrams, frequency problems).
• Stacks and queues, including monotonic stack (next-greater-element, largest-rectangle-in-histogram).
• Trees and graphs: BFS/DFS, topological sort, basic shortest path like Dijkstra on a small grid.
• Dynamic programming, usually the approachable kind: coin change, longest increasing subsequence, edit distance, grid-path counting. Not a research-paper DP with four-dimensional state.
• Occasionally bit manipulation or a math-flavored problem (modular arithmetic, counting, a probability-adjacent simulation), because this is a math shop and they enjoy it.

For low-latency C++ tracks, expect deeper systems questions:

• How std::vector reallocates and why that matters in a hot loop.
• Cache locality, and why an array-of-structs can beat a struct-of-arrays or the reverse.
• Why a lock-free ring buffer beats a mutex on the critical path.
• Move semantics and when a copy sneaks in.
• "What happens between the exchange sending a packet and your code reacting."
• You do not need to quote NAPI internals. You do need to not hand-wave: if you say "it's faster," be ready to say why, in terms of cache lines, branch prediction, or system calls avoided.

How to actually win the round. This is where most people lose points they did not have to.

• When I run a loop in front of a candidate, what I am really checking is whether they narrate it.
• Say what you are doing: "I am going to use a hash map so lookups are O(1), then one pass over the array, which gets me O(n) time and O(n) space."
• That one sentence tells me you understand the tradeoff, not just the syntax, and it lets me nudge you before you waste ten minutes down a wrong path.

The loop I want to see:

1. Clarify. Repeat the problem back in your own words. Ask about input size (hundreds or billions?), duplicates, negatives, empty input, integer overflow. Thirty seconds here saves you from confidently solving the wrong problem.
2. Talk the approach before you type. Give the brute force, say its complexity out loud, then improve it. Even if you jump straight to optimal, show you saw the naive path so I know you did not just memorize the trick.
3. State complexity and mean it. Time and space. If you say O(n) and your code is secretly O(n log n) because of a sort you forgot about, I will catch it, and now I am wondering what else you do not track.
4. Code cleanly. Real names, no magic numbers, handle the edge cases you listed in step one. Blanking? Write the function signature and the loop skeleton first, then fill the body. Structure visible on screen beats a blinking cursor.
5. Test it yourself. Walk a small example by hand, out loud, and deliberately pick one tricky case (empty, single element, all duplicates). Catch your own off-by-one before I do. Candidates who test themselves read as people who ship working code, which is the whole point.

5The probability and market-making round (your real differentiator)#

This is the round that separates SIG from a generic tech loop, and the one most engineers under-prepare.

• Do not skip it because you think of yourself as "a coder."
• On the trading track this round outweighs the coding round.
• Even on the SWE track it can be the tiebreaker that decides your level or your offer.

Probability and brain-teasers. The topics come up again and again:

• Expected value of games (dice, coins, cards). Compute EV fast, and when the game repeats, set up the recursion. Example: "You roll a die repeatedly, summing, and stop whenever you choose. What is the optimal stopping strategy and its EV?" The answer rides on comparing your current sum to the EV of rolling again.
• Conditional probability and Bayes. The classic reframes: the two-children problem, Monty Hall updates, "I flipped two coins and at least one is heads, probability both are heads is 1/3 not 1/2." Know why it is 1/3, do not just memorize it.
• Combinatorics: permutations, combinations, counting without overcounting, inclusion-exclusion for the "at least one" questions.
• Distributions you can reason about: uniform, binomial, geometric, Poisson. Know the expectation shortcuts cold (for example, the expected number of flips to get the first head on a coin with probability p is 1/p) and be able to derive it on the spot.
• Logic and estimation puzzles. Fermi estimates ("how many ping-pong balls fit in this room," "how many gas stations in the US") where they grade your decomposition and your sanity-checks, not your final number. Say your assumptions out loud so they can follow the chain.

Mental math. They will test raw arithmetic.

• Sometimes as a timed mental-math sprint early in the process (SIG's screen is known for this, often dozens of quick questions against the clock).
• Practice multiplying two-digit numbers, computing percentages, and converting fractions to decimals fast.
• Get comfortable estimating: 7/16 is about 0.44, and you should know that in a breath, not grind out long division.
• Drill it daily until it is reflex. Fumbling 13 times 24 in front of a trader reads as disqualifying whether that is fair or not.

The market-making game. This is the signature round, and you cannot cram it the night before.

• A version: the interviewer picks a hidden quantity (sum of two dice, number of a certain letter in a sentence, the population of a country, your own future exam score).
• You quote a two-sided market, a bid and an ask, out loud, for example "I am 8 bid at 12."
• They can hit your bid (sell to you) or lift your ask (buy from you), and then they feed you a piece of information.
• You re-quote. Repeat several rounds.

What they are grading:

• Spread around your true EV. Too tight and you get picked off when you are wrong; too wide and you are not really making a market and they will say so. The spread should reflect how uncertain you are: wide when you know little, tightening as you learn.
• Correct updates on new info. If the hidden number is the sum of two dice (EV 7) and they tell you one die is a 6, your whole market should shift up fast. Show the update, do not just mumble a new number.
• Risk and position sense. If they keep lifting your ask round after round, that is a signal you are quoting too low. Notice it, infer you may be on the wrong side, and adjust rather than mechanically repeating the same market.
• Staying calm while picked off. Tilt is the failure mode this whole exercise is designed to expose.

You cannot "solve" this with a formula. You play it until the rhythm is in your hands.

• Grab a friend, use a deck of cards or a pair of dice, and run the game at least ten times before your onsite, alternating who is the maker.
• The muscle memory, quote, get info, re-quote without freezing, is the actual prep.

6Behavioral and culture fit#

SIG's culture is real and specific: intellectual honesty, curiosity, collaboration, and comfort with calculated risk.

• The poker thing is not a gimmick, it is the firm telling you what it values.
• They want people who can say "I was wrong" without ego, update their view on new information, and keep going.
• That is literally how you survive at a trading desk, where being wrong is routine and refusing to admit it is fatal.

Prepare STAR stories (Situation, Task, Action, Result) for:

• A time you were wrong and changed your mind.
• A hard technical decision with a real tradeoff.
• A conflict you resolved.
• A time you taught yourself something fast under a deadline.
• End each one with a number, because a result without a number is just a feeling.

One full worked example:

Situation: Our team's backtesting job was taking 40 minutes per run, so analysts only ran it overnight, which slowed every strategy decision by a full day. Task: I owned making it fast enough to run on demand, ideally under 5 minutes, without changing any results. Action: I profiled it instead of guessing. 80% of the time was in a pandas loop recomputing rolling stats symbol by symbol. I vectorized the hot path with NumPy, cached intermediate frames that were being recomputed, and parallelized across symbols with a process pool. Then I wrote a diff test comparing old and new outputs on a full year of data to prove nothing changed. Result: Runtime dropped from 40 minutes to about 3, a 13x speedup, and analysts went from one overnight run to roughly a dozen iterations a day. The diff test caught two edge cases I would otherwise have shipped as silent bugs.

Why that story is the SIG shape:

• Curiosity: profiled, did not guess.
• Intellectual honesty: built a test to prove correctness rather than assuming it.
• A concrete number at the end.
• They will probe with follow-ups ("why not just add more machines?"), so pick stories you actually lived and can defend three questions deep.

Have a real "why trading?" and "why SIG?", not a recited one.

• "I like making decisions under uncertainty and I want my code to matter in microseconds, not in a sprint-review slide" beats "the comp is great," even though the comp is, in fact, great.
• They pass on people who clearly see SIG as a brief high-paying stop before something else.

7Your prep plan#

4-week plan:

• Week 1: 3 to 4 LeetCode mediums a day across arrays, hash maps, trees, graphs. Narrate every solution out loud as if someone is grading you. Start a daily 10-minute mental-math drill (two-digit multiplication, percentages, fractions to decimals).
• Week 2: Probability. Work through a problem set on EV, conditional probability, and combinatorics, one focused set per topic. Do one brain-teaser set a day. Keep LeetCode light, 1 to 2 a day, to stay warm.
• Week 3: Market-making game with a friend or a deck of cards, 20 or more reps, swapping roles. Add DP (coin change, LIS, edit distance) and, if you are on the low-latency track, C++ systems review: memory layout, cache, concurrency, lock-free basics.
• Week 4: Full mock loops. One coding, one probability, one game per sitting, timed. Diagnose your weakest round from the mocks and spend your extra hours there. Write and rehearse your STAR stories.

2-week plan:

• Days 1 to 5: LeetCode mediums (3 a day) + daily 10-minute mental math + one probability set.
• Days 6 to 9: Probability and brain-teasers hard, plus market-making reps every day.
• Days 10 to 12: Timed mocks, and C++/systems review if your track calls for it.
• Days 13 to 14: STAR stories, rest, light review only. Do not cram the night before; a tired brain fumbles mental math, and mental math is half the game.

2-day crash plan:

• Day 1: Re-solve 10 classic mediums (two-pointer, sliding window, hashing, BFS/DFS, one DP). Run 30 minutes of mental math. Learn EV, Bayes, the two-children problem, and the geometric 1/p expectation cold.
• Day 2: Play the market-making game 10 times with dice or cards. Write 3 STAR stories, each ending in a number. Re-read your resume and be ready to defend every single line. Sleep a full night.

8Why people get rejected at SIG#

1. Froze on the probability round. Strong coder, blank face at "expected value of this game." They under-prepped the exact thing that defines SIG and tried to coast on their coding strength.
2. Silent problem-solving. Got the right answer but never said a word, so the interviewer could not see the reasoning and could not trust that it was not luck. Untrusted answers do not count.
3. Shaky mental math. Fumbled basic arithmetic in the timed sprint or inside the trading game. At a firm that prices options in real time, that reads as disqualifying, fairly or not.
4. Ego when corrected. Argued instead of updating when the interviewer pushed back on a quote or an answer. That is the single clearest anti-signal for a poker culture built on changing your mind on new information.
5. Played the market-making game badly. Quoted a crazy wide or crazy tight spread, never updated when info arrived, got picked off round after round, and did not notice they were on the wrong side.
6. No real "why SIG." Treated it as just another high-paying tech job and could not say anything specific about trading or the firm. They can tell in thirty seconds, and they pass on people who will not stay.

9The offer, comp and negotiation#

SIG pays at the top of the market, especially for new grads, and on the trading side the bonus is where the real money lives.

• US new grad SWE: roughly $150k to $200k base, sign-on often $25k to $50k or more, plus a meaningful performance bonus. First-year total commonly $200k to $350k+.
• US Quant Trader: similar base, but the performance bonus dominates and is far less fixed. A strong year pushes total well past $300k, and top performers earn multiples of that; a flat year is more modest. Understand that variance before you compare offers.
• Dublin / London: GBP 90k to 130k+ base for strong grads, with a large bonus on top. Genuinely elite for Europe, often the best new-grad comp on the continent.
• India / APAC: a real and growing presence (SIG India plus APAC desks), competitive local-plus comp, smaller footprint than the US hub but a legitimate seat.

Negotiation tips, SIG-flavored:

1. Competing offers move the number. A Jane Street, Citadel, HRT, Optiver, or top-tier FAANG offer gives you real leverage on sign-on and sometimes base. Be honest about what you are holding, because they know these firms and will sanity-check the shape of your claim. A fabricated offer is a fast way to lose trust at a firm built on reading people.
2. Ask about the bonus structure, not just base. On the trading side the bonus is most of the comp, so two offers with identical base can be wildly different. Ask how the bonus is determined, how much is discretionary versus formulaic, and what a median versus strong year looks like, before you compare naively.
3. Negotiate sign-on and start date gently. These are the most flexible levers for new grads. Base bands are fairly fixed across a cohort, but one-time sign-on money and start timing have room. Be polite and specific ("would you be able to move the sign-on to $X given my competing offer"), not adversarial. This is a firm that respects a clear, reasoned ask and quietly dislikes a sloppy one.

When you are ready, map these rounds onto your actual calendar and build a dated plan you can follow day by day.