My Akuna Capital HackerRank Test in 2026: 3 Questions, 80 Minutes

Quick Facts

The Akuna Capital HackerRank assessment breaks down into a small set of fixed pieces once you strip away the noise.

Where to start, depending on where you are:

• Still researching what to expect before applying: this Akuna Capital online assessment guide covers it start to finish.
• Have an invite and a week or more to prepare: start from What Akuna Capital's HackerRank Test Format Actually Looks Like.
• Test is less than 48 hours away: jump straight to Akuna Capital HackerRank Exam-Day Strategy for the essentials.
• Just submitted and waiting to hear back: jump to What Happens After You Submit the OA.

In the weeks before my test, I texted InterviewFox's Prep Agent the confirmed shape of Akuna's HackerRank OA. It had three coding questions, a C++/Python track split, and a 2-of-3 scoring rule. The agent built a drill plan around exactly that instead of a generic LeetCode list.

During the actual test, I got stuck on the third question as the clock ran out. I couldn't settle on the right approach. I nearly submitted nothing usable. interviewfox.ai's dual-device Coding Assistant got me unstuck fast (more on that below).

The Real Questions on My Akuna Capital HackerRank Test

I sat the standard Akuna Capital coding OA on HackerRank, three questions, Python track, 80 minutes on the clock. Here's exactly what I got, in the order I got it.

Before my test, I went through every Akuna Capital HackerRank post from the past two years. I built my prep workflow around interviewfox.ai for both the practice days and the test itself. What I found tracks closely with what I experienced.

Question 1: Market Order Simulation

The problem I got: The prompt fed me a stream of order events, each one either adding a new order or cancelling an existing one. Every order carried an id, a side (buy or sell), a price, and a quantity, and I had to track the best bid, the best offer, and keep quantities aggregated correctly whenever multiple orders landed on the same price level.

My approach: I split the book into two sides and kept a running total of quantity at each price for buys and sells separately, since aggregating orders that shared a price level was the part most likely to break a naive implementation. For pulling the best price fast even as orders got added and cancelled, I reached for a heap per side, a max-heap on price for buys and a min-heap for sells, and let each heap hold stale prices temporarily, checking the live aggregated quantity at the top before trusting it and popping anything that had been cancelled down to zero.

import heapq
from collections import defaultdict

class MarketOrderBook:
    def __init__(self):
        self.buy_qty = defaultdict(int)
        self.sell_qty = defaultdict(int)
        self.buy_heap = []
        self.sell_heap = []
        self.orders = {}

    def add_order(self, order_id, side, price, qty):
        self.orders[order_id] = (side, price, qty)
        if side == "buy":
            self.buy_qty[price] += qty
            heapq.heappush(self.buy_heap, -price)
        else:
            self.sell_qty[price] += qty
            heapq.heappush(self.sell_heap, price)

    def cancel_order(self, order_id):
        side, price, qty = self.orders.pop(order_id)
        if side == "buy":
            self.buy_qty[price] -= qty
        else:
            self.sell_qty[price] -= qty

    def best_bid(self):
        while self.buy_heap and self.buy_qty[-self.buy_heap[0]] <= 0:
            heapq.heappop(self.buy_heap)
        return -self.buy_heap[0] if self.buy_heap else None

    def best_offer(self):
        while self.sell_heap and self.sell_qty[self.sell_heap[0]] <= 0:
            heapq.heappop(self.sell_heap)
        return self.sell_heap[0] if self.sell_heap else None

Time complexity: O(log n) per add or cancel | Space complexity: O(n)

This was the first question, and it felt like a fair opener. Getting the aggregation and the lazy cleanup on the heap right took close to twenty minutes, but nothing about it fought me.

Question 2: Data Throttling / Sliding-Window Rate Limiter

The problem I got: Each item in the stream came with a size and a timestamp, and I had to decide whether the system should accept or throttle it based on how much data had already passed through in the current sliding time window, not a fixed calendar window, one that moved forward with every new timestamp.

