InterviewLegend

Your Susquehanna Prep Plan

Alex Chen11 min readUpdated
In this lesson
  • Confirm you are on the software / quant-developer track before drilling; the trader track runs a different process
  • Weight prep toward the CodeSignal gate, SIG's recurring problem set and the optimize-the-code round
  • Know what "ready" looks like at each phase, so you advance on skill rather than the calendar

Susquehanna runs two different hiring pipelines under one name, and the first job of any prep plan is to make sure you are on the right one. The famous SIG loop is the quantitative-trader track: a probability and expected-value math test, make-a-market games with cards and dice, and mental math at speed. It is not a coding interview at all. This plan is for the other track, the software-engineer and quant-developer loop. That one is a genuine coding pipeline: a CodeSignal General Coding Assessment, then one or two live technical rounds, then a Super Day. Interviewing to trade? Close this and go drill probability and market-making instead. If you are interviewing to build, the good news is that SIG reskins a small, recurring set of problems rather than a firehose of random algorithms. A focused plan goes a long way.

The Susquehanna angle
Two facts shape everything downstream. First, the SWE assessment is a standard CodeSignal General Coding Assessment, reported at roughly four questions in about seventy minutes, easy to medium. Intern and older reqs have run shorter, so confirm the exact shape with your recruiter rather than assuming. Second, SIG rewards clean data-structure choice and correct stateful implementation over clever optimums. The single most-reported technical problem is a range-and-category lookup store, the "movie database." Candidates over-reach for segment trees there; the interviewer just wants hashmap indexing. Read the interview process and how hiring decisions get made first, so the two-track split and the Super Day are clear before you plan around them.

The plan, phase by phase

Each phase below carries one focus and a checkpoint that tells you when you have earned the next. A phase is a share of your total prep time, not a fixed number of weeks, so the plan holds whether your runway is two months or one hard week. The proportions are the message. The CodeSignal assessment leads, because it is the pass-or-fail gate and nothing downstream counts until you are through it, and its pass rate is widely understood to be low. The recurring problem set does double duty, since the same archetypes that clear the assessment come back in the live round, so time spent there compounds. Design sits light on purpose, because for most SWE reqs SIG "design" means OOP and in-memory optimization, not distributed-systems whiteboarding. Do not step past a checkpoint until you can clear it cold.

1
≈8% · start here

Confirm your track, then map the loop

  • Make sure you are on the software-engineer / quant-developer track and not the quantitative-trader track. The trader loop is a probability and market-making process with no coding; this plan will not prepare you for it, and the coding plan will not prepare you for that. Poker, for the record, is post-hire culture at SIG, not a round you sit and not a skill you need to get an offer.
  • Read the interview process and how hiring decisions get made. The shape is a resume screen, the CodeSignal assessment as a gate, and one or two live technical rounds. Then comes a Super Day of three to six back-to-back sessions, virtual or at a SIG office. End to end is commonly two to four weeks.
  • Ask your recruiter the specifics your req uses: how many CodeSignal questions and how long, how many technical rounds, and whether the final loop is virtual or on-site. The technical-round count varies and is not a pass-or-fail signal, so do not read anything into it.
Ready to move on: You have confirmed you are on the coding track, you can describe the loop in order, and you know your assessment format and where your Super Day will be.
2
≈32% · the gate

Clear the CodeSignal assessment

  • Read the CodeSignal OA and coding bar to see how the assessment is scored and what "good enough" looks like. The bar is clean, correct, well-chosen data structures under a clock, not hard dynamic programming. Most candidates work in Python or C++; fluency in one is enough.
  • Build SIG’s signature problem end to end: the range and category lookup store. Objects carry a name, a category, and a year; you index them so a lookup by category and by year-range answers in near-constant time. The trap is reaching for a segment tree when hashmap bucketing is what the interviewer wants.
  • Drill the OA staples. In the lazy-update hashmap, add-to-all-keys and add-to-all-values stay O(1) by tracking global offsets. The ticker trie and string matching problem loads company-to-ticker pairs into a trie and scans a headline for every ticker it contains.
  • Rehearse simulation and OOP design: a Battleship-style grid that returns per-shot state, and a Premium question that prints a receipt. These are "implement this stateful system correctly," not algorithmic trickery, so practice writing clean, testable classes fast.
