Voleon Software Engineer Interview Questions

Voleon·Software Engineer·Technical Phone Screen

Jul 2026

Voleon threw a recursive string parsing problem at me that looked deceptively clean on the surface. The constraint to hit O(n) was the real test.

A 'good string' is defined recursively: '0' is a good string, and if A and B are both good strings, then '1' + A + B is also a good string. Given a binary string, determine whether it is a good string. Your solution must run in O(n) time.

“My first instinct was to write a recursive parser and call it a day, which technically works but I fumbled explaining the O(n) guarantee because I kept second-guessing whether the recursion would revisit characters.”

View Post

Voleon·Software Engineer·Technical Phone Screen

Jun 2026

Voleon SWE interview had at least one coding round that went straight into a circular game simulation variant. Not a brutal interview but the twist on a known problem meant you couldn't just recite the standard solution.

Given n friends sitting in a circle, simulate an elimination game where the count-to-eliminate changes each round according to a given array. Return the last remaining friend.

“I recognized the base problem pretty fast but the per-round k array threw me for a second.”

View Post

Voleon·Software Engineer·Technical Phone Screen

Jun 2026

Voleon gave me a coding problem about simulating a Kac ring, which sounds like a physics toy but turns into a pretty tricky math/CS puzzle once you hit the O(1) constraint on kstep. The question was well-designed and clearly not off-the-shelf leetcode, which I respect even if it wrecked me a little.

Implement a Kac ring simulation with N positions on a circle, where balls move clockwise each step and flip color when leaving a marked position. The class needs a step() method, a kstep(k) method that runs in O(1) time even for k up to 10^18, and a color() method that returns (W - B) / N in O(1).

“The step() part was fine, just bookkeeping.”

View Post

Voleon·Software Engineer·Onsite - System Design / Architecture

May 2026

Voleon system design round, pretty deep into multi-client trading infrastructure. The question had a lot of moving parts and I felt like I was chasing the problem the whole time rather than leading it.

You have an existing single-client trading system with a market data feed and an order manager that enforces a participation-rate cap. How would you extend it to handle multiple clients simultaneously, where one client's executed order shifts the market state before the next client acts?
How would you design a priority queue for client orders on a per-symbol basis, and what data structure or keying strategy supports swappable prioritization policies like FIFO, tier-weighted, or deadline-aware ordering?
How do you maintain per-client participation-rate caps independently when multiple clients are trading the same symbol, and how do you prevent one client's high volume from eating into another's quota?
Walk through the concurrency model: do client strategies run on shared threads or isolated per-client threads, and how does that interact with the order routing stage?
How would you test the interaction effects between clients deterministically, given that fills and market state changes are time-dependent?

“This is where I fumbled first.”

View Post

Voleon·Software Engineer·Technical Phone Screen

May 2026

Voleon coding screen focused on a streaming data problem, basically a trade feed processor with volume queries mixed in. Pretty niche problem, felt more like a systems-adjacent coding challenge than a pure algo grind.

Given a stream of trade events, design a system that handles both trade print events and volume-check queries for a specific security. How do you process these efficiently?

“I went straight to a hashmap keyed by security ID and accumulated volume as trade events came in.”

View Post

Voleon·Software Engineer·Technical Phone Screen

May 2026

Voleon software engineer interview with a geometry/grid problem that started simple and got complicated fast. Two parts: first no blockers, then rocks that block queen attacks. Classic escalation structure.

Given a set of queen positions on an unbounded 2D integer grid and a list of query points, for each query point return how many queens can attack it. A queen attacks along all 8 directions (row, column, two diagonals), with no blockers.
Now add rocks to the grid. A queen can only attack a query point if there is no rock strictly between the queen and the point along their shared line. Return the same attack counts with this blocking constraint.

“Part 1 felt manageable.”

View Post

Voleon·Software Engineer·Technical Phone Screen

May 2026

Voleon threw a chess-themed algorithmic problem at me that started reasonable and then got a lot more interesting once blockers entered the picture. Two-part question, one interview, and I left feeling like I'd only half-solved it.

Given an N×N chessboard with a list of queens and a list of query points, for each point determine how many queens can attack it, where a queen attacks along its row, column, and both diagonals.
Now add 'rocks' to the board that block a queen's line of attack. A rock stops the attack ray at that cell, the rock itself is not attacked, and any point behind the rock on that ray is safe from that queen. How do you handle this efficiently?

“Part one felt manageable.”

View Post

Voleon·Software Engineer·Technical Phone Screen

May 2026

Voleon coding round focused on a single meaty implementation problem around sparse matrices. Not a vibe-check interview at all, pretty much just heads-down engineering the whole time.

Implement a sparse matrix data structure that supports addition and multiplication, using a memory-efficient representation that skips zero entries. Include proper dimension validation and raise meaningful errors when shapes are incompatible.

“I went with a dict-of-dicts internally, rows as outer keys and columns as inner.”

View Post

Voleon·Software Engineer·Technical Phone Screen

May 2026

Interviewed for a software engineering role at Voleon and got a pretty meaty algorithmic problem involving a circular ring of balls and gates. The core challenge was figuring out how to answer queries efficiently when K can be astronomically large. Felt like a competitive programming problem dressed up in a physics costume.

You have a ring of N positions, each with a ball (white or black) and optionally a flip gate. Balls move clockwise each step, toggling color when crossing a gate. Given a potentially huge number of steps K, how many balls are white after exactly K steps? Design a preprocessing approach that answers each query in O(1).

“The naive simulation is obviously dead on arrival when K is huge.”

View Post

Voleon·Software Engineer·Onsite - Multi Round

May 2026

Voleon quant onsite, multi-part technical loop. Heavy on ML fundamentals and linear algebra, the kind of interview where you can't just memorize a leetcode problem and call it a day. Left feeling like I held my own on most of it but definitely fumbled some of the theoretical depth they were probing for.

Explain the power method for finding leading eigenvectors, including how the algorithm works and why it converges.
Why does imposing sparsity constraints on PCA make the eigenvector problem significantly harder to solve?
Walk through the bias-variance trade-off across different model families including linear regression, ridge, lasso, kernel methods, and tree ensembles. When does each tend to minimize total error?
Solve a geometric interpretation problem involving linear regression, specifically around projection and orthogonal complements.

“I knew the basics: repeatedly multiply by the matrix and normalize.”

View Post