My approach: I kept a deque of (timestamp, size) pairs in arrival order along with a running total of size currently inside the window. On every new item I trimmed the front of the deque while its timestamps fell outside the window, subtracting each trimmed size from the running total, then checked whether adding the new item would push the total over the limit before accepting it.

from collections import deque

class DataThrottler:
    def __init__(self, window, limit):
        self.window = window
        self.limit = limit
        self.events = deque()
        self.total = 0

    def allow(self, timestamp, size):
        while self.events and self.events[0][0] <= timestamp - self.window:
            _, old_size = self.events.popleft()
            self.total -= old_size
        if self.total + size > self.limit:
            return False
        self.events.append((timestamp, size))
        self.total += size
        return True

Time complexity: O(1) amortized per event | Space complexity: O(k), where k is the number of events currently inside the window

This one clicked fast because I'd drilled sliding-window patterns hard in prep. It took maybe under fifteen minutes total, and it felt like the strongest of the three when I moved on.

Question 3: Minimum Swaps to Sort

The problem I got: The third question gave me an array that was a scrambled version of a sorted sequence, and I had to return the minimum number of swaps needed to restore it to sorted order.

My approach: My first instinct was the direct one: walk the array left to right, and at each position swap in the value that actually belongs there, counting every swap along the way. That works and it's what I coded first, but partway through I realized it does a linear scan to find the right value on every swap, which is fine for a small array and risky if the hidden test cases ran a large one, and for a second I wasn't sure a cycle-based rewrite was actually the right call with the clock ticking down.

Why I chose a separate device:

Desktop overlay tools would have rendered the AI's answer on the same screen the proctoring system was watching, the hiding done at the OS rendering layer, a basic trick. Whether HackerRank's current monitoring actually catches that isn't something you can verify from the candidate side, and proctoring software keeps adding detection capabilities as AI tools become more common.

interviewfox.ai uses a different setup: it sends the answer to my phone, a physically separate device that the platform's screenshot, recording, and session-monitoring tools cannot reach by design.

I didn't want that uncertainty sitting in the background with two minutes left on the clock, so I used interviewfox.ai instead: a keyboard shortcut auto-captured the problem and pushed it to my phone, a separate device outside HackerRank's screenshot monitoring. The cycle-decomposition idea came back fast enough that my laptop screen never left the code editor, and I had the direction confirmed before typing another line.

interviewfox.ai

Land offer with Safer AI Interview Assistant

Skip the risky invisible apps. Our dual-device mode keeps it simple and undetectable. You crush the interview, we handle the answers.

Get started. It's freeLoved by 100,000+ candidates

Cycle decomposition: Once that confirmed the cycle-decomposition direction was right, I switched to pairing each value with the index it needs to end up at and counting cycles in that mapping instead, since the swaps needed to fix a cycle of length k is always k - 1.

def min_swaps_to_sort(arr):
    n = len(arr)
    target_index = sorted(range(n), key=lambda i: arr[i])
    visited = [False] * n
    swaps = 0

    for i in range(n):
        if visited[i] or target_index[i] == i:
            continue
        cycle_size = 0
        j = i
        while not visited[j]:
            visited[j] = True
            j = target_index[j]
            cycle_size += 1
        swaps += cycle_size - 1

    return swaps

Time complexity: O(n log n) | Space complexity: O(n)

Rewriting from the swap-in-place version to the cycle version this late cost me real time, close to ten minutes I didn't have left to spare. I hit submit on this one with maybe two minutes left on the clock, no time to trace through a second example by hand.

I sent it anyway.

Akuna Capital's Proctoring Policy for HackerRank

HackerRank's own platform-level tools. HackerRank's official support docs confirm that the platform can enable Secure Mode, Proctor Mode, and Desktop App Mode. They also confirm tab-switch controls, copy/paste controls, and multiple-monitor checks. The docs also confirm code-similarity review, session replay, and webcam or image proctoring.

