What is a Software Engineer at AKUNA CAPITAL?

At AKUNA CAPITAL, a Software Engineer is not just a developer; you are an architect of the financial markets. Akuna is a leading options market maker, which means the code you write directly impacts the firm’s ability to provide liquidity and execute trades with nanosecond precision. In this role, you are building the high-performance engines that drive trading strategies, data analysis, and risk management in real-time.

This position sits at the intersection of extreme technical challenge and immediate business impact. Whether you are working on low-latency execution platforms in C++, building data pipelines and automation tools in Python, or optimizing the Linux kernel for speed, your work is critical to the firm's success. You will collaborate closely with Quants and Traders to turn mathematical models into live, efficient software. This is a role for engineers who enjoy seeing the immediate results of their code in a fast-paced, competitive environment.

Common Interview Questions

The questions below are representative of what candidates face at AKUNA CAPITAL. They generally avoid brain teasers in favor of practical coding and systems questions. Note that C++ and Python tracks will have distinct questions, but the logic and problem-solving standards remain consistent.

C++ & Low-Level Systems

These questions test your mastery of the language and the machine it runs on.

• What is the difference between struct and class in C++?
• Explain the keyword volatile and when you would use it.
• Implement a thread-safe queue.
• What is a virtual destructor and why is it important?
• Explain memory layout (Stack, Heap, Data, Text segments).

Python & Scripting

These questions focus on your ability to use Python efficiently for data and automation.

• Explain the difference between a list and a tuple.
• How does Python manage memory? Explain reference counting and garbage collection.
• Write a function to flatten a nested list.
• What are Python decorators and how would you implement one?
• Explain the difference between deepcopy and shallow copy.

Algorithms & Logic

These questions assess your general problem-solving ability and speed.

• Given an array of integers, find two numbers that add up to a specific target.
• Implement an LRU (Least Recently Used) Cache.
• Detect a cycle in a linked list.
• Merge k sorted lists.
• Calculate the angle between the hour and minute hands of a clock.

Getting Ready for Your Interviews

Preparing for an interview at AKUNA CAPITAL requires a shift in mindset from general software engineering to performance-critical engineering. You should expect a process that rigorously tests your fundamental understanding of computer science concepts, not just your ability to write syntax.

Technical Depth & Fundamentals – 2–3 sentences describing: You must demonstrate a deep understanding of how your chosen language (usually C++ or Python) works under the hood. Interviewers will probe your knowledge of memory management, pointers, the Global Interpreter Lock (GIL), and data structure internals to ensure you can write highly optimized code.

Problem-Solving Speed & Accuracy – 2–3 sentences describing: In the trading industry, speed is a feature. You will be evaluated on your ability to solve algorithmic problems efficiently and accurately under time constraints, mirroring the rapid decision-making required in live trading environments.

Systems & OS Knowledge – 2–3 sentences describing: For many engineering roles here, knowing the application layer is not enough. You should be ready to discuss operating system concepts such as multithreading, concurrency, race conditions, and network protocols (TCP/UDP), as these are vital for low-latency systems.

Communication & Collaboration – 2–3 sentences describing: You will frequently work with non-engineers, such as traders and mathematical researchers. You need to demonstrate that you can articulate complex technical ideas clearly and work collaboratively to solve open-ended problems.

Interview Process Overview

The interview process at AKUNA CAPITAL is structured to filter for high technical aptitude and quick thinking early on. It typically begins with a rigorous Online Assessment (OA) or a technical phone screen, often involving HackerRank or similar platforms. These initial screens are designed to test your raw coding ability and math logic before you ever speak to an engineer. If you pass, you will move to technical phone interviews that dig deeper into language specifics and CS fundamentals.

The core of the evaluation is the Code Pair round and the final "Superday" or final round interviews. The Code Pair session is an interactive coding interview where you share a screen with an engineer to solve problems in real-time. This is distinct from a whiteboard interview because you are expected to write compilable, runnable code. The final rounds often involve a mix of system design, behavioral questions, and further deep-dive coding challenges. The process is known to be challenging but fair, prioritizing candidates who can demonstrate true mastery of their tools.

This timeline illustrates the progression from automated screening to intense live problem-solving. You should conserve your energy for the Code Pair and Final Round stages, as these are the most interactive and demanding parts of the process. Note that for specialized roles like Quant Developer or Systems Engineer, the specific technical questions in the middle stages will pivot heavily toward math or OS internals, respectively.

Deep Dive into Evaluation Areas

The evaluation at AKUNA CAPITAL is technically dense. Based on candidate reports, you should focus your preparation on the following key areas, tailoring your depth based on whether you are applying for a C++ or Python track.

Core Programming Languages (C++ or Python)

This is the most critical evaluation area. You are expected to be an expert in your primary language. For C++ candidates, this means modern standards (C++14/17/20) and low-level mechanics. For Python candidates, this means understanding the interpreter and efficient scripting.

Be ready to go over:

• Memory Management – Stack vs. heap, smart pointers (unique_ptr, shared_ptr), and manual memory management nuances.
• Language Internals – Virtual tables (v-tables) in C++, the GIL in Python, and how decorators or generators function.
• STL / Libraries – Deep familiarity with the Standard Template Library (C++) or standard Python libraries (collections, itertools).
• Advanced concepts – Template metaprogramming, move semantics, and r-value references for C++; asyncio and multiprocessing for Python.

Example questions or scenarios:

• "Implement a smart pointer from scratch and explain how it handles reference counting."
• "Explain the difference between malloc and new, and what happens at the OS level when you request memory."
• "How would you optimize a Python script that is CPU-bound versus one that is I/O-bound?"

Operating Systems & Concurrency

Because AKUNA CAPITAL deals with high-frequency and low-latency systems, understanding how the code interacts with the hardware is vital. This area tests your ability to write safe, parallel code.

Be ready to go over:

• Multithreading – Creating threads, thread lifecycles, and the difference between threads and processes.
• Synchronization – Mutexes, semaphores, spinlocks, and how to avoid deadlocks and race conditions.
• Networking – TCP vs. UDP, sockets, and multicast (crucial for market data feeds).
• OS Internals – Context switching, kernel vs. user space, and virtual memory.

Example questions or scenarios:

• "Describe a scenario where a race condition might occur in a trading system and how you would prevent it."
• "What is the difference between a process and a thread? Which is more expensive to create and why?"
• "How does the OS handle a page fault?"

Algorithms & Data Structures

While standard algorithmic questions are asked, they often come with a twist regarding efficiency or practical application. You need to know the time and space complexity of every solution you propose.

Be ready to go over:

• Linear Data Structures – Arrays, linked lists, stacks, and queues.
• Trees & Graphs – Binary search trees, heaps (priority queues), and basic graph traversal (BFS/DFS).
• Hash Maps – Implementation details, collision resolution, and performance characteristics.
• Sorting & Searching – Quick sort, merge sort, and binary search variants.

Example questions or scenarios:

• "Design a data structure that supports add, remove, and getRandom in O(1) time."
• "Given a stream of market data, how would you efficiently calculate the moving average?"
• "Find the median of two sorted arrays."