Interview guides · Cerberus Capital Management

Cerberus Capital Management Software Engineer Interview Guide

Cerberus Capital Management Software Engineer interview guide: reported rounds, C# and .NET questions, algorithms, behavioral prompts, 7-day plan.

The 60-second brief

Cerberus Capital Management is an investment management firm. Candidate reports describe the Software Engineer role as building and maintaining software behind its investment strategies and daily investment operations, across products that range from trading platforms to data analysis tools. The work also covers troubleshooting existing systems, taking part in code reviews, and turning requirements from product managers, analysts and traders into technical specifications.

This guide is for candidates interviewing for a Software Engineer position at Cerberus Capital Management. It covers the two reported stages (a recruiter phone screen and the technical interviews), the C# and .NET fundamentals candidates report, the data structure, algorithm, troubleshooting and data-handling questions on the reported list, and the behavioral prompts. Reports say questions vary by team and no loop covers every topic, so treat the question list as a practice set rather than a script.

Candidates report two stages over roughly 2-4 weeks: a phone screen with a recruiter about background and role fit, then one or more technical interviews that may include coding challenges and system design discussions.

Focus areas

Garbage Collection (GC)
React (front-end framework)
Project-based technical assessment

Overview

The requirements candidates describe put C# and the .NET framework first, with C++ also mentioned in the preparation tips, plus data structures, algorithms and Agile working methods. Cloud technologies, microservices, financial concepts, unit testing frameworks and CI/CD practice are listed as nice-to-haves. The practical reading is that you should be able to write C# by hand and explain what the runtime does underneath it, not just name design patterns.

The reported technical questions are mostly fundamentals. Five are language and concepts questions: object-oriented principles, how garbage collection works in C#, stack versus queue, handling deadlock in multithreaded code, and polymorphism in C#. Four are coding or algorithm questions: reverse a linked list, explain recursion with an example, implement binary search, and compare the time complexity of sorting algorithms. Four are case-style questions about managing large datasets, finding anomalies or errors in a dataset, troubleshooting a performance issue, and judging whether a software implementation succeeded. Topic tags from candidate reports also mention .NET and CLR internals, React, a programming task, and a project-based technical assessment, so confirm the format with your recruiter.

The five reported behavioral prompts cover a hard project challenge, prioritising across projects, teamwork, motivation and handling feedback. The role description mentions code reviews, troubleshooting existing systems and working with traders, analysts and product managers, so pick stories that include at least one of those. Candidates are also advised to learn some of the financial context; that is a bonus on top of the C# and algorithm fundamentals, not a replacement for them.

The Cerberus Capital Management interview process

Candidates describe two stages. The second stage may be several technical interviews rather than one, so treat it as the bulk of your preparation.

Phone Screen

Candidates report an initial call with a recruiter that checks your background against the role. No technical content is reported for this stage, so approach it as a short, structured conversation about what you have built and whether it matches a C# and .NET engineering role in an investment setting. Have a clear CV narrative, a view on why this role, and your own questions about what the technical stage involves.

What to demonstrate

Background and experience against the role, as the stage is described
Fit for a Software Engineer position working with C# and .NET
How clearly you describe your own projects

How to prepare

Write a short CV narrative that leads with your C# or .NET work, and C++ if you have it, and names one project you can discuss in depth.
Map your experience to the listed requirements: Agile, unit testing, CI/CD, cloud or microservices, and any exposure to financial systems.
Prepare questions for the recruiter: whether the technical stage has live coding, a project-based task or system design, which language you will code in, and who you will meet.
Know your availability, since candidates report a process of roughly 2-4 weeks.

Technical Interviews

Candidates report one or more technical interviews that may include coding challenges and system design discussions. Topic tags from reports also mention garbage collection, .NET and CLR internals, React, a programming task and a project-based technical assessment, though which of these you meet depends on the team. Approach it as three kinds of work: write correct C# for classic algorithm problems, explain runtime and concurrency concepts precisely, and reason aloud through case-style problems such as large datasets, anomalies and performance.

