FIRM INTERVIEW GUIDE

DRW Interview Guide

Explore DRW interviews for quantitative trading analysts, quantitative researchers and software developers. Trading finals include a Python challenge and trading simulation.

DRW Interview Overview

The short answer

For internships and graduate positions, DRW uses a resume application, a timed technical challenge at home, a virtual technical interview and a final round. Quantitative trading, research and software applicants face different technical tasks, so choose the path for your position below.

The challenge tests probability and logic for quantitative roles and coding for developers. DRW's campus interview process includes a phone or Zoom discussion and an in person final that starts with introductions and a challenge, followed by further interviews. The exact technical work depends on the role.

Choose your role

DRW Quantitative Trading Analyst Interview Process

A DRW Quantitative Trading Analyst applies probability, statistics and Python to market decisions. The recruiting route includes an at home quantitative challenge, a roughly 45 minute probability and statistics interview, and a final with a Python challenge and trading simulation.

  1. Stage 1: Application & Resume

    Apply with a concise technical resume that demonstrates probability, Python, research projects or decisions made under uncertainty.

  2. Stage 2: Quantitative Challenge

    Complete a timed at home assessment of logical and quantitative problem solving, using your invitation for the actual duration.

  3. Stage 3: Quant Interview

    Explain probability and statistics problems aloud in an approximately 45 minute Zoom interview with a trader.

  4. Stage 4: Trading Superday

    Work through a Python challenge, a trading simulation and further technical conversations at the in person final.

Stage 1: Application & Resume

DRW reviews campus applications on a rolling basis and asks for a recent resume. Lead with quantitative evidence: a model you implemented, a real decision you improved or an analytical project with a result you can explain. The Quantitative Trading Analyst role connects research, coding and trading, so show both technical depth and sound judgement under risk.

Know the products relevant to the opening and be ready to discuss one market development in terms of value, volatility and trading risk. Finance vocabulary alone is not a substitute for solving quantitative problems.

Stage 2: Quantitative Challenge

The DRW quantitative online assessment is a timed challenge completed at home. It tests logical and quantitative reasoning. Its instructions give the test length, so use the duration in your invitation rather than a fixed practice timer.

Prepare conditional probability, counting, distributions, expected value and multi step deduction. For example, after observing that a customer buys more often when a security is valuable, update the state probabilities with Bayes' rule before computing a quote. For research oriented quantitative questions, be comfortable interpreting a model assumption rather than only performing fast arithmetic.

For EverythingQuant practice, solve six varied quantitative questions in 45 minutes and review incorrect solutions afterwards. This drill is independent of the DRW test duration.

Practise DRW quantitative interview questions A DRW focused bank of probability, expected value, statistics and logic problems, with free previews and premium questions.

Stage 3: Quant Interview

The next DRW trading interview is ordinarily a Zoom conversation of about 45 minutes testing probability and statistics. Expect to explain a solution as you go. State the sample space and assumptions, calculate the result and check whether it makes sense before moving to the next question.

Practise a sequence of follow ups: how does a posterior probability change with a different likelihood, when is a trade profitable after costs, and how should an estimate change with new order flow? Be prepared to explain a technical project from your resume and discuss why a market event changes the risk of a position.

Use the informed order flow problem below to rehearse a conditional fair value and a quote with positive expected profit.

Stage 4: Trading Superday

DRW's Quantitative Trading Analyst final includes an in person Superday with a quantitative Python coding challenge, a trading simulation and multiple technical interviews. The wider campus final format begins with introductions and a technical challenge, followed by a full day of interviews and opportunities to meet the team.

For Python, practise a short simulation that samples outcomes, checks the empirical expected payoff and presents a result clearly. For trading practice, estimate a fair value before quoting, distinguish the quote from expected value, and update exposure when an incoming order changes your beliefs. Treat these as rehearsal tasks rather than the rules of a confirmed DRW simulation.

Read a current market event and explain the mechanism linking the news to a product's price and risk. A good trading answer states the tradeoff between expected profit, execution costs, adverse selection and inventory, not simply the direction of a forecast.

DRW Quantitative Research Interview Process

DRW quantitative researchers analyse market data, build statistical models and test trading ideas through simulation and validation. The graduate recruiting pathway includes an at home quantitative challenge, a conversation with a researcher and a final round; the research discussion concentrates on statistical reasoning and explaining technical work.

  1. Stage 1: Application & Research

    Show a statistically sound Python project, a credible baseline and a clear explanation of how you validated the result.

  2. Stage 2: Quantitative Challenge

    Take the timed at home quantitative assessment, prioritising mathematical reasoning and clear work under the time limit.

  3. Stage 3: Research Interview

    Defend your research methods, statistical assumptions and coding choices in a technical conversation with a researcher.

  4. Stage 4: Final Interviews

    Discuss research and prior projects in depth across campus final interviews and explain where a proposed signal can fail.