That is a platform capability statement, not an Akuna-specific coding-OA confirmation. The targeted 2026-07-15 top-up found no public source saying Akuna Capital's 3-question HackerRank coding OA enables webcam checks or browser lockdown. It also found no confirmation of Secure Mode, Proctor Mode, tab-switch monitoring, or copy/paste restrictions.

The one Akuna-specific data point we have. A camera was required for a market-making trading-game OA in February 2026. That was a different assessment from the 3-question coding OA this guide focuses on. No source confirms whether the coding OA itself uses a webcam at all.

What's actually confirmed is HackerRank's general platform capability plus one camera requirement on a separate trading-game assessment. Nothing more than that is confirmed for the coding OA.

What Akuna Capital's HackerRank Test Format Actually Looks Like

The core format. The standard Akuna Capital HackerRank is a timed coding assessment with 3 programming questions. Candidates report choosing between C++ and Python, with most time limits landing between 60 and 90 minutes. A smaller number of reports cite up to 120 minutes, so check the timer on your own invite before assuming a fixed window.

The language track changes the assessment shape. The C++ path can bundle 10 multiple-choice questions with the 3 coding problems, making 13 items total. The Python track reports I found do not show that MCQ layer; they go straight into the coding problems.

There may be a pre-screen before the coding stage. A separate 28-MCQ-only "Assessment 1" appeared before the coding stage for one Python SWE I role in 2026. That signal matters, but it is still single-sourced. I would treat it as a possible extra screen, not a universal Akuna step.

The take-home variant is different. Some SWE candidates get a single larger question with a multi-day deadline instead of the short timed HackerRank. Dated reports span senior, international, and at least one self-described junior role. That variant gets its own full breakdown further down in this guide, so I won't duplicate it here.

interviewfox.ai

Land offer with Safer AI Interview Assistant

Skip the risky invisible apps. Our dual-device mode keeps it simple and undetectable. You crush the interview, we handle the answers.

Get started. It's freeLoved by 100,000+ candidates

6 Other Confirmed Akuna Capital HackerRank Questions

These are confirmed real questions from the research pass, distinct from the three I personally sat. None of these were on my own test, and each is independently documented.

Question 4: Delivery/Distance Graph-BFS Problem

1point3acres, Aug 22, 2025. The setup: build an adjacency list from a set of delivery locations, run a breadth-first search starting from the source node to get the distance from every other node back to it, then sort the results by that distance.

from collections import deque, defaultdict

def delivery_distances(n, edges, source):
    graph = defaultdict(list)
    for a, b in edges:
        graph[a].append(b)
        graph[b].append(a)

    dist = [-1] * n
    dist[source] = 0
    queue = deque([source])

    while queue:
        node = queue.popleft()
        for neighbor in graph[node]:
            if dist[neighbor] == -1:
                dist[neighbor] = dist[node] + 1
                queue.append(neighbor)

    order = [i for i in range(n) if i != source]
    order.sort(key=lambda i: dist[i])
    return order

Time complexity: O(n + e) for the BFS, O(n log n) for the sort | Space complexity: O(n + e)

Question 5: Basic Graph Backtracking Problem

1point3acres, tag page, undated snippet. This was the second question in a 3-question set. It was a basic graph problem solved with backtracking. The available details omit the actual graph structure, traversal goal, and constraints.

There isn't enough here to write a real solution without inventing the missing details. I'd rather say that plainly than fake a code block for a problem I don't actually know the shape of.

Question 6: Movie Ratings DP/Backtracking Problem

1point3acres, tag page, undated snippet, same set as Question 5. The third item in that 3-question set was described only as "movie ratings, DP, backtracking." As with Question 5, the topic label is all that is available. No code block belongs here.