What to demonstrate

Working code for a coding challenge, since that format requires it
How you structure a design discussion and explain your choices
C# and .NET knowledge, including memory management and threading as reported
Data structure and algorithm fundamentals and their complexity

How to prepare

Write linked-list reversal, binary search and a recursive example in C# without an IDE, and test empty, single-element and two-element inputs.
Prepare a spoken explanation of garbage collection in C# and of deadlock handling, each with a short code or diagram example.
Outline answers for the large-dataset design question and the performance troubleshooting question as numbered steps you can say aloud.
If your recruiter confirms a project-based task or React, set aside time for a small tested C# project and a component-and-state refresher.

Where candidates lose points

Defining object-oriented principles, polymorphism or garbage collection in textbook terms with no C# detail

For each concept prepare one mechanism-level explanation and one C# example. For polymorphism, show a virtual method overridden in a derived class and the same call through an interface. For garbage collection, cover the managed heap, generations, roots, the large object heap and when IDisposable matters.

Writing linked-list reversal or binary search silently, then hitting off-by-one or null-pointer bugs

Say the invariant first: for reversal, previous, current and next pointers; for binary search, the interval you are keeping. Write it in C# by hand, then walk an empty input, one element and two elements. Use a midpoint form that cannot overflow.

Answering the deadlock question with "avoid locks" and nothing else

Name the four conditions for deadlock, then give the fixes: a consistent lock order, shorter critical sections, timeouts such as Monitor.TryEnter, and fewer shared locks. Be ready to write a two-lock deadlock in C# and show how ordering fixes it, and to say how you would find one in a hung process.

Jumping to a tool or technology on the large-dataset, anomaly and performance case questions

Ask about data size, growth, access pattern and what counts as an anomaly or a success before choosing anything. For performance, measure first, form a hypothesis, change one thing and measure again, so the answer is a sequence rather than a list of buzzwords.

Behavioral answers that stay in "we", name no decision of yours, and end with a virtue instead of a result

Build each story around your own decision, the alternatives you rejected and a result you can check. Prepare separate stories for challenge, prioritisation, teamwork and feedback so you do not reuse one project for all five prompts.

Questions & practice

Explain how garbage collection works in C#.

Medium · Technical / Domain Questions

Approach

Describe the CLR collector as a tracing, generational, compacting collector: it starts from roots (stack locals, static fields, CPU registers, GC handles), marks everything reachable, reclaims the rest and compacts survivors so allocation stays a pointer bump.
Explain generations 0, 1 and 2: new objects go to gen 0, survivors are promoted, and gen 0 collections are cheap because most objects die young; a full gen 2 collection is the expensive one.
Cover the Large Object Heap: objects of 85,000 bytes or more go there, are collected only with gen 2 and are not compacted by default, which is why large short-lived arrays cause fragmentation (ArrayPool<T> helps).
Separate memory from resources: the GC frees managed memory only, so file handles, sockets and connections need IDisposable with using; finalizers are a fallback that delays reclamation by at least one extra collection, and Dispose calls GC.SuppressFinalize.
Mention the modes: workstation versus server GC, and background GC that runs gen 2 collection concurrently with application threads to cut pause times.

Follow-up

How can a managed C# application still leak memory, for example through event handler subscriptions or static collections?
Why is calling GC.Collect in production code usually a mistake?
How would you reduce allocation pressure in a hot path (structs, Span<T>, pooling)?

How do you handle deadlock situations in multithreaded environments?

Medium · Technical / Domain Questions

Approach

