>

Akuna Capital

INTERVIEW GUIDE

Akuna Capital Software Engineer Interview Guide 2026

Complete Akuna Capital Software Engineer interview guide. Prepare for the online assessment, C++ and Python developer tracks, low-latency systems questions, and the collaborative culture of a Chicago options market maker.

5 min read

Updated Sep 2026

31+ practice questions

31+

Practice Questions

5

Rounds

6

Categories

5 min

Read
TL;DR

Akuna Capital, a Chicago-based options market maker, interviews software engineers by language track, C++ developers face deep systems and performance questions, Python developers face data tooling and infrastructure problems, and both face genuine algorithmic coding. The typical path is a recruiter screen, an online assessment mixing coding with language-specific and sometimes probability questions, one or two technical video interviews, then a final round of three to five interviews with developers and team leads. Low-latency thinking, cache behavior, memory layout, lock-free patterns for the C++ track, distinguishes strong candidates, while trading knowledge is taught, not required. The culture is younger and more collaborative than old-guard trading firms. Expect 3 to 6 weeks and strong Chicago compensation.

INTERVIEW ROUNDS
Recruiter Screen
Online Assessment
Technical Video Interview(s)
Final Round Technical
Team Lead & Fit Conversations
KEY TOPICS
C++ or Python depth by track
Coding & Algorithms
Low-latency and systems performance
Concurrency
System Design
Behavioral fit
ESTIMATED TIMELINE

3-6 weeks

PRACTICE BANK

31+ questions


Sample Questions

31+ in practice bank

CODING & ALGORITHMS
Two threads increment adjacent counters and scale badly. Why?
Hard

False sharing on a shared cache line, diagnosed and fixed with padding or per-thread accumulation, the signature Akuna C++ performance question.

Implement an order book supporting best bid and ask queries
Medium

Price-level book with efficient insert, cancel, and top-of-book access, discussing data structure trade-offs under realistic update distributions.

What does Python's GIL actually serialize, and when does it not matter?
Medium

Python-track depth question, threads versus processes versus asyncio, C-extension escape hatches, and choosing correctly for an IO-bound pipeline.

SYSTEM DESIGN
Design a market data feed handler
Hard

Parse a multicast feed at millions of messages per second, sequence-gap recovery, hot-path allocation avoidance, and measuring tail latency honestly.

Speed up a backtest that takes four hours
Medium

Profile first, then attack data loading, vectorization, caching, and parallelism, with honest discussion of correctness risks each optimization introduces.

STATISTICS & MATH
Expected value of rolling a die until you see a six
Easy

Geometric distribution reasoning, the level of probability that appears in developer loops, answered cleanly with the recurrence argument.


About the Interview Process

Akuna structures its developer hiring by language and team, C++ roles sit near the trading path where nanoseconds matter, Python roles build research platforms, data pipelines, and tooling, and there are also web, DevOps, and data engineering tracks. Interviews are conducted by working developers who probe claimed expertise with escalating follow-ups. The tone is friendly but technically exacting, and the final round includes team-lead conversations that double as mutual fit checks.

Recruiter Screen
30 min
informational

Track selection, C++, Python, web, or infrastructure, and background review. Be precise about your strongest language, the whole loop keys off it.

Online Assessment
90 min
coding

Language-specific questions testing real depth, C++ semantics or Python internals, plus algorithmic problems at medium difficulty and occasionally brief probability questions.

Technical Video Interview
60 min
coding

Live coding and language deep-dive with a developer, expect your resume's claims tested, projects, concurrency experience, and performance work.

Final: Technical Rounds
60 min x2-3
technical

Systems and design questions by track, design a market data handler, speed up a slow pipeline, concurrency scenarios, plus more coding with performance follow-ups.

Final: Team Lead & Fit
45 min
behavioral

Career goals, collaboration style, and interest in trading technology. Akuna's culture is flat and social, genuine enthusiasm and low ego read well.

Timeline

3 to 6 weeks, with campus cycles moving faster. Chicago onsites are common for final rounds, though virtual finals happen too.

Tips

When answering performance questions, reason in concrete costs, cache miss versus branch mispredict versus allocation, numbers-first answers land.

Think aloud through the assessment-style problems, partial structured progress beats silent stalling in the live rounds.