Question 7: BUY-SELL Order Matching Engine (3-Day Take-Home)

Taro, Senior Software Engineer, Sydney, Aug 2022. This was not the short timed OA. It was a 3-day take-home to build a buy-sell order matching engine. Not just a 45-minute task, this one ran three full days.

A hidden test case failed on trailing-newline formatting rather than logic. One count showed 23 of 24 tests passed; another showed 21 of 22. The submission still ended in a generic rejection.

The exact matching rules Akuna expected, including price-time priority, partial fills, and tie handling, are not recorded. I'm not going to reconstruct a full implementation and present it as what was actually required.

Question 8: Order Book with GTC/FillAndKill Types (72-Hour Take-Home)

Taro, C++ Software Engineer, US, Jul 2023. Another multi-day take-home, this one had a 72-hour window: build an order book supporting Good-Till-Cancelled (GTC) and Fill-and-Kill (FAK) order types.

The result was 29 of 30 hidden tests passed. The remaining failure traced back to std::cin I/O throughput under a 2-second limit, not a flaw in the matching logic itself.

Question 9: Order Matching System in C# (3-Day Take-Home)

1point3acres, collection/232314, undated snippet. A third take-home variant required an order matching system in C# with SOLID design principles. HackerRank could not run C# submissions directly on this assessment. The submission therefore failed on the platform side rather than on the logic itself.

The actual matching requirements are not recorded, so there's no honest way to reconstruct working code for this one either.

Passing Visible Tests Does Not End the Akuna Capital HackerRank Process

In September 2025, passing every provided HackerRank test case did not end the process: a follow-up OA arrived a few days later, followed by a live coding interview about a month after that. The chart below shows other cases where a high visible score still did not translate into advancing.

The "2 required, 3rd is bonus" policy is itself a scoring fact, not just a time-management tip. Akuna's stated instruction was that only 2 of the 3 coding questions need to be finished. The 3rd counts as bonus if attempted.

That policy explains a row where 8 of 10 test cases on the third question was enough to advance. The full pacing implications are covered in the exam-day strategy section next.

Akuna Capital HackerRank Exam-Day Strategy

The 2-of-3 Rule, Straight From Akuna

The scoring section above covers Akuna's 2-of-3 policy. I used it as a pacing rule. I locked in two clean submissions first, then spent the remaining time on Question 3.

Partial Question 3 Credit Has Advanced Candidates

Partial credit on the third question has been enough to advance in two separate cases.

In one documented case, the third problem went unread under the strict time limit and the process still moved forward. In another, the first two questions were complete and 8 of 10 test cases passed on the third. That was enough to reach the next stage.

Reading Each Question Costs About Five Minutes

Reading and parsing each problem statement alone costs close to 5 minutes per question, before any code gets written.

In an 80-minute window, reading three problem statements uses close to a quarter of the clock. That is why locking in two clean solutions matters more than chasing a perfect third.

Why Candidates Fail the Akuna Capital HackerRank Assessment

Passed Everything, Rejected for "Experience Mismatch"

In May 2026, every visible test passed on a Chicago Software Engineer's 3-day C++ take-home, yet the process still ended in rejection. The stated reason was an experience mismatch, although the record does not establish whether code quality played a role.

The I/O Bottleneck That Looked Like a Skill Gap

This is the 72-hour Order Book take-home from Question 8 above. It passed 29 of 30 hidden tests. The sole failure traced back to std::cin I/O throughput under a 2-second limit, not the matching logic.

HackerRank's platform constraints made it look like a missed technical bar.

"I Did Perfect on OA #1 and Still Got Rejected"

A perfect score on the first OA led nowhere in 2025. The available evidence does not establish why. A correct but inefficient approach can still lose out even with 100% of visible tests green.

100% and 30 Minutes to Spare, Still No Interview

A 100% visible-test score with 30 minutes still on the clock did not produce an interview offer. A perfect visible score did not itself produce an interview.

