Want to ace Akuna’s Online Assessment but not sure what they’ll throw at you? You’re in good company. As an options market maker, Akuna optimizes for speed, correctness, and clarity. That shows up in their OA: time-pressured coding, streaming data scenarios, order book logic, and performance-aware solutions.

If you want to walk into the Akuna OA confident and ready, this guide gives you the no-fluff breakdown — what to expect, how to prep, and how to execute.

When to Expect the OA for Your Role

Akuna’s OAs vary by role and track, but patterns are consistent across teams.

• New Grad & Intern (Software/Quant Dev)
• Expect an OA invite soon after recruiter outreach. For many intern/new grad roles, the OA is the main technical screen before virtual onsite.
• Trading Systems / C++ Engineer
• Standard OA with a tilt toward performance: priority queues, parsing, arrays/strings, bit manipulation, and careful complexity. C++ and Python are common choices.
• Data / Quant Platform Engineering
• OA includes data processing, streaming stats, log parsing, joins/group-bys, and careful memory usage. Python is common; Java/C++ also appear.
• Quant Trader / Research Roles
• Often a separate math/probability assessment and mental math. Coding OA may be shorter or follow the math screen.
• Senior Engineering Roles
• Some candidates skip a generic OA and go straight to interviews, but many still receive a timed OA to standardize the funnel.

Action step: When the recruiter reaches out, ask directly: Which platform (HackerRank, CodeSignal, or Codility)? How many questions? Duration? Any language constraints (e.g., C++/Python preferred)? Any focus areas (parsing, streaming, heap)?

Does Your Online Assessment Matter?

Short answer: absolutely.

• It’s the primary filter. High applicant volume means the OA is how you earn the interview loop.
• Your code sets the tone. Interviewers may review your OA solutions and ask you to walk through choices.
• Performance matters. Akuna cares about efficient data structures, avoidance of unnecessary allocations, and correctness under scale.
• Domain-flavored tasks. You may see order-book-like logic, time-series windows, or stream statistics — reflecting trading infrastructure realities.

Pro Tip: Treat the OA like a live interview. Write readable code, handle edge cases, watch complexity, and include brief comments to explain intent.

Compiled List of Akuna OA Question Types

Candidates report seeing the following categories. Practice these patterns:

1. Order Book Matching / Backlog Processing — type: Heap / Simulation
2. Median of Data Stream — type: Two Heaps / Streaming
3. Sliding Window Maximum — type: Deque / Monotonic Queue
4. Design Hit Counter / Rate Limiter — type: Queue / Hash Map
5. Log File Parsing & Reordering — type: String Parsing / Sorting
6. Kth Largest Element in a Stream — type: Heap
7. Subarray Sum Equals K — type: Prefix Sum / Hash Map
8. Top K Frequent Elements — type: Heap / Bucket Sort
9. XOR Subarray Queries — type: Bit Manipulation / Prefix XOR
10. Network Delay Time — type: Graph / Dijkstra
11. Meeting Rooms II — type: Intervals / Heap
12. Valid Parentheses / Bracket Matching — type: Stack
13. Merge K Sorted Lists — type: Heap / Divide & Conquer
14. Max Average or Max Sum Subarray Fixed Window — type: Sliding Window

How to Prepare and Pass the Akuna Online Assessment

Think of prep as building reflexes you’ll need in a low-latency environment: stream processing, heaps, deques, prefix sums, and clean parsing.

1. Assess Your Starting Point (Week 1)

• Take 2–3 timed practice OAs on HackerRank or CodeSignal.
• Identify weak zones: parsing, heaps, monotonic queues, prefix sums, or bit manipulation.
• Benchmark languages: If choosing C++, verify you’re comfortable with STL (priority_queue, unordered_map, deque). If Python, practice heapq, collections.deque, and fast I/O patterns.

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

• Self-study (LeetCode/HackerRank playlists)
• Focus on heaps, streaming, sliding windows, simulation, and parsing.
• Timed mock assessments
• Simulate 90–120 minutes with 2–3 problems and strict pacing.
• Mentor/code review
• A reviewer can spot complexity pitfalls, messy edge handling, and I/O inefficiencies early.

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

• Build a 40–60 problem set weighted toward:
• Heaps (order book, top-K, kth-largest)
• Deques (sliding window max/min)
• Prefix sums/XOR (subarray targets)
• Parsing/sorting (logs, FIX-like key=val strings)
• Simulation (event processing, matching)
• Always refactor for clarity after solving. Replace ad-hoc logic with small helpers and clear variable names.

4. Learn Akuna-Specific Patterns

• Order book matching and price-time priority
• Use two heaps (buy=max-heap, sell=min-heap). Watch integer overflow and tie-breaking.
• Streaming stats and rolling windows
• Medians with two heaps; window max/min with deque; VWAP/PnL windows with prefix sums.
• Log and market data parsing
• Parse timestamped events and handle out-of-order or duplicate messages. Beware whitespace and malformed lines.
• Precision and numeric safety
• Prefer integer cents or Decimal for money; avoid float drift.
• Throughput and latency
• Minimize allocations in hot loops; consider fast I/O; avoid O(n^2) with large inputs.

Note: For trader/quant tracks, brush up on probability, combinatorics, and mental math. For SWE, domain knowledge helps but isn’t required to pass.

5. Simulate the OA Environment