Stage 1: Application & Research

Apply with evidence that you can create and test a model rather than only use a library. DRW research internships involve statistical analysis of markets, machine learning, derivatives pricing and custom simulation or backtesting tools. Python proficiency, including NumPy, pandas and scientific modelling, is useful for this work.

Prepare one substantial project: the question, data timestamps, simple baseline, modelling method, untouched validation period and a specific finding. Include an unpromising experiment and what it taught you about false patterns or hidden biases.

Stage 2: Quantitative Challenge

Research applicants take an at home, timed quantitative technical challenge testing logical and mathematical reasoning. Practise conditioning and distributions, expected value, estimation and multi step reasoning, then check how the result changes if the model assumptions change. The timing comes with the assessment invitation rather than a single public duration for all research applicants.

As additional research preparation, derive an expectation from first principles, interpret uncertainty and connect a probability result to a numerical model. These are useful research skills, not a claimed list of guaranteed assessment questions.

Build quantitative research probability skills Conditional probability, distributions, dependence and simulation practice, with free and premium course material.

Stage 3: Research Interview

DRW's campus virtual interview pairs applicants with a trader, developer or researcher for technical and behavioural questions. For quantitative research, prepare a complete explanation of the project on your resume, including how you assembled the dataset, selected a model and decided whether its result was credible.

Be ready to discuss hypothesis testing, estimates, distributions, stochastic models and numerical methods. Explain why a chronological train and test split matters for market data; how transaction costs, regime changes and correlated observations change a result; and how you would reproduce an experiment with the same inputs.

Work through the two state regime example and explain why a positive gross expected return may still be a losing trade after execution costs.

Stage 4: Final Interviews

The DRW campus final begins with an afternoon technical challenge and continues with further technical and behavioural interviews on the following day. Research candidates should be ready to discuss their research and publications in depth.

Defend why a signal is not an artefact of data selection, leakage or a shifting market regime. Compare the original result with a simple baseline, a later unseen period and realistic turnover and trading costs. If a model fails, explain how you would diagnose whether the problem is data, inference, execution or the underlying hypothesis.

Research interviews reward clarity about what your experiments established and what would change your conclusion. Build one reproducible Python demonstration and be able to explain it without reading a prepared slide.

DRW Software Developer Interview Process

Software developers at DRW build market data, risk and trading systems. The new graduate developer pathway starts with an online coding assessment, followed by an approximately 45 minute technical Zoom interview and an onsite final with another coding challenge and more advanced technical interviews.

  1. Stage 1: Application & Projects

    Apply with evidence of correct, tested code and a design or performance decision that you can explain precisely.

  2. Stage 2: Coding Assessment

    Solve timed coding tasks that test correct output, algorithmic efficiency and handling of unexpected inputs.

  3. Stage 3: Technical Interview

    Discuss algorithms and fundamental computer science, keeping a computer ready for implementation questions.

  4. Stage 4: Onsite Coding & Systems

    Complete another coding exercise and deeper technical interviews covering design, correctness and system behaviour.

Stage 1: Application & Projects

DRW looks for software developers who can write and maintain reliable systems. Current internship descriptions include C++, Python or Java, object oriented design, data structures, algorithms, networking and multithreaded applications. The specific language and systems focus depend on the engineering vacancy.

Market data teams work on packet decoders, quote normalisation and instrument order books, while other software teams work on risk applications and tools for trading operations. Put a genuine implementation on your resume and be ready to describe its test coverage, a difficult bug and how you measured performance.

Stage 2: Coding Assessment

The software developer online assessment is a timed coding challenge. DRW provides a Codility sample through its technical challenge guidance to show the style: problems may ask you to build functions for a scenario or solve a game style task, and solutions are evaluated for correctness and performance.

Practise arrays, hash maps, sorting, heaps, graph or tree traversal and basic dynamic programming. Test empty inputs, duplicates, maximum sizes and performance as inputs grow. A useful EverythingQuant drill is two medium problems in 60 minutes with explicit complexity reasoning; the official challenge length is supplied in the invitation email.

Practise programming interview questions Algorithms, heaps, arrays and data structures, with free questions and an expanded premium bank.

Stage 3: Technical Interview

DRW's new graduate developer interview is typically a 45 minute Zoom conversation assessing technical skills. Have a computer ready for possible coding questions. Talk through a straightforward implementation first, establish its complexity and then test edge cases and failure paths before optimising.

Prepare data structure operations, memory lifetime, C++ containers, TCP/IP basics, threading and synchronization where they fit your job description. For a market data example, explain how you would handle an empty book, a duplicate update or a missing packet without silently showing stale top of book prices.