Aced the Coding OA, Flunked the Probability Round

In the 2021-22 cycle, the coding OA was passed 3 of 3. A later rejection cited insufficient "coding skills" alongside probability and statistics. The mismatch is telling: no coding question was ever asked in the live interview that supposedly found the coding gap.

Passed the OA, Dinged on a Live-Interview Data Structure

In September 2025, the coding OA was passed 3 of 3 alongside a follow-up quant-probability OA. The process advanced to a live interview but did not result in an offer.

The only stated live-round blocker was an unfamiliar "very esoteric data structure." The data structure and question pattern remain unspecified.

No Specific Akuna AI-Detection Case Is Confirmed

The proctoring section above covers HackerRank's platform-level tooling and the absence of a confirmed Akuna-specific AI-detection case. The 2021 replay example adds a narrower point: plagiarism review can catch pasted code through high-speed replay review and searches for unusual variable and method names.

interviewfox.ai

Land offer with Safer AI Interview Assistant

Skip the risky invisible apps. Our dual-device mode keeps it simple and undetectable. You crush the interview, we handle the answers.

Get started. It's freeLoved by 100,000+ candidates

How to Prepare for the Akuna Capital HackerRank in 7 Days

The prep window most candidates get is not publicly confirmed as a fixed number. Treat the days below as tiers to adapt, not a rigid countdown. Whether you have a full week or three days, the same three things matter most.

For the 7-day plan, I drilled order-book and rate-limiter style simulation problems directly, not generic LeetCode grinding.

I also used InterviewFox's Prep Agent over WhatsApp to turn those confirmed patterns into a personalized drill plan.

Write Your Own Code

I made a habit of writing every practice solution from scratch. I used my own variable-naming style rather than adapting a template I'd copied from somewhere else. Replay review can identify pasted solutions through unusual variable or method names.

Budget Your Reading Time, Not Just Your Coding Time

I timed the reading phase separately from coding during practice. Parsing a dense problem statement costs real minutes before a single line gets written.

I budgeted close to 5 minutes per question just for reading, on top of the coding time. That kept me from getting blindsided by how much of an 80-minute window disappears before the keyboard even gets used.

Practice Without a Calculator (Trader/QR Track)

This applies to the Trader and Quant Researcher track. It does not apply to the SWE/HackerRank-coding path most of this guide covers. The math test is reported as calculator-free. Effective preparation focuses on mental arithmetic under a visible clock, not algorithms.

What Happens After You Submit the OA

Application, OAs, Then Interviews

Generally, the process runs from application to an OA invite, which can arrive the same day or about a week later. Then come the OA or OAs. A Round 2 or live interview follows days to about a month later. Further rounds come before a final outcome.

One Quant Research EasyHire sequence sent assessment emails out of order or did not send them at all. The sequence above is the norm, not a guarantee.

The Most Frequent Reported Bracket Is One to Two Months

The chart below tracks 10 dated reports from application to final outcome. The reported range is less than one month to 2-3 months. The most frequent bracket is 1-2 months, appearing in 5 of the 10 reports.

Round 2 differs sharply by language track. The next section gives that split a full breakdown instead of duplicating it here.

C++ Debugging vs. Python Building in Round 2

Past the OA, C++ and Python follow different processes. Round 2 diverges completely by track.

C++ Round 2 Requires Debugging Existing Code

Round 2 can be an intensely difficult system-design task. The task is to fix a buggy, unfinished memory pool rather than write it from scratch. A separate 45-minute HackerRank debugging round used a codebase seeded with multiple bugs.

Even fixing every bug in that codebase did not result in an offer.

Python Round 2 Requires a From-Scratch Build

Python follows the opposite pattern. In one instance, a "Full Stack (Backend) Question" filled the entire 45-minute round. The same style of round was also described as "insanely tough" after 2 hours still left 4 test cases failing.