Define deadlock through the four necessary conditions: mutual exclusion, hold and wait, no preemption and circular wait; breaking any one of them prevents it.
Prevent it first: acquire locks in one global order (for example by account id when moving funds between two accounts), keep lock scope small, and never call external code, events or blocking I/O while holding a lock.
Use timeouts where ordering is hard: Monitor.TryEnter(obj, timeout) or SemaphoreSlim.WaitAsync with a timeout lets a thread back off, log and retry instead of waiting forever.
Cover the async case in C#: blocking on a Task with .Result or .Wait() inside a single-threaded synchronization context can deadlock; the fix is async all the way, plus ConfigureAwait(false) in library code.
Diagnose it in production by capturing a memory dump and inspecting thread stacks and lock owners (SOS commands such as clrstack and syncblk, or Visual Studio's Parallel Stacks window); for database deadlocks the engine kills one transaction as the victim, so make that operation safe to retry.

Follow-up

What is the difference between a deadlock and a livelock, and how would you notice each?
When would you replace a lock with Interlocked operations or ConcurrentDictionary, and what do you lose?
How would you test that a lock ordering rule actually holds across the codebase?

Write a function to reverse a linked list.

Medium · Coding / Algorithms

Approach

Use the iterative three-pointer method: keep prev = null and curr = head; in each step save next = curr.next, set curr.next = prev, then move prev = curr and curr = next; return prev as the new head.
State the cost: O(n) time and O(1) extra space, since each node is visited once and only pointers change.
Walk the edge cases aloud: an empty list returns null, a single node returns itself, and a two-node list confirms the pointer order is right.
Offer the recursive version and its trade-off: reverse the rest, then set head.next.next = head and head.next = null; it is O(n) time but O(n) call-stack space, so a very long list can overflow the stack.
Write it in C# with a small ListNode class and trace a three-node example to show no node is lost.

Follow-up

Reverse only the nodes between positions m and n, or reverse the list in groups of k.
How does the code change for a doubly linked list?
What happens if the list contains a cycle, and how would you detect that first?

Explain the concept of recursion and provide an example.

Medium · Coding / Algorithms

Approach

Define recursion as a function solving a problem by calling itself on a smaller instance, with a base case that stops it and a recursive case that must move toward the base case.
Give a clean example such as summing the values in a binary tree: return 0 for a null node, otherwise node.Value + Sum(node.Left) + Sum(node.Right); O(n) time and O(h) stack space for tree height h.
Explain the call stack: each call holds a frame, so depth is the limit; in .NET a StackOverflowException cannot be caught and ends the process, and the C# compiler does not guarantee tail-call elimination.
Show the overlapping-subproblem trap: naive recursive Fibonacci takes exponential time (about 1.618^n calls), while memoizing results or iterating brings it to O(n).
Say when to convert to iteration with an explicit Stack<T>: very deep or unbalanced inputs such as long linked structures or degenerate trees.

Follow-up

Rewrite your recursive example iteratively with an explicit stack.
What is the time and space complexity of naive recursive Fibonacci, and why?
How would you generate all subsets or permutations of a list recursively?

How would you implement a binary search algorithm?

Medium · Coding / Algorithms

Approach

State the precondition: the array must be sorted; keep lo and hi bounds and compare the target with the middle element, discarding half the range each step for O(log n) time and O(1) space.
Compute the midpoint as lo + (hi - lo) / 2 to avoid integer overflow, and keep one loop invariant consistently, for example while (lo <= hi) with hi = mid - 1 and lo = mid + 1.
Handle the edge cases: empty array, target smaller than the first or larger than the last element, a single element, and duplicates.
For duplicates, write the lower-bound variant that returns the first index whose value is >= target, which also gives the insertion point.
Mention the library behaviour in .NET: Array.BinarySearch and List<T>.BinarySearch return a negative number, the bitwise complement of the insertion index, when the value is not found.

Follow-up

Find the first and last occurrence of a value in a sorted array with duplicates.
Search for a value in a sorted array that has been rotated at an unknown pivot.
How would you use binary search on an answer range, such as the minimum capacity needed to finish within a deadline?

Discuss the time complexity of various sorting algorithms.

Medium · Coding / Algorithms

Approach

Anchor on the comparison-sort lower bound: any comparison sort needs Omega(n log n) comparisons in the worst case, which merge sort and heapsort meet.
Compare the main algorithms: quicksort averages O(n log n) but is O(n^2) in the worst case, in place and not stable; merge sort is O(n log n) in all cases, stable, with O(n) extra space; heapsort is O(n log n) worst case with O(1) extra space but not stable.
Name the quadratic sorts and when they still win: insertion sort is O(n^2) worst case but O(n) on nearly sorted input and fast for small arrays, which is why hybrid sorts use it for small partitions.
Cover non-comparison sorts: counting sort in O(n + k) for small integer ranges and radix sort in O(d(n + k)) for fixed-width keys.
Connect to .NET: Array.Sort and List<T>.Sort use introsort (quicksort switching to heapsort and insertion sort), which is not stable, while LINQ OrderBy is stable, which matters when sorting by one key after another.

Follow-up

Which algorithm would you use for data that is already almost sorted, and why?
How would you sort a file of trades too large to fit in memory?
Why does stability matter when you sort records first by date and then by account?

Hold a per-tenant active cap against concurrent creates

Hard · write skew · isolation levels · constraints

A tenant on the standard plan may hold at most 50 resources with status='active'. The create handler runs SELECT count(*) FROM resource WHERE tenant_id = $1 AND status = 'active', compares to 50, then inserts. Two creates arrive 3 ms apart on different instances and the tenant lands at 51. Name the anomaly, say whether PostgreSQL 16 READ COMMITTED or REPEATABLE READ prevents it and why, then give an implementation that holds the cap at READ COMMITTED with the exact statements. Finally, say what changes when the cap is 'at most one running export per tenant' on job_run.

Approach

Name it: write skew. The two transactions read an overlapping set and write disjoint rows, so there is no row-level conflict for the engine to detect and each commit is individually legal.
Rule out the levels precisely. READ COMMITTED takes a fresh snapshot per statement and takes no lock on the counted rows, so both see 49. PostgreSQL's REPEATABLE READ is snapshot isolation: it removes non-repeatable reads and phantoms within the snapshot but still admits write skew, because the anomaly is not a re-read of a changed row, it is a read of a set that a concurrent transaction invalidates. Only SERIALIZABLE closes it, by tracking the read dependency and aborting one transaction with SQLSTATE 40001 — a guarantee that exists only if the application re-runs the whole transaction from the read.
Convert the set predicate into a single-row conflict: keep tenant.active_resource_count and run UPDATE tenant SET active_resource_count = active_resource_count + 1 WHERE tenant_id = $1 AND active_resource_count < 50 in the same transaction as the INSERT. Zero affected rows is the cap, returned as 409. The row lock serialises the decision at any isolation level, and contention is bounded to one tenant's row — which is also the fair-scheduling unit, unlike a global counter that would convoy every tenant behind one row.
State the cost you just took on: a counter is a second source of truth that can drift, so every path that changes status must adjust it inside the same transaction, and a periodic reconciliation has to exist, with resource_revision as the authority for what the count should have been.

Follow-up

A resource moves from archived back to active. Which statements change, and what breaks if the counter update and the status change land in different transactions?
The cap becomes plan-dependent and a plan can change mid-month. Where does the number 50 live, and who reads it?

Explain why the owner filter ignores the listing index

Medium · composite index · query plans · sort elimination

The only index on resource is (tenant_id, status, updated_at DESC, resource_id DESC). A new endpoint returns one user's resources across all statuses, newest created first: WHERE tenant_id = $1 AND owner_user_id = $2 ORDER BY created_at DESC LIMIT 20. On a tenant with 2M rows it takes 900 ms and EXPLAIN shows a sort above a large scan. Explain precisely why the existing index cannot serve it, give the index that can, and state which of these the new index still will not help: owner_user_id alone across tenants; the same query ordered by updated_at. PostgreSQL 16.

Approach

Separate the two jobs an index does. For filtering, a composite btree is seekable only on a left prefix, so with no predicate on status the scan can at best range over tenant_id and test owner_user_id per row; PostgreSQL 16 has no btree skip scan to jump the unconstrained column.
For ordering, the index is sorted by (status, updated_at) within a tenant and not by created_at, so the LIMIT cannot stop early: every matching row is read and then sorted. That is the 'Sort Method: top-N heapsort' line, and it is why the plan reads 2M rows to answer with 20.
Derive the replacement from the access path — equality, equality, then the ordering column: CREATE INDEX CONCURRENTLY ON resource (tenant_id, owner_user_id, created_at DESC). The scan seeks to the (tenant, owner) range and walks 20 entries in order, so the Sort node disappears along with the row-read.
Treat INCLUDE (title, status) as conditional, not free. An index-only scan still visits the heap for any row whose page is not marked all-visible, so on a table taking 1.2k writes/second the win depends on autovacuum keeping the visibility map current, and the wider index costs more on every insert.

Follow-up

90% of rows are status='active'. Would a partial index WHERE status = 'active' change your answer, and for which of the three queries?
A dashboard runs this for 40 owners in one page load. What changes about the design?

What are the principles of object-oriented programming?

Medium · Technical / Domain Questions

Approach

Name the four principles and give each a one-line C# example: encapsulation (private fields behind properties and methods that guard invariants), abstraction (an interface or abstract class exposing what a type does, not how), inheritance (a class deriving from one base class), polymorphism (a base reference calling the derived override at runtime).
Point out that C# allows single class inheritance but multiple interface implementation, so shared contracts usually go in interfaces and shared code in a base class or a composed helper.
Tie encapsulation to correctness: a Position class that only changes quantity through Buy and Sell methods cannot be left in an invalid state by outside code, unlike one with a public setter.
Say when not to inherit: prefer composition when the relationship is 'has a' or when a subclass would have to break the base contract (the Liskov substitution principle from SOLID).
Close with the trade-off: deep inheritance hierarchies couple subclasses to base-class internals, so keep them shallow and program to interfaces.

Follow-up

When would you choose an abstract class over an interface in C#, given that interfaces can carry default implementations since C# 8?
Give an example of an inheritance hierarchy that violates Liskov substitution and how you would restructure it.
How does encapsulation change when a type has to be immutable or shared across threads?

Describe the differences between a stack and a queue.

Medium · Technical / Domain Questions

Approach

State the core difference: a stack is last in, first out (push, pop, peek at the top) and a queue is first in, first out (enqueue at the back, dequeue from the front); all of these are O(1), amortized O(1) when backed by a growing array.
Name the .NET types: Stack<T> and Queue<T> (Queue<T> is a circular array buffer), plus ConcurrentStack<T> and ConcurrentQueue<T> for multi-threaded use.
Give uses that show the access order matters: stacks for the call stack, undo history, bracket matching and iterative DFS; queues for BFS, request or order processing in arrival order and producer-consumer pipelines.
Cover edge cases: popping or dequeuing an empty collection throws InvalidOperationException, so use TryPop or TryDequeue or check Count first.
Contrast with neighbours: a deque allows both ends, and a priority queue (PriorityQueue<TElement, TPriority> in .NET 6+) dequeues by priority with O(log n) operations rather than by arrival order.

Follow-up

Implement a queue using two stacks and explain why dequeue is amortized O(1).
How would you make a bounded queue that blocks producers when full (BlockingCollection or Channel<T>)?
Why does a queue backed by a plain array need a circular buffer?

What is polymorphism, and how is it implemented in C#?

Medium · Technical / Domain Questions

Approach

Define polymorphism as one interface with many implementations: code written against a base type or interface runs the behaviour of the actual object at runtime.
Separate the two kinds: compile-time (method overloading, operator overloading, generics) resolved by the compiler, and runtime (virtual/override, abstract members, interface implementation) resolved through the object's method table.
Give a short example: an abstract Instrument with an abstract Price() method, Bond and Equity overriding it, and a loop over List<Instrument> that prices each without a type check.
Call out the C# trap: the new modifier hides a base method instead of overriding it, so the call is chosen by the variable's static type; sealed override stops further overriding.
Mention the cost and alternative: virtual calls go through an indirection the JIT can sometimes devirtualize, and generic constraints give polymorphism resolved per type argument.

Follow-up

What does this print if a base reference points at a derived object whose method is declared with new rather than override?
Why is calling a virtual method from a constructor risky in C#?
How would you replace a growing switch on an object's type with polymorphism?

How would you approach designing a system to manage large datasets efficiently?

Medium · Problem-Solving / Case Studies

Approach

Clarify the shape before choosing anything: data volume and growth rate, read versus write ratio, query patterns (point lookups versus large scans and aggregations), latency targets, retention and consistency needs.
Pick storage from the access pattern: a relational store with indexes for transactional lookups, and a columnar format or warehouse (for example Parquet files or a column store) for analytical scans, where compression and reading only needed columns cut I/O.
Partition by the main filter, usually date, so queries and deletions touch only relevant partitions; add indexes only for real query paths, since each one slows writes.
Make ingestion idempotent: load in batches or streams keyed by a natural key so a rerun or backfill does not create duplicates, and validate schema and row counts at the boundary.
State the trade-offs: denormalising and precomputing aggregates speeds reads at the cost of storage and refresh complexity; caching helps repeated reads but needs an invalidation rule.

Follow-up

How would you reprocess six months of history after a bug in the transformation logic?
What changes if the data grows tenfold and the main query starts timing out?
How would you handle a schema change in the incoming data without breaking downstream consumers?

Given a dataset, how would you identify anomalies or errors?

Medium · Problem-Solving / Case Studies

Approach

Start with structural checks before statistics: schema and types, nulls in required fields, duplicate keys, out-of-range values (negative quantities, future dates) and referential integrity against reference tables.
Apply simple statistical rules per column: z-scores when the data is roughly normal, or the IQR rule (below Q1 - 1.5 x IQR or above Q3 + 1.5 x IQR) and median absolute deviation when it is skewed or already contains outliers.
For time series, compare each point with its own history: rolling mean and standard deviation, day-over-day change, and seasonality, so a normal month-end spike is not flagged.
For multivariate cases, mention methods such as isolation forest or checking relationships between fields (for example price x quantity matching the reported amount).
Separate errors from genuine extremes: confirm flagged rows against the source, quarantine rather than delete them, and turn confirmed rules into automated checks in the pipeline.

Follow-up

How would you set thresholds so the checks do not flood people with false positives?
A price series shows a single-day jump of 40 percent: how do you decide whether it is an error?
What would you do with flagged records while they are being investigated?

How would you evaluate the success of a software implementation?

Medium · Problem-Solving / Case Studies

Approach

Define success criteria before release and tie them to the problem the software was built to solve, with a baseline measured from the old process or system.
Cover several dimensions: user outcomes (adoption, time to complete a task, manual steps removed), reliability (error rate, incidents, availability), performance (latency under real load) and cost to run and maintain.
For systems that replace an existing one, run old and new in parallel and reconcile outputs to prove correctness before switching over.
Combine metrics with feedback from the people who use it daily, since adoption numbers alone can hide workarounds.
Review after a fixed window and compare to the baseline; separate the effect of the software from other changes happening at the same time.

Follow-up

What do you do when two success metrics move in opposite directions, such as speed improving while error rate rises?
How would you evaluate an internal tool where usage is mandatory, so adoption tells you nothing?
How do you show the improvement came from your change and not from something else?

Describe your process for troubleshooting a performance issue in an application.

Medium · Problem-Solving / Case Studies

Approach

Pin the symptom with numbers: which operation, p50 versus p99 latency or throughput, since when, and what changed around then (deploy, data volume, configuration).
Reproduce and measure before guessing: check CPU, memory, disk and network, GC counts and pause time, thread pool queue length and lock contention (dotnet-counters gives these live for .NET).
Decide whether the time is spent computing or waiting: high CPU points to a profiler (dotnet-trace, PerfView, Visual Studio profiler) and hot methods; low CPU with high latency points to I/O, locks or thread pool starvation from blocking calls.
Check the database path: slow queries, the execution plan, missing indexes, and N+1 query patterns from an ORM loop.
Change one thing at a time, measure again against the baseline, and add a benchmark (for example BenchmarkDotNet) or a load test so the regression is caught next time.

Follow-up

CPU is low but requests are slow: what are your top three suspects and how do you confirm each?
Memory grows steadily until the process restarts: how do you find what is holding it?
How would you tell whether the slowdown is caused by the recent deploy or only coincides with it?

Suggested practice checklist

The plan follows the two reported stages: day one maps the loop, days two to five cover the C# concepts, algorithms and case questions from the technical interviews, day six builds the behavioral story bank, and day seven is a mixed mock run.

Day 1 — Map the loop and the requirements

Write down the two reported stages and the topics candidates tag: garbage collection, CLR internals, React, a programming task and a project-based assessment.
Build a table matching each requirement (C#, .NET, algorithms, Agile, unit testing, CI/CD, cloud or microservices) to a project of yours that proves it.
Write the questions you will ask the recruiter about the format of the technical stage.

Deliverable: A one-page loop map, a requirement-to-evidence table and a list of recruiter questions.

Day 2 — C# memory management and the CLR

Explain aloud how garbage collection works in C#: managed heap, generations, roots, the large object heap, finalizers versus IDisposable.
Write a short C# snippet that allocates in a loop and one that holds an unintended reference, and say how each behaves under the collector.
List what you can say about the CLR beyond collection, such as just-in-time compilation and the type system.

Deliverable: A one-page garbage collection and CLR cheat sheet, a spoken answer you can repeat cleanly, and two annotated C# snippets.

Day 3 — OOP, polymorphism, stacks, queues and deadlock

Answer the object-oriented principles question and the polymorphism question with a C# example using an abstract class, an interface and a virtual method override.
Implement a stack and a queue in C#, then give one use for each, such as call frames, undo, breadth-first search and a work queue.
Write a two-lock deadlock in C#, then fix it with a consistent lock order and show the Monitor.TryEnter variant.

Deliverable: Runnable C# files for the polymorphism example, stack and queue, and the deadlock reproduction with its fix.

Day 4 — Coding by hand: lists, recursion, search and sorting

Write iterative and recursive linked-list reversal in C# and test empty, single and two-node lists.
Write a recursion example with a base case, then rewrite it iteratively and note the stack-depth risk.
Implement binary search, including a variant that returns the first matching index, and test duplicates and missing values.
Build a table of sorting algorithms with best, average and worst time, extra space and stability, and say which you would pick for nearly sorted data.

Deliverable: C# solutions with a small set of edge-case tests, plus a sorting comparison table.

Day 5 — Case questions: data volume, anomalies and performance

Outline an answer for managing large datasets efficiently: clarify size and access pattern, then storage, partitioning, indexing and batch or streaming choices.
Outline how you would identify anomalies or errors in a dataset: validation rules, summary statistics, duplicates and missing values, and how you would handle a flagged record.
Write a numbered troubleshooting sequence for a slow application, and a list of measures you would use to say a software implementation succeeded.

Deliverable: Four one-page spoken outlines for the case questions, and notes from the two practice drills.

Day 6 — Behavioral story bank

Pick three or four projects and write each as situation, your decision, alternatives rejected and result.
Assign stories to the prompts on a hard challenge, prioritisation, teamwork, motivation and feedback, so that no single project carries all of them.
Rehearse each aloud, using "I" for your actions, and cut any story that has no verifiable result.

Deliverable: A story bank table with a story, a result and a follow-up answer for each of the five reported behavioral prompts.

Day 7 — Mixed mock and format-specific refresh

Run a mock session: write binary search in C# while talking, answer a large-dataset design question aloud, then tell the hard-challenge story.
If the recruiter confirmed a project-based task, build a small tested C# project with unit tests and a CI step; if React is in scope, review components, props, state and hooks.
List the three answers that went worst and rewrite each one.

Deliverable: A recorded mock run, a small tested project or React refresher notes if relevant, and a rewritten list of weakest answers.

Behavioral prompts for the Cerberus loop

Candidates report five behavioral prompts: a hard project challenge, prioritising across projects, teamwork, motivation and handling feedback. For a role that involves code review, troubleshooting existing systems and working with traders, analysts and product managers, choose stories where you made a decision, worked with those kinds of people or fixed something that was already running.

Tell me about a time a code review comment changed how you wrote or structured your code.

Describe a time when you faced a significant challenge in a project. How did you handle it?

Medium · Behavioral / Leadership

Approach

Choose a challenge where you owned a decision, ideally in a project that involved troubleshooting or reworking an existing system, since that matches the work candidates describe.
Give the situation in two sentences, then the specific constraint that made it hard: a deadline, an unclear requirement, a failing component or a conflict between stakeholders.
Spend most of the answer on options you weighed, why you chose one, and what you did step by step. Say "I" for your own actions and name teammates for theirs.
Close with a result you can verify, such as an error rate, a delivery that landed or a process that changed, and one thing you would do differently.

Follow-up

What alternatives did you reject, and what would have made you pick one of them?
How did you know the fix worked rather than the problem moving elsewhere?
What would you do differently if you faced it again?

How do you prioritize tasks when working on multiple projects?

Medium · Behavioral / Leadership

Approach

Open with the criteria you apply, for example impact, deadline, whether others are blocked by it, cost of delay and effort, so the answer is a method before it is a story.
Then give one real case with two or three competing items and say how each was ranked, including what you deferred or declined and who you told.
Show how you communicate with the people involved. The role description mentions product managers, analysts and traders, so a story with stakeholders who want different things fits.
Explain how you re-prioritise when something urgent arrives, such as a production issue in the middle of planned work.

Follow-up

Two stakeholders each say their request is the most urgent. How do you decide?
What did you say no to, and how did that person react?
How do you handle a production bug that lands mid-sprint?

Can you provide an example of how you have worked collaboratively within a team?

Medium · Behavioral / Leadership

Approach

Pick a story where you had a clear piece of work in a shared effort, and say what it was. A story where the whole team succeeded without your part visible does not answer the question.
Include some friction: a design disagreement, a handoff, a code review thread or a dependency on another team. Explain what you did to resolve it, such as agreeing an interface, pairing or writing down the decision.
Mention the practices that made it collaborative, such as code review, shared test coverage or working with a non-engineer who owned the requirement.
State the outcome for the team and what you carried forward into later projects.

Follow-up

Tell me about a disagreement in that team and how it ended.
What did you do when a teammate was blocked or behind?
How did you work with someone who was not an engineer?

What motivates you to perform at your best?

Medium · Behavioral / Leadership

Approach

Answer with evidence, not a slogan: describe one or two moments in past work where you were at your best and name what they had in common, for instance untangling a hard bug, owning reliability or seeing users depend on your system.
Connect the pattern to the role as candidates describe it: maintaining and improving software that supports investment operations, with stakeholders who use it directly. Do not claim to know the firm's values.
Be honest about what drains you too, so the answer reads as self-knowledge rather than a pitch.
Avoid answers built only on pay or title, and avoid generic phrases such as "challenge and growth" with no example behind them.

Follow-up

Describe a period when you were not motivated. What did you change?
What kind of work drains you, and how do you handle it when it is unavoidable?
What would make you leave a role like this?

How do you handle feedback and criticism?

Medium · Behavioral / Leadership

Approach

Choose a specific piece of critical feedback, such as a hard code review comment or a review of how you communicate, rather than a mild one or a disguised strength like "I work too hard".
Show the sequence: you listened, asked a clarifying question to be sure you understood, decided what to change, changed it, and later checked that it had worked.
Give a concrete behaviour that is different afterwards, for example smaller pull requests, tests before review or earlier updates to stakeholders.
Also say how you give feedback, since code review is part of the role as candidates describe it.

Follow-up

Tell me about feedback you disagreed with. What did you do?
How do you give critical feedback in a code review?
What is the most recent change you made because of feedback?