The order book coding exercise below covers a practical event stream data structure with a working Python solution. Explain how the same design would change for low latency C++.

Stage 4: Onsite Coding & Systems

The developer final includes an additional coding challenge and in depth technical interviews with future teammates. DRW's wider campus onsite format begins with a challenge in the afternoon followed by a fuller day of technical and behavioural discussions.

For engineering preparation, consider how an exchange feed decoder deals with corrupt packets, how a normaliser updates its order book, and how replay or sequence numbers help recover dropped updates. Be able to compare memory allocation, lock contention and latency against correctness and maintainability, using specific measurements from a real project where possible.

For experienced engineering applicants, expect the relevant team's production constraints to matter more than a generic student coding checklist. Select a debugging, reliability or concurrency example that demonstrates a decision you owned.

DRW Interview Questions: Worked Practice

These three original EverythingQuant questions are realistic training exercises for trading, research and software work. They are not attributed to a DRW interview. Open a solution to check the full derivation or code after attempting the problem.

Worked trading question: quote after an informed order

This original EverythingQuant exercise combines conditional probability, market making and expected profit. It is practice material, not a question attributed to DRW.

The question

A contract pays 120 in the high state and 80 in the low state, with each state initially equally likely. In the high state, an incoming customer buys with probability 0.8; in the low state, a customer buys with probability 0.3.

You must post one bid and one ask before observing whether the customer buys or sells. What are the conditional fair values after each order direction, and what is the expected profit per arriving customer if you quote bid 87 and ask 111, ignoring fees and inventory risk?

Show the complete solution

The probability of a customer buy is 0.5(0.8) + 0.5(0.3) = 0.55. After seeing a buy, Bayes' rule gives the high state probability 0.4 / 0.55 = 8/11.

The conditional value after a buy is 120(8/11) + 80(3/11) = 1200/11 = 109.09. A customer buy executes against your ask of 111, giving conditional expected profit 111 - 1200/11 = 21/11 = 1.91.

A customer sells with probability 0.45. The high state probability after a sell is 0.1/0.45 = 2/9, so conditional value is 120(2/9) + 80(7/9) = 800/9 = 88.89.

A customer sell executes against your bid of 87, so the conditional expected profit is 800/9 - 87 = 17/9 = 1.89. Averaging the two order directions gives 0.55(21/11) + 0.45(17/9) = 1.90 per incoming order.

Both quoted prices are profitable on this model, before fees, inventory risk and errors in the assumed customer behaviour. The important insight is that an order carries information about value.

Interview extension

If each trade costs 2.1 units, the expected profit after that cost becomes negative 0.2 units per order. Explain why a seemingly wide bid and ask is not enough when order flow is informed.

Worked research question: when is a regime signal tradable?

This original EverythingQuant exercise uses a two state Markov model to turn a statistical forecast into an actual trading decision. The final step tests whether a promising gross result survives costs.

The question

A market is in either a calm state or a volatile state. When calm, the next period is volatile with probability 0.2; when volatile, the next period remains volatile with probability 0.7.

The market is calm now. A strategy expected to run two periods from now earns 2 ticks in the volatile state and loses 0.5 ticks in the calm state, before a cost of 0.35 ticks per trade.

Find the probability of volatility two periods from now, the expected profit after costs and the minimum volatile state probability that makes the trade worthwhile.

Show the complete solution

From a calm starting point, the next period is calm with probability 0.8 and volatile with probability 0.2. The market can be volatile after two periods through either path, so P(volatile at t+2) = 0.8(0.2) + 0.2(0.7) = 0.30.

The gross expected payoff is 0.30(2) + 0.70(-0.5) = 0.25 ticks. After execution cost, expected profit is 0.25 - 0.35 = -0.10 ticks, so reject the trade at the current estimated probability.

For a general volatile probability p, the expected net profit is 2p + (-0.5)(1-p) - 0.35 = 2.5p - 0.85. Break even occurs at p = 0.85/2.5 = 0.34, so the model must estimate a volatile probability greater than 34% for positive expected profit.

The research conclusion is stronger than merely finding a regime model. State the assumption that transition probabilities are stable, then test whether the estimated edge remains positive on data outside the fitting period.

Interview extension

Recalculate the decision if transaction costs rise to 0.6 ticks. Then explain how you would estimate the transition matrix without allowing future observations into the training window.

Worked software question: maintain the top of an order book

This original EverythingQuant coding exercise matches the kind of data structure work relevant to trading infrastructure. DRW software developers work with exchange data decoding and book normalization, so the task is useful even if your assessment uses a more general algorithm prompt.

The question