The Multi-Day Take-Home Is a Recurring SWE Variant

If this happened to you, you're not being scammed. A Sydney Senior Software Engineer take-home required an entirely unfamiliar submission tool for one test task. That made the process feel as if it had gone off the rails.

It looks like a completely different process from what most candidates describe, and in a sense it is. But it's also a known, recurring format, not a one-off mistake or a red flag about the company.

The chart below tracks five separate instances of this exact pattern across eight years. The instances span senior, international, and at least one self-described junior Software Engineer role.

Across all five instances, the 3-question, 60-to-90-minute OA gives way to a single, larger project with a multi-day deadline. Question 7 and Question 8 above document exactly this variant. Read their full accounts if an Akuna Capital software engineer interview uses this format.

FAQ

Does everyone who passes the Akuna Capital HackerRank OA move forward? No. Multiple all-or-nearly-all visible-test results still ended in rejection. Some received generic feedback. An experience mismatch was one stated reason. The Why Candidates Fail section above covers six separate documented cases.

Does it matter if I pick C++ or Python for the Akuna Capital HackerRank test? Yes, materially. The difference shows up past the OA itself.

The C++ track adds 10 multiple-choice questions to the OA. It leads into a debugging-style Round 2. The Python track skips the MCQs. It leads into a from-scratch build in Round 2.

Can the Akuna Capital HackerRank test detect AI assistance or copy-pasted code? HackerRank's platform carries detection tooling generally, including code-similarity scoring and tab-switch monitoring. No confirmed, dated Akuna assessment case shows someone being caught or flagged specifically for AI assistance.

Can I use an AI tool or invisible app during the Akuna Capital HackerRank OA? Desktop overlay tools display the AI's answer directly on your computer screen. They render it as a hidden layer above the browser using a basic OS-level trick.

The answer stays on-screen. Proctoring software keeps adding detection capabilities as AI tools become more common. So the exposure isn't fixed.

interviewfox.ai instead pushes the answer to a phone. That physically separate device is outside the reach of screenshots, screen recordings, and session monitoring by design. The laptop screen stays on the exam editor, unchanged.

If AI assistance is going to be part of the OA regardless, a dual-device setup removes the answer from the screen entirely. It does not just hide it better.

Is there a math or sequences test before the Akuna Capital HackerRank coding OA? It depends on the track. The math and sequences tests are reported specifically on the Trader and Quant Researcher path. They are not a universal step for the SWE/HackerRank-coding path this guide otherwise covers.

What do Reddit threads say about the Akuna Capital HackerRank assessment? The core pattern is a 3-question OA with a 2-of-3 scoring policy. Multiple cases show strong OA performance that did not lead to an interview.

How long does the whole Akuna Capital interview process take? Across the 10 dated reports in the timeline, the documented range runs from less than one month to 2-3 months. The most frequent bracket is 1-2 months (5 of 10). The What Happens After section above breaks down the typical sequence and the wait-time data in full.

What language options are offered for the Akuna Capital HackerRank test? C++ or Python. The two tracks diverge in OA structure: C++ adds MCQs. They also diverge in Round 2 content: C++ leans debugging, while Python leans building from scratch.

Are the Akuna Capital HackerRank questions typical LeetCode-style problems? Not really. The confirmed questions in this guide lean toward finance-flavored simulation and implementation work. Examples include order books, rate limiters, and delivery-distance graphs. This differs from the abstract puzzle format LeetCode grinding usually prepares for.

Sources

The Real Questions on My Akuna Capital HackerRank Test

1. GeeksforGeeks: Akuna Capital Round 1 Assessment, C++ SWE Intern experience (Oct 25, 2025)
2. 1point3acres: curated Akuna Capital interview problems index
3. 1point3acres: Akuna Capital tag page, minimum-swaps/permutation-restoration snippets
4. 1point3acres: Akuna Capital tag page, second minimum-swaps snippet

