Problems
Core Catalog Algorithms Domain Knowledge NEW Workbooks
Leaderboard
Community
Overview Contributors Affiliate Program Shop
Tools
Mock Interview NEW Resume Reviewer Job Board NEW
Join our Discord server!

Practice real systems,
not Leetcode puzzles.

Crush Technical Interviews.Be the other candidate.

Get Started Try Mock Interviews
WhiteBox problem showcase WhiteBox problem showcase

Our users landed offers at

Google
Apple
Nvidia
Roblox
Snowflake
Jane Street
HRT
Databricks
Google
Apple
Nvidia
Roblox
Snowflake
Jane Street
HRT
Databricks
Google
Apple
Nvidia
Roblox
Snowflake
Jane Street
HRT
Databricks
Google
Apple
Nvidia
Roblox
Snowflake
Jane Street
HRT
Databricks

Practice what actually gets you the offer.

Top companies don't just filter on LeetCode anymore. 80% of your prep should go toward building real engineering skills: implementation depth, domain knowledge, and systems thinking.

Gmail Inbox 2

Real interview problems straight from the source.

We actively interview at top companies (FAANG+, quants) to keep our problems catalog fresh, and stay up to date with the interview meta.

You can also contribute your latest interview problems to the problems catalog and gain cool cosmetics & badges.

The best DSA roadmap you'll find.

Neetcode is outdated. TLE and A2Z are bloated. WhiteBox's roadmap is handpicked by Codeforces Masters and ICPC/IOI participants from Quant and FAANG+ companies.

Learn the minimum set of patterns that covers what top companies actually ask. No repetition, no padding. Just the techniques that transfer directly to interviews.

Complete Search10/12
Recursion6/6
BFS & DFS0/8
Prefix Sums2/7
Stacks & Queues0/2
Getting Started10/11
Maps & Sets6/8
Two Pointers0/2
Binary Search10/10
Trees0/6
Sorting0/2
-2σ-1σμ+1σ+2σ

Unlock your inner potential.

We notice that candidates waste months on the wrong resources & study habits. Most people are also ignorant of resources beyond Leetcode and influencer courses. We compile and organize all the resources out there to help you skip the beginner phase, avoid traps, and land your dream offer.

The deciding rounds, organized.

LeetCode is just the bar. Strong candidates separate themselves by what they know beyond it: OS internals, concurrency, ML fundamentals, distributed systems. Organized into focused modules.

WhiteBox domain knowledge modules WhiteBox domain knowledge modules
Explore Knowledge Base Structured modules across every domain top companies test

Interview problems, sourced from real interviews

Company tags on LeetCode go stale for years. WhiteBox problems come straight from candidates who just interviewed, shared anonymously and curated by our team.

New Submission 3 hours ago
Akuna Capital
Quant Dev Final Round
I got asked this last week and got cooked on this problem ngl. It was implement a lock-free MPSC queue and you had to implement...
Akuna Capital Concurrency 2025 Dec
Anonymous
MPSC Queue – WhiteBox
https://whitebox.ac/problems/mpsc-queue

MPSC Queue

Expert 8 Concurrency Akuna Capital