Ready to move on: You can take any of the four archetypes cold and land clean, correct, tested code inside a tight time box, and the range-and-category store holds no surprises.
3
≈20% · the onsite

Drill the optimize-the-naive-code technical round

  • Expect a live round in a shared editor, roughly sixty to ninety minutes, sometimes open-notebook, with one or two engineers in C++ or Python. Its signature is reading existing code and optimizing a naive O(N) approach into an indexed lookup, rather than starting from a blank whiteboard.
  • Practice the movie-database problem in its live form: you are handed a CSV read with a linear scan and asked to make repeated queries fast. Narrate the read-versus-query asymmetry, then build the index. The same range-and-category and lazy-update shapes from the assessment return here, so the archetypes you already drilled are the round.
  • Think out loud and state your time and space complexity as you go. SIG engineers are described as collaborative and willing to hint, so treat the round as a working session: talk through the trade-off, choose the structure, test before you call it done.
Ready to move on: You can pick up naive code, name why it is slow, and refactor it to an indexed solution with the complexity spoken, and the CSV-optimize problem is automatic.
4
≈18% · level-gated

Prepare the light design section

  • Read the OOP and low-latency design overview to see how SIG scopes "design." For most SWE reqs it means class design and in-memory optimization, not sharding a distributed system, so calibrate your effort to that and to your level.
  • Work the one worked design, an in-memory market-data store. It is the movie database grown up: model instruments, index them for fast category and range queries, and reason about memory layout and low-latency access rather than horizontal scale.
  • If you are interviewing at a senior or low-latency-team level, be ready for the trading-infrastructure flavor senior candidates report: order books, market-data normalization, and message passing. At most levels, though, design sits light, so do not over-invest here at the expense of the coding archetypes.
Ready to move on: You can carry the in-memory market-data store end to end with a clear indexing and memory argument, or you have confirmed design sits light at your level and prepared to that.
5
≈22% · fit and offer

Prepare fit stories and the offer

  • Read SIG values and fit. The SWE behavioral is a resume-and-fit conversation. Have specific stories ready; a rehearsed rubric won’t carry you here. SIG’s stated values are unnumbered themes, not a principles list: collaboration over the lone genius, questioning your assumptions, individual impact, and dependability and honesty.
  • Build stories around the behavioral themes SIG rewards: reasoning under uncertainty, collaborating rather than playing lone genius, and intellectual honesty about what you did versus what the team did. A genuine, specific "why SIG" that connects to how they work lands better than a generic pitch.
  • Skim negotiating your offer before you need it. SIG is privately held, so there are essentially no RSUs. Comp is a high base plus a cash bonus plus a sign-on. The cash bonus and sign-on are where you push, a different negotiation from a FAANG equity package.
Ready to move on: You have specific stories mapped to reasoning-under-uncertainty, collaboration, and intellectual honesty, a true "why SIG," and you understand the cash-heavy, no-equity offer shape before any number is on the table.

To make the proportions concrete, picture a four-week runway. The first days go to Phase 1: confirm you are on the coding track and map the loop with your recruiter. Week one and half of week two belong to the assessment. Build the range-and-category store, the lazy-update hashmap, the ticker trie, and the simulation and OOP problems until each runs on reflex. These four are most of what CodeSignal and the live round throw at you. The back half of week two is the technical round, working the CSV-optimize problem and narrating complexity until refactoring naive code is automatic. Week three is the light design section, the in-memory market-data store carried end to end, scaled to your level. Week four is fit stories, a true "why SIG," a mock loop or two, and skimming the offer playbook so nothing catches you flat. On a tighter runway you compress the same order without reordering it, because the assessment comes before everything.

Why the phases are weighted this way

The weighting tracks how SIG filters. The assessment leads. It is a hard pass-or-fail gate with a low pass rate, and nothing downstream counts until you are through it. The recurring problem set takes the largest combined share because it is unusually concentrated: the same four archetypes clear the assessment and then reappear in the live round, so hours spent there pay twice. The technical round takes a real band. Its optimize-the-naive-code framing is a specific skill that blank-whiteboard practice leaves you least ready for. Design sits light because for most SWE reqs it is OOP and in-memory work rather than distributed systems, and pushing it hard would steal time from the coding that decides the loop. Fit and offer close the plan. The behavioral is a genuine conversation, not a formality, and the no-equity comp shape rewards knowing the levers before you are asked for a number.

