Heard the stories about Jane Street’s online assessment — part coding, part probability, part puzzle — and wondering how to actually train for it? You’re in the right place. Jane Street’s OA is different from a typical big-tech coding screen: expect trading-flavored simulations, functional programming vibes (OCaml is their house language), and questions that reward rigor, clarity, and a cool head under time pressure.

If you want to walk in confident and prepared, this guide is your blueprint. No fluff. Real patterns. Targeted prep.

When to Expect the OA for Your Role

Jane Street tailors the OA based on role and level. Here’s how the timing and content usually shake out:

• New Grad & Intern (Software Engineering) – High probability of an OA shortly after applying or after a campus event. It’s often your first technical filter and may be the only screen before live interviews.
• Software Engineer (Backend / Systems / Tools) – Expect a coding OA link (HackerRank, Codility, or a custom portal). Questions lean toward correctness, efficiency, and clean functional-style reasoning.
• Quant Developer / Trading Tech – Coding plus math/probability-flavored prompts. Simulations (order books, queues, streaming stats) show up.
• Systems & Infrastructure – Performance-aware coding, concurrency safety, low-level data structure usage, careful handling of edges/corners.
• Senior Engineering – Some candidates skip a generic OA and go straight to live interviews, but many still receive a coding screen to baseline.
• Non-Engineering (Trading/Research) – Different pipeline. If an assessment appears, it’s more math/logic-heavy and not code-centric.

Action step: Ask your recruiter for the platform, duration, number of questions, and allowed languages. If OCaml is encouraged, they’ll often tell you. Otherwise, Python/C++/Java are typical options.

Does Your Online Assessment Matter?

Short answer: absolutely.

• It’s the primary filter. Your OA performance typically determines whether you move forward.
• It’s signal-rich. Reviewers pay attention to clarity, correctness, complexity, and how you structure your thinking.
• It mirrors the job. Jane Street cares about precision, edge cases, and clean reasoning under constraints — and the OA reflects that.
• It can follow you. Your OA code might be referenced in later rounds; it sets the tone for how you communicate and solve.

Pro tip: Treat the OA like your first interview. Name things clearly, reason about complexity, write tight tests (if available), and handle corner cases.

Compiled List of Jane Street OA Question Types

Based on common reports and the firm’s engineering focus, expect a mix of algorithmic coding, streaming/simulation, probability, and functional thinking. Practice these patterns:

1. Number of Orders in the Backlog — type: Heaps / Simulation
2. IPO — type: Greedy / Heap
3. New 21 Game — type: Probability / DP
4. Probability of Heads — type: DP / Expected Value
5. Find Median from Data Stream — type: Heaps / Data Stream
6. Sliding Window Maximum — type: Deque / Sliding Window
7. Maximum Profit in Job Scheduling — type: DP / Binary Search
8. Course Schedule — type: Graph / Topological Sort
9. Network Delay Time — type: Graph / Dijkstra
10. Subarray Sum Equals K — type: Prefix Sums / Hashing
11. Single Number II — type: Bitwise / State Compression
12. Count of Smaller Numbers After Self — type: Fenwick / Merge-Count
13. LRU Cache — type: System Design / HashMap + DLL
14. Design Hit Counter — type: Queue / Sliding Window

How to Prepare and Pass the Jane Street Online Assessment

Think of this as a focused training cycle: you’re building reflexes for correctness, probabilistic reasoning, and clean, functional-style code.

1. Assess Your Starting Point (Week 1)

List strengths (arrays, heaps, prefix sums) and gaps (DP with probabilities, event simulations, bit tricks). Do a timed set of 3–4 targeted problems to benchmark speed and accuracy. Note any consistent failure modes (off-by-one, numeric stability, overflows).

2. Pick a Structured Learning Path (Weeks 2-6)

• Self-study on LeetCode/HackerRank
• Best for autonomous learners. Build a curated list (see above), time-box sessions, and track error patterns.
• OCaml upskilling (optional but valuable)
• If you’re open to OCaml, try: Real World OCaml, OCaml.org, Exercism OCaml track. Focus on pattern matching, immutability, tail recursion, and modules.
• Mentorship / mock OAs
• A coach or peer can give feedback on clarity, test coverage, and communication under time constraints.

3. Practice With Realistic Problems (Weeks 3-8)

Prioritize:

• Heaps/priority queues (order matching, streaming medians)
• Sliding windows and prefix sums (time-window metrics)
• DP (expected value, probabilities, interval DP)
• Graphs (Dijkstra/topo sort) with careful edge handling
• Bitwise state compression (space/time efficiency)

After solving, refactor for readability. Functional thinking helps: pure functions, small helpers, and clear data flows.

4. Learn Jane Street-Specific Patterns