• Timebox: Most OAs are 90–120 minutes for 2–3 questions.
• Tools: Practice in the platform’s editor (HackerRank/CodeSignal) with custom tests.
• Pacing: Allocate ~25–40 minutes per medium problem; leave 10–15 minutes for tests and edge cases.
• Performance hygiene:
• C++: ios::sync_with_stdio(false); cin.tie(nullptr);
• Python: sys.stdin.readline for input-heavy tasks; avoid per-line regex if not needed.

6. Get Feedback and Iterate

• Post solutions for review or revisit after 24 hours.
• Track recurring misses: off-by-one in windows, forgetting to handle empty inputs, or mixing < vs <= in heap comparisons.
• Maintain personal snippets: heap patterns, deque window template, prefix sum skeleton, robust parser.

Akuna Interview Question Breakdown

Here are sample problems styled after what Akuna cares about: streaming data, matching engines, rolling stats, and efficient parsing.

1. Order Book Matching with Price-Time Priority

• Type: Heap / Simulation
• Prompt: You receive a stream of buy/sell orders (price, quantity, side, timestamp). Match orders using price-time priority and return remaining backlog size and/or executed trades.
• Trick: Maintain two heaps: buys as max-heap by price then time; sells as min-heap. While top buy >= top sell, match quantities. Watch integer overflows and stable ordering.
• What It Tests: Heap fluency, simulation correctness, tie-breaking, and handling large inputs efficiently.

2. Streaming Median of Trade Sizes

• Type: Two Heaps / Streaming
• Prompt: Given a stream of trade sizes, support add() and median() queries. Variants may ask for percentile or weighted median.
• Trick: Keep a max-heap for the lower half and a min-heap for the upper half; rebalance to keep size difference ≤ 1. Return either top of one heap or average of both.
• What It Tests: Streaming data structures, balancing invariants, and amortized complexity.

3. Sliding Window Max Volume Over Time

• Type: Deque / Monotonic Queue
• Prompt: Given timestamped volumes, compute the maximum total volume within any window of width W (or max per fixed-size K items).
• Trick: Use a deque to maintain candidates in decreasing order; pop from front when out of window and from back when smaller than new element. For time-based windows, track timestamps and accumulate rolling sums.
• What It Tests: Sliding window mastery, deque operations, and careful boundary conditions.

4. FIX-Style Log Parsing and Aggregation

• Type: String Parsing / Hash Map / Sorting
• Prompt: Parse lines of messages like “35=D|11=ABC|38=100|44=12.34|…” and output aggregated stats (per symbol counts, notional, rejects, etc.).
• Trick: Split efficiently, handle missing/duplicate tags, numeric conversion safety (use Decimal/int cents), and stable output ordering.
• What It Tests: Robust parsing, edge case resilience, and practical data munging under time pressure.

5. Token-Bucket Rate Limiter per Key

• Type: Queue / Math / Hash Map
• Prompt: Implement allowRequest(user, timestamp) with capacity C and refill rate R. Decide whether to allow or drop based on token availability.
• Trick: Track lastRefillTime and tokens per user. Refill lazily on each call using delta time, clamp at capacity, then consume if tokens available.
• What It Tests: State management, correctness over time, and precision in discrete-time simulations.

What Comes After the Online Assessment

Passing the OA moves you from “can you code efficiently?” to “can you build reliable systems under realistic constraints?” Here’s what typically comes next.

1. Recruiter Debrief & Scheduling

You’ll hear back within a few business days. Expect high-level feedback and an outline of upcoming rounds. Ask about interview formats (live coding, design, behavioral) and focus areas (low-latency, data pipelines, C++ specifics).

2. Live Technical Interviews

• Interactive coding on a shared editor. Similar topics as OA but with more dialogue.
• Expect tasks like “extend your order book to support cancels” or “debug a broken sliding window.”
• Communicate clearly: explain invariants, complexity, and test your code out loud.

Pro tip: Review your OA solutions; interviewers may ask you to walk through them or add features.

3. Systems & Architecture Round

• For backend/infra roles: design a simplified market data normalizer, real-time risk checks, or a publish/subscribe pipeline.
• Evaluate trade-offs: latency vs. throughput, memory vs. GC/allocs, failure modes, and observability.
• Show pragmatic decisions (e.g., batching, backpressure, idempotency, exactly-once semantics vs. at-least-once).

4. Behavioral & Collaboration Interviews

• Examples: “Tell me about a time you shipped under tight deadlines.” “How did you handle a high-severity incident?”
• Highlight: crisp communication, ownership, bias toward action, and working well with traders/teammates in fast cycles.
• Use the STAR method and quantify impact where possible.

5. Final Round / Virtual Onsite

• Multiple back-to-back sessions (coding, design, team fit). You may meet engineers from different teams (risk, data, trading systems).
• Expect context switching — prepare to reset quickly between problems.

6. Offer & Compensation Discussion

• Comp typically includes base salary and an annual performance bonus; some roles include sign-on and relocation. Equity is less common than in big tech; bonuses can be significant.
• Come prepared with market data and priorities (comp, learning, location/team).

Conclusion

You don’t need to guess what Akuna will test — you need to prepare for the patterns they care about:

• Heaps, deques, prefix sums/XOR, and robust parsing
• Streaming stats and windowed computations
• Simulation with price-time priority and careful tie-breaking
• Performance-aware, readable code that passes edge cases

Treat the OA like your first interview. Time yourself, write clean and efficient solutions, and verify with custom tests. Do that, and you’ll turn Akuna’s OA from a hurdle into your strongest signal.

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.