The Susquehanna angle
The trap is preparing for SIG as if it were either the trader track or a generic FAANG loop. People grind probability and market-making for a coding req, or grind hard LeetCode for an assessment that rewards picking a hashmap over a segment tree and implementing a stateful system correctly. Or they whiteboard distributed systems for a round that is really about indexing an in-memory store. Spend your hours where SIG looks. Get the range-and-category store and the other three archetypes into your hands until they flow, make optimizing naive code automatic, keep design light unless your level demands otherwise, and bring honest, specific fit stories. Those pieces turn SIG from a curveball into home ground.

In the room

  • Confirm you are on the coding track first. The trader loop is math, expected value, and market-making games with no coding; poker is post-hire culture, not a round. This plan is for the SWE / quant-developer CodeSignal pipeline.
  • Clear the CodeSignal assessment before anything else. It is a standard General Coding Assessment, reported around four questions in seventy minutes, easy to medium. The bar is clean, correct data-structure choice under a clock, not hard dynamic programming.
  • Drill the four recurring archetypes until they are automatic. The range-and-category lookup store is the signature problem; the lazy-update hashmap, the ticker trie, and the simulation-and-OOP builds round out the set, and they return in the live round.
  • In the technical round, optimize the naive code and speak the complexity. Expect to read an existing linear scan, often a CSV movie search, and refactor it to an indexed lookup in a shared editor. Think out loud and test before you finish.
  • Bring honest fit stories and know the offer shape. The behavioral is a resume-and-fit conversation grounded in unnumbered values; the offer is a high base plus cash bonus plus sign-on with essentially no RSUs, so the cash levers are what you negotiate.

Weight your prep toward what SIG filters on: the CodeSignal assessment, a tiny recurring set of data-structure and OOP problems, an optimize-the-naive-code technical round, and a light design section. Confirm first that you are on the coding track and not the trader track, because the two reward completely different preparation. Clear the assessment before anything else, since it is a low-pass-rate gate, by drilling the range-and-category store and the other three archetypes to reflex, the same shapes that come back in the live round. Keep design light unless your level demands the trading-infrastructure depth. Prepare honest fit stories around reasoning under uncertainty and intellectual honesty, and go in knowing the cash-heavy, no-equity offer so the negotiation holds no surprises.

Key Takeaways

  • ✓Confirm your track before you drill anything. SIG runs a quantitative-trader loop (math, expected value, market-making games, no coding) and a separate software-engineer / quant-developer coding loop. This plan is for the coding track; poker is post-hire culture, not a round.
  • ✓The CodeSignal General Coding Assessment is the gate, so clear it first. It is reported at roughly four questions in seventy minutes, easy to medium, and rewards clean, correct data-structure choice under a clock rather than hard dynamic programming.
  • ✓SIG’s problem set is unusually concentrated. Drill four archetypes to reflex: the range-and-category lookup store (the signature problem, solved with hashmap indexing not segment trees), the lazy-update hashmap, the ticker trie, and the simulation-and-OOP builds. They clear the assessment and return in the live round.
  • ✓The live technical round reads existing code and optimizes a naive O(N) scan into an indexed lookup, often a CSV movie search in a shared editor. Narrate the trade-off, state your complexity, and test before you finish. Design sits light for most reqs: OOP and in-memory work, not distributed systems.
  • ✓Prepare the behavioral and offer as first-class pieces. The SWE behavioral is a resume-and-fit conversation grounded in SIG’s unnumbered values, so bring honest stories on reasoning under uncertainty and collaboration. SIG is private, so comp is high base plus cash bonus plus sign-on with essentially no RSUs, and the cash levers are what you negotiate.
Had your Susquehanna interview?Tell us what they asked. Reviewed before it goes in, never with your name.
Susquehanna interview guide

Know what Susquehanna asks before you walk in.

8 coding · 1 system design · 26 behavioral questions

Get Premium$49 a year · Cancel anytime
Or start freeNo card.

Get their questions first.

InterviewLegend is independent and not affiliated with or endorsed by any company it covers.