Stripe's OA in 2026 keeps its trademark shape: two engineering-heavy problems in a 90-minute window. Unlike LeetCode-style screens, Stripe prompts span 2-3 screens with multiple APIs and incremental parts — they test whether you can ship clean, extendable engineering code under pressure. This article breaks down the three core themes for the 2026 New Grad cycle and adds a practical VO coaching / mock-interview plan.
Stripe OA 2026 at a Glance
| Dimension | Detail |
|---|---|
| Platform | Stripe's in-house web IDE |
| Duration | 90-120 minutes |
| Count | 2 long problems, each with multiple parts |
| Difficulty | LC Medium + engineering extensions |
| Grading | Unit tests + code readability |
| Focus | State machines, string parsing, API simulation |
Type 1: State Machines / Event Handling
Stripe state-machine problems are essentially guaranteed. Common wrappers: subscription state flow, refunds, Payment Intent.
Sample: Subscription FSM
Implement a subscription FSM with states {active, trialing, past_due, canceled} and these transitions:
| Current state | Event | Target state |
|---|---|---|
| trialing | trial_ended (paid) | active |
| trialing | trial_ended (unpaid) | past_due |
| active | invoice_failed | past_due |
| past_due | invoice_paid | active |
| any | cancel | canceled |
class SubscriptionFSM:
def __init__(self):
self.state = "trialing"
self.transitions = {
("trialing", "trial_ended_paid"): "active",
("trialing", "trial_ended_unpaid"): "past_due",
("active", "invoice_failed"): "past_due",
("past_due", "invoice_paid"): "active",
}
def handle(self, event):
if event == "cancel":
self.state = "canceled"
return self.state
key = (self.state, event)
if key in self.transitions:
self.state = self.transitions[key]
return self.state
raise ValueError(f"Invalid event {event} in state {self.state}")
Part 2 typically asks for event replay (apply historical events to derive final state). Part 3 asks for undo (step back to the previous state).
The key to Stripe state-machine problems is an explicit transition table + extensibility — never hard-code nested if-else.
Type 2: Fraud Detection / Sliding Window
Sample: Suspicious Activity
txn_logs[] sorted by timestamp; each row (ts, user_id, amount, country). Flag a user if within any 5-minute window their behavior satisfies either:
- Total transactions exceed $10,000, or
- More than 3 distinct countries
from collections import defaultdict, deque
def find_fraud(txns):
suspects = set()
windows = defaultdict(deque)
sums = defaultdict(int)
countries = defaultdict(lambda: defaultdict(int))
for ts, uid, amt, ctry in txns:
windows[uid].append((ts, amt, ctry))
sums[uid] += amt
countries[uid][ctry] += 1
while windows[uid] and windows[uid][0][0] < ts - 300:
old_ts, old_amt, old_ctry = windows[uid].popleft()
sums[uid] -= old_amt
countries[uid][old_ctry] -= 1
if countries[uid][old_ctry] == 0:
del countries[uid][old_ctry]
if sums[uid] > 10000 or len(countries[uid]) >= 3:
suspects.add(uid)
return suspects
Time O(n) — each entry is enqueued and dequeued at most once.
Type 3: API Parsing and Reconciliation
Sample: Multi-currency Reconciliation
Two datasets:
charges[]=[(charge_id, amount_cents, currency)]refunds[]=[(charge_id, amount_cents, currency)]
Compute the net per currency (charges − refunds). Part 2: convert everything to USD using fx_rates: {currency: rate_to_usd}.
from collections import defaultdict
def reconcile(charges, refunds, fx_rates):
by_ccy = defaultdict(int)
for _, amt, ccy in charges:
by_ccy[ccy] += amt
for _, amt, ccy in refunds:
by_ccy[ccy] -= amt
usd_total = 0
breakdown = {}
for ccy, amt in by_ccy.items():
breakdown[ccy] = amt
usd_total += amt * fx_rates.get(ccy, 0)
return breakdown, usd_total
The challenge in Stripe reconciliation isn't the algorithm — it's edges: refunds exceed charges, missing fx rates, partial currencies.
Frequency Table from 1point3acres
| Category | Frequency | Key technique |
|---|---|---|
| State machines | ★★★★★ | Explicit transition table |
| Sliding window / fraud | ★★★★ | Deque + dict |
| API parsing / reconciliation | ★★★★ | defaultdict + precision |
| Rate limiter | ★★★ | Token bucket / sliding |
| Template substitution | ★★★ | Stack |
VO Loop
Stripe's 2026 VO continues to be 5 rounds:
- HR phone: motivation + projects (25 min)
- Algorithms: 1 LC Medium-Hard + follow-ups (60 min)
- Integration: long realistic-scenario code, OA-style but deeper (90 min)
- Debug / bug bash: find and fix bugs in given code (60 min)
- Hiring manager / behavioral: Operating Principles (45 min)
VO Coaching / Mock Interview Roadmap
Practical patterns
- OA bucketing: tag the last 6 months of Stripe reports on 1point3acres + Glassdoor by topic; concentrate on state machines, fraud, reconciliation
- Integration round mocks: have a mentor run a 90-minute long problem; you code + narrate design
- Debug round practice: pick a buggy open-source toy project on GitHub; timebox a fix
- Behavioral playbook: prepare 3 stories around Stripe Operating Principles (Move with urgency, Bring evidence, Trust and amplify)
oavoservice's combined VO Proxy + VO Coaching package
For Stripe's 5-round VO (HR / Algorithms / Integration / Debug / HM), oavoservice offers:
- VO Coaching: state machine + fraud + reconciliation + integration long-form mocks, with realistic 90-minute timing
- VO Proxy: real-time answer assistance during the live interview — especially for Integration long-form coding and Debug round
- Behavioral playbook: stories tuned to Stripe Operating Principles (Move with urgency / Bring evidence / Trust and amplify)
- Recorded debrief: every mock is recorded; we audit your Part 1 / Part 2 time allocation
Reach out on WeChat Coding0201 for the full plan and pricing.
7-Day Sprint
| Day | Task |
|---|---|
| D1 | Bucket the last 90 days of Stripe OA posts |
| D2 | State machines: write 3 (Subscription, Refund, Payment Intent) |
| D3 | Fraud / sliding window: LC 239 + classic deque problems |
| D4 | API parsing / reconciliation: 5 hand-crafted edge cases |
| D5 | One full 90-minute mock in a Stripe-like web IDE |
| D6 | Debug round: fix 1 open-source bug |
| D7 | Behavioral STAR: polish 1 story per Operating Principle |
FAQ
Is Stripe OA totally different from LeetCode?
Yes. Stripe prompts read like product specs: 2-3 screens with multiple parts. The right prep isn't more LC — it's practicing engineering code + state-machine abstractions.
How hard is the OA?
Algorithms sit at LC Medium, but the time pressure + prompt length push the felt difficulty up to LC Hard. Finishing Part 1 + Part 2 in 90 minutes is typically passing.
Cooldown after a failed Stripe OA?
Typically 12 months. Switching teams (e.g., Payments → Connect / Issuing) usually resets it.
Which languages does Stripe OA support?
Python / JavaScript / Java / Go / Ruby and others. New Grad reports on 1point3acres lean heavily on Python.
Preparing for Stripe OA / VO?
oavoservice provides OA bucketing, integration-round mocks, debug-round drills, behavioral playbooks for Stripe / PayPal / Square / Adyen and similar payments / fintech companies. Our mentors come from frontline payments / infra teams and can build a 1-2 week sprint around the Stripe New Grad bar.
👉 Add WeChat: Coding0201 — get Stripe high-frequency questions + VO coaching.
Contact
Email: [email protected]
Telegram: @OAVOProxy