Implement a lock-free MPSC (multi-producer, single-consumer) queue.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
namespace whitebox
{
template <typename T>
class MpscQueue {
public:
explicit MpscQueue(size_t capacity)
: capacity_(capacity), mask_(capacity - 1),
data_(capacity), seq_(capacity) {
assert((capacity & mask_) == 0 && "capacity must be a power of 2");
for (size_t i = 0; i < capacity_; ++i) {
seq_[i].store(i, std::memory_order_relaxed);
}
head_.store(0, std::memory_order_relaxed);
tail_.store(0, std::memory_order_relaxed);
}
bool push(const T& value) {
size_t pos = head_.load(std::memory_order_relaxed);
while (true) {
size_t tail = tail_.load(std::memory_order_acquire);
if (pos - tail >= capacity_) return false;
if (head_.compare_exchange_weak(
pos, pos + 1,
std::memory_order_acq_rel,
std::memory_order_relaxed)) {
auto& s = seq_[pos & mask_];
while (s.load(std::memory_order_acquire) != pos) {}
data_[pos & mask_] = value;
s.store(pos + 1, std::memory_order_release);
return true;
}
}
}
bool pop(T& out) {
size_t pos = tail_.load(std::memory_order_relaxed);
auto& s = seq_[pos & mask_];
if (s.load(std::memory_order_acquire) != pos + 1) return false;
out = std::move(data_[pos & mask_]);
s.store(pos + capacity_, std::memory_order_release);
tail_.store(pos + 1, std::memory_order_release);
return true;
}
private:
const size_t capacity_;
const size_t mask_;
std::vector<T> data_;
std::vector<std::atomic<size_t>> seq_;
std::atomic<size_t> head_;
std::atomic<size_t> tail_;
};
}
Accepted 20 · 12% acceptance
Submit a problem you were asked Earn free Premium for verified contributions

Everything in one place.

We built the interview prep platform we wished existed. Here's what sets WhiteBox apart.

WhiteBox
LeetCode / NeetCode
getcracked.io
Codeforces
Interview Transferability Does it reflect what companies actually ask?
Real, direct & up-to-date interview problems covering algorithms, systems, and implementation patterns
Algorithmic focus — transferability varies
Strong for C++ / quant, narrower scope
Builds problem-solving fundamentals, steep learning curve
Implementation Problems Real systems, not toy puzzles
Concurrency, ML pipelines, API design, and production patterns
Limited, mostly behind paywall
Some
None
Skill Rating How you compare to other candidates
Custom Elo-based rating with per-domain strength breakdown
Based on problems solved
Based on problems solved and success rate
Elo rating (contest only)
Tsuki AI Tutor In-editor guidance that teaches, not tells
Context-aware AI that know your code, language, and constraints
Leet (premium only)
None
None
AI Mock Interviews Practice speaking under pressure
Voice-based mock interviews with real-time AI interviewer, per-question rubric grading, and detailed debrief reports
None
None
None
Problem Sourcing How current and relevant the problems are
Continuously sourced from the community & our own exclusive problems
Company Tags (Premium & Outdated)
Relevant but quant-focused niche
Not relevant to interviews
Structured Roadmap A clear path to mastery
Interactive skill tree with dependency mapping, progress tracking, and curated problem sets per topic
Study plans exist but are rarely updated
None — problem list only
No guided path
Gamification Stay motivated long-term
Unlockable cosmetics, profile badges, card frames, and a leaderboard to compete with friends
Streaks and badges
None
None
Pricing Cost to access
Generous free tier — premium from $12/mo
$180/yr (LeetCode) or $300 lifetime (NeetCode)
$25/mo, no free tier
Free

Pay once and prep forever.

One payment. No subscriptions eating into your runway while you're job hunting. Lock in lifetime access before prices go up.

Free

$0 /month

Level up your interview game with commonly asked interview implementation questions.

  • 100+ implementation problems & quizzes
  • 700+ handpicked DSA problems
  • Exclusive interview questions
  • Discord advice & mentorship
  • AI resume review
  • Custom profile badge
  • Lock in price forever

Premium

Most popular
$12 /month

One lunch for the complete WhiteBox experience.

  • 100+ implementation problems & quizzes
  • 700+ handpicked DSA problems
  • DSA roadmap & workbooks
  • Exclusive interview questions
  • Unlimited mock interviews
  • Discord advice & mentorship
  • AI resume review
  • Custom Premium badge
  • Lock in price forever

Lifetime

$167 /once

0.2% of your future salary.

  • 100+ implementation problems & quizzes
  • 700+ handpicked DSA problems
  • DSA roadmap & workbooks
  • Exclusive interview questions
  • Unlimited mock interviews
  • Discord advice & mentorship
  • AI resume review
  • Custom Lifetime badge
  • Lock in price forever

Frequently asked questions