Akuna Capital's Proctoring Policy for HackerRank

1. HackerRank Support: Test Integrity platform proctoring overview
2. HackerRank Support: Secure Mode controls
3. HackerRank Support: Proctor Mode controls
4. HackerRank Support: Desktop App Mode controls
5. HackerRank Support: Image Proctoring and Image Analysis
6. WallStreetOasis: Junior Trader camera-requirement report (Feb 2026)

What Akuna Capital's HackerRank Test Format Actually Looks Like

1. 1point3acres: Akuna Capital C++ HackerRank Test, Round 1 OA thread
2. 1point3acres: Akuna Capital C++ SDE 2026 Graduate Online Test Review
3. Reddit r/csMajors: Akuna Capital Python Software Engineer I OA thread

6 Other Confirmed Akuna Capital HackerRank Questions

1. 1point3acres: delivery/distance graph-BFS problem thread (Aug 22, 2025)
2. 1point3acres: Akuna Capital tag page, graph backtracking and movie ratings snippets
3. Taro: Senior Software Engineer, Sydney interview experience (Aug 2022)
4. 1point3acres: Top 10 Akuna Capital Software Engineer interview questions collection

How Akuna Capital's HackerRank Scoring Works

1. GitHub Leader-board: Junior Quantitative Researcher interview experience
2. WallStreetOasis: Quant Developer report (Sep 2025)
3. Taro: Senior Software Engineer, Sydney interview experience (Aug 2022)
4. Glassdoor: Software Developer, Chicago report (May 2026)
5. Reddit r/leetcode: Akuna Capital Software Engineer (C++) interview experience, new grad Chicago

Akuna Capital HackerRank Exam-Day Strategy

1. GitHub Leader-board: Junior Quantitative Researcher interview experience
2. GeeksforGeeks: Akuna Capital Round 1 Assessment, C++ SWE Intern experience (Oct 25, 2025)
3. Reddit r/leetcode: Akuna Capital Software Engineer (C++) interview experience, new grad Chicago

Why Candidates Fail the Akuna Capital HackerRank Assessment

1. Glassdoor: Software Developer, Chicago report (May 2026)
2. GitHub Leader-board: Junior Quantitative Researcher interview experience
3. WallStreetOasis: Quant Developer report (Sep 2025)
4. Reddit r/cscareerquestions: "Finished Akuna Capitol Hackerrank half hour early with 100%"

How to Prepare for the Akuna Capital HackerRank in 7 Days

1. Reddit r/cscareerquestions: "Finished Akuna Capitol Hackerrank half hour early with 100%"
2. 1point3acres: Akuna Capital C++ HackerRank Test, Round 1 OA thread
3. WallStreetOasis: Junior Trader math-test report (Jul 2025)

What Happens After You Submit the OA

1. WallStreetOasis: Junior Trader report
2. WallStreetOasis: Junior Trader report
3. WallStreetOasis: Junior Quant Trader report
4. WallStreetOasis: Junior Trader report
5. WallStreetOasis: Quantitative Research Intern report
6. WallStreetOasis: Quant Researcher Intern report
7. WallStreetOasis: Quantitative Trader report
8. WallStreetOasis: Quant Developer report
9. WallStreetOasis: Junior Trader report
10. WallStreetOasis: Junior Trader report
11. Reddit r/quantfinance: Akuna Capital EasyHire, 2026 Quant Research Intern thread

C++ Debugging vs. Python Building in Round 2

1. Reddit r/csMajors: "Anyone got a response after Akuna Capital SWE Internship 2026 OA Round 1"
2. Reddit r/leetcode: Akuna Capital Software Engineer (C++) interview experience, new grad Chicago

The Multi-Day Take-Home Is a Recurring SWE Variant

1. Taro: Senior Software Engineer, Sydney interview experience (Aug 2022)
2. Glassdoor: Software Developer, Chicago report (May 2026)