• Order book and matching logic — two heaps, price-time priority, partial fills, edge cases
• Expected value DP — probability transitions, floating-point stability, memoization
• Streaming analytics — moving averages, percentiles/medians, bounded memory
• Immutability-first coding — expressions over statements, recursion, avoiding shared mutable state
• Low-level correctness — overflows, integer vs float error bounds, deterministic behavior
• Scheduling/interval optimization — greedily or with DP + binary search

5. Simulate the OA Environment

• Use a practice platform (HackerRank/LeetCode playground) with a strict timer (often 60–90 minutes for 2–3 problems).
• Disable hints and autocomplete; write from scratch.
• Practice in your intended language. If OCaml is new, do a few dry runs to internalize syntax and standard library.

6. Get Feedback and Iterate

• Post solutions for review or self-review the next day with fresh eyes.
• Track a “bug log” of recurring mistakes and add targeted drills.
• Re-solve missed problems a week later without notes to test retention.

Jane Street Interview Question Breakdown

Here are featured sample problems that reflect Jane Street’s OA flavor. Master these patterns for maximum coverage.

1. Simulate an Order Book Matcher

• Type: Heaps / Simulation
• Prompt: You’re given a stream of orders (buy/sell, price, size, timestamp). Implement a matcher that updates the book and performs trades according to price-time priority. Output the total matched volume and remaining backlog.
• Trick: Use two heaps (max-heap for bids, min-heap for asks). Carefully handle partial fills, same-price aggregation, and tie-breaking by time.
• What It Tests: Data structure choice, event-driven thinking, correctness under edge cases, and attention to detail.

2. Expected PnL After Limited Trades

• Type: DP / Probability
• Prompt: Given a sequence of independent price moves with known probabilities and a cap on the number of trades, compute the maximum expected profit assuming optimal decisions at each step.
• Trick: DP over (index, remaining trades, position state). Watch floating-point precision and avoid recomputation with memoization.
• What It Tests: Expected value reasoning, state modeling, and clean DP transitions.

3. Detect Currency Arbitrage

• Type: Graph / Bellman-Ford
• Prompt: Given currency exchange rates, determine if an arbitrage opportunity exists.
• Trick: Transform rates with -log, then detect negative cycles with Bellman-Ford. Handle disconnected components and precision thresholds.
• What It Tests: Graph theory, numerical stability, and mapping a real problem to a classic algorithm.

4. Streaming Median with Time Windows

• Type: Heaps / Data Stream
• Prompt: Process a time-stamped price stream and support queries for the median in the last W seconds.
• Trick: Dual heaps with lazy deletion and a timestamped index. Balance heaps and prune expired elements efficiently.
• What It Tests: Real-time data structures, amortized analysis, and implementation discipline.

5. Bitwise Portfolio Flags Compression

• Type: Bit Manipulation
• Prompt: You have up to 32 boolean flags per symbol and millions of updates. Pack/unpack flags, support toggles, and answer “count set bits in range” queries quickly.
• Trick: Use bit masks, precompute popcount where needed, and design APIs that avoid branches on hot paths.
• What It Tests: Low-level efficiency, bit tricks, and API clarity for performance-critical paths.

What Comes After the Online Assessment

Clearing the OA is the start. Next comes deeper evaluation of how you think, code, and collaborate.

1. Recruiter Debrief & Scheduling

If you pass, you’ll hear from a recruiter with next steps and timelines. Ask about interview structure, expected languages, and any prep advice they can share.

2. Technical Screens (Live Coding)

Expect one or two rounds over video and a collaborative editor. You’ll solve algorithmic problems and often walk through reasoning out loud. If OCaml is encouraged, they may invite you to use it, but mainstream languages are usually acceptable.

3. Systems & Performance Deep Dive

Especially for backend/systems roles, you may get questions on:

• Complexity trade-offs and data locality
• Concurrency safety and determinism
• Practical performance debugging and memory considerations

4. Problem Solving with Trading Flavor

Even for SWE, you might see logic/probability puzzles or simplified market simulations. The focus is not on trick questions but on structured, rigorous reasoning and clear communication.

5. Final Round / Onsite Loop

A multi-interview sequence combining:

• Additional coding and design
• Problem-solving/puzzles
• Cross-functional discussions with engineers or trading partners

Prepare for endurance and context switching across several hours.

6. Offer & Negotiation

Compensation at trading firms often emphasizes base plus a significant annual bonus. Understand market ranges, ask about growth paths, and compare total comp structure when negotiating.

Conclusion

You don’t need to guess; you need to train with intent. If you:

• Benchmark early and target your weak areas,
• Practice Jane Street-style problems (heaps, streaming, probability DP, interval optimization),
• Write clean, testable, and precise code (functional style helps),

you’ll turn the OA into a strength — and set yourself up for the live rounds. OCaml experience is a plus, not a prerequisite. What matters most is clarity of thought, correctness under pressure, and disciplined problem solving.

For more practical insights and prep strategies, explore the Lodely Blog or start from Lodely’s homepage to find guides and career resources tailored to software engineers.