You receive updates of the form (side, price, quantity), where side is "B" or "S", and all prices are positive integer ticks. A positive quantity sets the size at that level; zero removes that level.

After each update, return the highest active bid, the lowest active ask and their spread. Use None when a side is empty and design for many updates without scanning the entire book each time.

Show a complete Python solution

Keep the current level quantities in dictionaries and the candidate prices in two heaps. Remove obsolete heap entries only when they reach the top; each inserted heap entry is pushed and popped at most once.

from heapq import heappush, heappop


def top_quotes(events):
    bids, asks = {}, {}
    bid_heap, ask_heap = [], []
    results = []

    for side, price, quantity in events:
        if side not in ("B", "S") or price <= 0 or quantity < 0:
            raise ValueError("Invalid book update")

        book = bids if side == "B" else asks
        heap = bid_heap if side == "B" else ask_heap
        key = -price if side == "B" else price

        if quantity == 0:
            book.pop(price, None)
        else:
            book[price] = quantity
            heappush(heap, key)

        while bid_heap and -bid_heap[0] not in bids:
            heappop(bid_heap)
        while ask_heap and ask_heap[0] not in asks:
            heappop(ask_heap)

        bid = -bid_heap[0] if bid_heap else None
        ask = ask_heap[0] if ask_heap else None
        spread = ask - bid if bid is not None and ask is not None else None
        results.append((bid, ask, spread))

    return results


updates = [
    ("B", 100, 4), ("S", 105, 6), ("B", 102, 2),
    ("S", 104, 1), ("B", 102, 0), ("S", 104, 0)
]
assert top_quotes(updates) == [
    (100, None, None), (100, 105, 5), (102, 105, 3),
    (102, 104, 2), (100, 104, 4), (100, 105, 5)
]

With n updates, each update does at most one heap insertion and all lazy removals together cannot exceed the number of insertions. Total time is O(n log n) and space is O(n), rather than scanning every live price level after each event.

For a deeper discussion, explain how you would handle duplicate network messages, crossed quotes and recovery after a lost market data packet. Those production concerns matter as much as the headline algorithmic complexity.

What a strong implementation shows

Test cancellation, replacing a quantity and a completely empty side. Explain what changes if updates arrive out of order or the feed needs sequence numbers to recover missing messages.

How to Prepare for DRW Interviews

Build a short mock around the work your DRW position actually tests. Use these benchmarks to check readiness, not as claims about DRW's assessment thresholds.

  • Trading: finish six different probability problems under a 45 minute practice timer, then price an informed order and explain the impact of a fee and inventory risk.
  • Research: derive a probability or model result, implement a reproducible Python experiment and show how an unseen test period or transaction costs could reverse the decision.
  • Software: solve two varied coding problems under a 60 minute practice timer, check boundary inputs and discuss one memory, networking or concurrency failure case.

Complete one mock discussion aloud and revisit the two mistakes that cost the most clarity or correctness. A personalised preparation roadmap can help prioritise the remaining gaps.

DRW Interview FAQs

What is the DRW online assessment?

For campus quantitative trading and research roles, it is a timed at home test of logical and quantitative skills. Software applicants complete a coding based challenge. DRW supplies the actual time limit in the assessment invitation.

Does DRW use Codility?

DRW links software developer candidates to a Codility sample assessment. The software challenge tests correctness and efficiency, so use the sample to understand task style and test your solutions against edge cases.

How long is a DRW technical interview?

DRW describes roughly 45 minute virtual interviews for quantitative trading analysts and new graduate developers. Its broader campus interviews include technical and behavioural questions with a developer, researcher or trader.

What happens in the DRW final round?

Campus finals can include an introductory afternoon challenge followed by a full day of technical interviews. Trading analysts complete a Python task and trading simulation, developers complete another coding challenge, and researchers should be ready for detailed discussion of their work.

Do DRW quantitative research applicants need Python?

Python and statistical modelling are central to DRW quantitative research. Practise examining data, checking assumptions, implementing a model and explaining what its validation results mean.

How should experienced DRW applicants prepare?

Use the actual team description and prepare measurable decisions you owned: live risk, production reliability, trading performance or research validity. Explain the constraints, alternatives and outcome.

Is finance knowledge enough for DRW trading roles?

No. Quantitative trading roles also require probability, quantitative reasoning, programming and sound decisions under uncertainty. Understand your market, then practise the technical work the role uses.

DRW Sources

Use DRW's own graduate and internship hiring pages for the general sequence, then its role specific articles for trading, research and software details.

UNLOCK PREMIUM PREPARATION

Prepare for DRW with Premium.

Unlock more interview questions, worked solutions and assessment practice.

Unlock Premium

© 2026 EverythingQuant. All Rights Reserved.