Connect answers to trading system shapes, market data in, decisions, orders out, it shows you grasp the domain's data flow.

Ask developers what their team optimizes for, latency, throughput, or iteration speed, it varies by desk and shows sophistication.

What the C++ track tests

Akuna's C++ interviews go beneath the language surface. Expect questions like what a cache line is and how false sharing degrades a multithreaded counter, when move semantics actually elide copies, the cost of virtual dispatch in a hot loop, and how you would build a single-producer single-consumer queue without locks. The trading path processes market data at microsecond scale, and interviewers select for engineers who think in memory layout and mechanical sympathy by default.

Design questions follow the same theme, a feed handler that parses millions of messages per second, an order gateway that must never send a duplicate, or diagnosing tail latency in a pinned-thread process. General distributed-systems answers miss the point here, the interesting problems are single-machine, kernel-bypass adjacent, and measured in nanoseconds.

The Python track and the broader loop

Python developers at Akuna build the research and data backbone, backtesting platforms, market data pipelines, and internal tools quants depend on. Interviews test Python at internals depth, iterator protocol, the GIL's real implications, memory behavior of dataframes, plus practical design like a pipeline that reprocesses a day of options data quickly and correctly. The bar is production engineering, not scripting.

Across tracks, Akuna teaches trading knowledge internally and its interview reflects that, a curiosity check rather than a finance exam. The firm is younger-skewing and known for a social, flat culture unusual among market makers, and final-round fit conversations genuinely matter, they are assessing whether you will thrive on a desk where developers, quants, and traders sit together.


Leveling & Compensation
LevelTitleYoETotal Comp (USD/yr)
Dev
Software Developer0-3 yrs$175k - $350k
Sr Dev
Senior Software Developer3-7 yrs$250k - $500k
Lead
Team Lead / Principal Developer7+ yrs$350k - $750k
Dev
Software Developer

Ships performant, correct code within a team, absorbs trading domain knowledge quickly, and grows toward hot-path ownership.

Sr Dev
Senior Software Developer

Owns critical systems, market data, execution, or research platforms, makes latency-versus-complexity calls, and mentors within the team.

Lead
Team Lead / Principal Developer

Sets technical direction for a desk's systems, accountable for reliability where failures cost real money, and shapes hiring and standards.


How to Stand Out
Behavioral Focus Areas

Collaboration: Akuna emphasizes a flat, team-first trading floor

Curiosity about markets: interest in how market making works, taught from zero

Precision: sloppy reasoning about performance or correctness is disqualifying

Drive: fast-moving competitive domain with direct feedback

Humility: knowing the limits of your knowledge under probing

1.

Declare your track honestly, the C++ loop probes deep language mechanics, and bluffing depth fails fast under Akuna's follow-ups.

2.

For C++, study move semantics, virtual dispatch costs, cache lines, false sharing, and lock-free queue basics, these exact topics recur.

3.

For Python, know generators, the GIL, asyncio, and profiling, plus how you would make slow data pipelines fast.

4.

Practice LeetCode mediums with a performance lens, interviewers ask about constant factors and memory behavior, not just big-O.

5.

Learn market-making basics, bid-ask spread, what an options market maker does, hedging in one paragraph, enough to show genuine interest.

6.

Review probability fundamentals lightly, dev candidates get occasional expected-value questions, softer than the quant loop but present.

Recommended Resources

FAQ

No. Akuna explicitly teaches options and market making to new hires, and its interview only checks for curiosity. An hour learning the bid-ask spread, market maker economics, and what an options Greek is will cover every domain reference you meet.

Deeper than typical big-tech loops, memory model, cache behavior, atomics, and the assembly-level cost of abstractions are fair game for the trading-path track. If your C++ is framework-level, consider the Python or web tracks where the depth applies to those stacks instead.

Similar problem space, distinct cultures. Akuna is smaller, younger, Chicago-rooted, and known for a social, flat environment with meaningful responsibility early. Compensation is strong though generally below the very top of HFT, and the interview is somewhat less adversarial while remaining technically deep.

Akuna operates primarily from its Chicago headquarters with in-office expectations most days, reflecting how tightly developers work with traders and quants. Confirm the current policy with your recruiter, but plan on Chicago presence.


Comments
Markdown supported