SIG software engineering candidates report timed coding, recruiter conversations, deep C++ implementation discussion, low-level design, and follow-ups that test efficiency and changing requirements.
$174K
Avg. Base Comp
$214K
Avg. Total Comp
3-4 rounds
Typical Rounds
Not reported
Process Length
SIG Software Engineer candidates describe an interview path that tests implementation depth alongside practical problem solving. C++ knowledge can be an important theme, particularly understanding and implementing simplified vector::push_back() behavior and discussing possible optimizations. Prepare to explain the choices in your implementation and revise it when an interviewer changes the constraints.
Timed coding appears in several forms: four-question assessments around 70 minutes, 90-minute technical sessions, and shorter live coding segments. Reported prompts include ticker-symbol extraction and a bubble grid that requires connected-component search, removal of cells disconnected from the top row, and follow-ups about efficiency and chained changes. One assessment report also highlighted an empty-input edge case that passed visible tests but failed a hidden test. Practice getting a correct baseline working, checking boundary conditions, and then improving the approach when asked about cost.
Design discussions can focus on concrete implementation rather than only large distributed systems. Candidates mention grocery-checkout, library, and order-book prompts, with attention to classes, data structures, matching behavior, and latency or performance tradeoffs. Recruiter and manager conversations may cover background, motivation, resume projects, workplace scenarios, compensation expectations, and, in one report, mental math. The evidence does not establish one universal sequence, so treat these as reported possibilities rather than a fixed itinerary.
Synthesized from 8 candidate reports by our editorial team.
Had an interview recently?
Share your experience. Unlock the full guide.
Real interview reports from people who went through the Susquehanna International Group, Llp (Sig) process.
The process started with a recruiter screen, followed by a roughly two-hour C++ technical interview. The main task was to implement push_back() for a simplified std::vector-like container. I felt pretty confident at first because I was comfortable with STL internals, amortized O(1) growth, move semantics, and reallocation.
The interview got much harder once the follow-ups started. We went into noexcept moves versus copies, exception safety, allocators, placement construction, type traits, and raw memory management. I made a mistake in the reallocation path involving ownership of the old buffer that could have caused a double free, caught it during the discussion, and corrected the approach. I later advanced to a final virtual onsite with multiple technical discussions, including low-level design, data structures, performance tradeoffs, and C++ implementation details.
The final round felt broader than the first technical. Representative questions included designing a small order-management, choosing data structures for efficient lookup and updates, explaining ownership and lifetime decisions in the design, and optimizing a piece of code after new performance constraints were introduced. I felt strongest when discussing data structures and C++ tradeoffs, but the interviewers kept adding constraints that forced me to revise parts of the design. I was ultimately rejected after the final onsite, but the process made it clear that they were looking for both deep C++ knowledge and the ability to adapt a design under changing requirements.
Questions asked:
How would you implement push_back() for a simplified std::vector?
Why is vector::push_back() amortized O(1), and what happens when capacity is exhausted?
During reallocation, when should existing elements be moved versus copied, and how does noexcept affect that decision?
How do you make the reallocation path exception-safe while correctly managing raw memory and object lifetimes?
Design an Orderbook System
Share your own interview experience to unlock all reports, or subscribe for full access.
Sourced from candidate reports and verified by our team.
Topics based on recent interview experiences.
Featured question at Susquehanna International Group, Llp (Sig)
In which case would you use a bagging algorithm versus a boosting algorithm
| Question | |
|---|---|
| Fixed Length Arrays: Addition | |
| Simple Movie Database | |
| 2nd Highest Salary | |
| Employee Salaries | |
| Merge Sorted Lists | |
| Subscription Overlap | |
| Closest SAT Scores | |
| Empty Neighborhoods | |
| Top Three Salaries | |
| Monthly Customer Report | |
| Rolling Bank Transactions | |
| Find the Missing Number | |
| String Shift | |
| Comments Histogram | |
| Prime to N | |
| Top 5 Turnover Risk | |
| Like Tracker | |
| Maximum Profit | |
| Find the First Non-Repeating Character in a String | |
| Total Spent on Products | |
| Google Maps Improvement | |
| Cumulative Distribution | |
| Rectangle Overlap | |
| P-value to a Layman | |
| Size of Joins | |
| Top 3 Users | |
| Over-Budget Projects | |
| Slacking Employees Salaries | |
| Hurdles In Data Projects |
Synthesized from candidate reports. Individual experiences may vary.
Candidates report HackerRank or CodeSignal-style assessments, including four questions in roughly 70 minutes and, in another account, two easy coding problems. Topics varied from basic algorithmic work to graph, dynamic-programming, greedy, and BFS-style problems. An assessment account also reported a hidden edge case involving empty input.
Candidates report recruiter calls of about 30 minutes that covered background, resume experience, interest in SIG, motivations, compensation expectations, and behavioral or fit questions. One account also reported four mental-math questions completed aloud without a calculator.
Reported technical sessions ranged from roughly 30 to 90 minutes. Candidates describe live coding, explaining complexity and data-structure choices, and C++ follow-ups on a simplified vector `push_back()` implementation, reallocation, exception safety, allocators, and object lifetime.
Candidates report later discussions involving low-level object-oriented design, including grocery checkout, library, order-management, and order-book prompts. Interviewers may ask for class-level detail, efficient lookups and updates, ownership decisions, performance trade-offs, and revisions when constraints change.
