Skip to content
Hari KharelStudy

Stripe

Stripe tests real-world engineering, not puzzles. Expect a practical coding problem that grows in parts, a bug bash in an unfamiliar repo, an integration round against unfamiliar API docs, design with idempotency at its heart, and a behavioral round scored against Stripe’s operating principles. Your code is read like a pull request. Candidates who prepared only LeetCode freeze in the repo rounds.

The loop

Section titled “The loop”
Stage Format Evidence
Online assessment (some candidates) 60 min reported
Recruiter screen 30 min reported
Technical screen 60 min practical, multi-part coding. Since 2026 it is sometimes an AI-assisted round reported
Onsite (4-5 rounds) Coding, Bug Bash, Integration, System Design (mid-level and above), Behavioral with the hiring manager. Staff+ often present a project instead of Integration reported
Team matching After the onsite reported
  • Environment. Your own IDE with screen share, or CoderPad. For Bug Bash and Integration you clone a repo and run it locally, with setup instructions emailed in advance. Code runs and tests are provided. One candidate lost half an hour of the bug round to setup. reported
  • Language. Your choice. Several reports say C++ makes the repo rounds harder. reported
  • AI (changed in 2026). Bug Bash and Integration: no AI, but web search for syntax is fine. Nine 2026 reports describe a new AI-assisted coding round: about 60 min on HackerRank with a built-in AI chat, where you write your own tests. It is piloted in some loops only. reported

What each round tests

Section titled “What each round tests”

Coding. A realistic scenario at roughly LeetCode-medium level, growing in parts: basic version, then constraints, then optimisation. The early parts must compile and pass tests, and over-engineering is penalised. reported Reported families:

Family Study first
Rate limiter (token bucket or sliding window) Rate limiting, Sliding window
Messy financial or log data: parse, validate, aggregate Parsing, Input validation, Data aggregation
Currency conversion as a graph Graph representation, BFS, DFS
Masking card numbers in logs; simple IAM / permissions String handling, Permissions
Money and fees Money arithmetic, Reconciliation

Bug Bash. An unfamiliar, uncommented repo with 3-5 failing tests or bugs: edge cases, state handling, error handling, broken API flows. The bugs are “generic versions of real Stripe bugs.” Candidates’ advice: read the failing test, start where the error is thrown, form a hypothesis before you change anything, make the smallest fix, and say why the rest of the code is probably fine. reported Study Debugging and Testing.

Integration. Build against unfamiliar API docs or a private repo in 3-5 incremental tasks: HTTP calls, pagination, JSON, storage, reconciliation. Error handling is weighted heavily: retries on 429/503, timeouts, duplicate webhooks. Finishing only some of the tasks can still pass. reported Study Idempotency and Incremental requirements.

AI-assisted coding (2026 pilot). The most-reported task is a transaction rule engine: ordered accept/block rules, growing from equality checks, to AND/OR, to parentheses. You’re graded on designing the pieces yourself, catching the model’s mistakes, writing tests, and explaining your reasoning. One candidate was rejected for “insufficient explanation.” reported Study Expression evaluation.

System design. Reported prompts:

  • a double-entry ledger with idempotency
  • a rate limiter
  • feature flags with percentage rollout
  • webhook delivery with retries
  • metrics and monitoring
  • request routing

Raising idempotency and exactly-once concerns unprompted is called out as a strong signal. reported Study Ledgers, Idempotency and Event-driven design.

Behavioral. Scored against Stripe’s operating principles: users first; create with craft and beauty; move with urgency and focus; collaborate egolessly; stay curious; obsess over talent official. Expect ownership, pushing back, candour about failures, and a product-specific “why Stripe”. At Senior+ your scope must show: one candidate passed technically but was rejected because their answers “leaned too much toward execution.” reported

How you’re judged, and why people fail

Section titled “How you’re judged, and why people fail”

Code is read like a PR: readable, modular, edge cases handled, tests written. Interviewers write feedback independently, then a panel decides, and one weak round can sink the loop. reported

  1. LeetCode-only preparation, then freezing in a real codebase.
  2. Trial-and-error debugging in silence during Bug Bash.
  3. Losing time to environment setup.
  4. Ignoring failure modes: no retries, no idempotency, no handling of duplicates.
  5. Behavioral answers pitched below the target level.

Your plan

Section titled “Your plan”

Use the Sandbox’s Stripe filter for the coding rounds. The Sandbox is one file per problem, so practise the repo rounds locally (see below).

2 weeks 4 weeks
Week 1 Rate Limiter, Transaction Fees, Record Validator, Currency Converter, Idempotent Charges. Two Bug Bash drills. Set up and test your local environment The 2-week Week 1, plus Invoice Matcher and Bank
Week 2 Subscription Notifier, Expression Calculator (as a rule-engine warm-up; it’s outside the Stripe filter, under all problems), Payments Platform as a timed mock. One Integration drill. Two design sessions: ledger, webhooks. Map 6 stories to the operating principles Subscription Notifier, Sticky Load Balancer, Expression Calculator. Three Bug Bash drills
Week 3 Two Integration drills. Three design sessions: ledger, webhooks, feature flags. Read Stripe’s idempotency post and rate limiters post
Week 4 Payments Platform timed mock, one full mock loop, behavioral mocks against the principles

Bug Bash drill (local): check out an open-source library you’ve never read, at a commit just before a merged bug fix. Read the failing test from the fix PR, find the bug in 30 minutes, and narrate as you go. Integration drill: pick a public JSON API with pagination, and in 45 minutes write a client that pages through it, retries on 429/5xx with backoff, and de-duplicates records.

Ask your recruiter: Which rounds are in my loop: Bug Bash, Integration, AI coding, design? What is the setup for the local rounds, and can I test it beforehand? Which language and IDE?

Sources

Section titled “Sources”