Jobra
🐞Step 1 of Jobra:AI Debugging Rounds
DSA+AIPreparing you for both.
JOBRA Β· AI DEBUG ROUND (PREVIEW)sum.cpp
// buggy snippet
int total(vector<int>& a, int n) {
Β Β Β Β int sum = 0;
    for (int i = 0; i <= n; i++) { // 🐞        sum += a[i];
Β Β Β Β }
Β Β Β Β return sum;
}
A real codebase. A real bug. You + AI.

Jobra drops you into a broken repo. Find it, fix it, ship it. AI helps you debug like on the job.

Prompt:Correct the loop condition
Tap 'Let Jobra fix it' below to simulate AI debugging...

Stripe New-Grad Software Engineer Interview Guide

21 min read

Stripe new-grad software engineer interview guide: the OA, team screen and onsite with AI coding and integration rounds, from real candidate reports.

In this article
On this page

Editorial metadata (not part of the reader-facing article)

  • SEO title: Stripe New Grad Software Engineer Interview Guide
  • Meta description: Stripe new-grad software engineer interview guide: OA, technical screen, AI coding, integration and bug-squash rounds, with real candidate-reported questions.
  • Suggested slug: stripe-new-grad-software-engineer-interview-guide
  • Canonical URL: not confirmed β€” no publishing route was verified, so no canonical is asserted.
  • Status: DRAFT β€” several rounds fall short of the five-question minimum. See the completion checklist and coverage table at the end.

How to crack Stripe: The new-grad software engineer interview, from real experiences

Last reviewed November 17, 2026 Β· ~16 min read Β· For new-grad / early-career software engineers, mixed global locations

This guide was researched from candidate-reported Stripe new-grad accounts (labelled "2027 NG" in reports) published between August and October 2026, with carefully scoped external candidate accounts used only where the internal evidence was thin. It is an independent editorial draft, not an official Stripe publication, and no Stripe or Codinzhub team authorship is claimed. Reports are individual experiences, not a published company process. Your recruiter can confirm the current format, round count, and rules for your location.

The 30-second version. The reviewed new-grad accounts describe this order: apply (often by referral) β†’ online assessment (OA) β†’ technical screen / team screen β†’ virtual onsite (VO) whose rounds include AI coding, integration, and bug squash β†’ decision. The defining style is practical, multi-part implementation: long prompts, incremental requirements, hash maps, parsing, and state handling rather than classic LeetCode puzzles. Reports differ on exact round names and counts, and some rounds are described only as prep topics rather than confirmed interview questions. The single most useful habit is to write clean, modular code quickly and test each new requirement against the earlier ones.

Important things to know before the interview

  • Practical, multi-part coding, not a DSA sprint. Every assigned account describes long, scenario-based problems where each part adds a requirement. One candidate wrote that "doing more and more algorithm problems doesn't help much with this kind of thing." Model a small system; don't hunt for a trick. (state-machine OA, split-tender OA)

  • Reading and typing speed are part of the challenge. The 60-minute OAs describe "a lot of code to write" and racing the clock. Read the statement, examples, and constraints first; keep helper functions small so later parts are cheap to add.

  • Bug squash is a real risk, not the only factor. One 2026 account was rejected after the VO; a reviewed candidate called a weak bug round "a deal breaker" β€” an opinion, not company policy. Set up your debugger in advance.

  • AI coding is a named 2026 round where AI tools were permitted. Do not extend that permission to the OA, technical screen, or bug-squash round; confirm each stage with your recruiter.

  • Language choice: no verified new-grad restriction. A separate Stripe intern account (different role and level, not part of this guide's question evidence) reported a prep document ranking C/C++ below Java and JavaScript. That is not an established new-grad policy. Pick a language whose standard library you know well and confirm with your recruiter. (related experience)

What this guide covers

This guide is for Stripe's new-grad / early-career Software Engineer role ("2027 NG" in some reports). Geography is mixed and global: the assigned accounts do not all state a location, and external new-grad reports come from the US, Canada, Ireland, Romania, and India. The evidence window is 2025–2026, with the most detailed accounts published August–October 2026. Reports are individual experiences, not a published process; your recruiter can confirm the current format.

We reviewed five assigned Codinzhub records. Two are near-identical versions of the same candidate's timeline (same dates, referral, and rounds) and are counted as one experience. Where a round has fewer than five reported questions, we say so rather than inventing prompts. Practice problems are labelled as analogues and never presented as questions Stripe asked.

Round-by-round breakdown

Stage 1: Application, where candidates applied

The assigned new-grad accounts show a friend referral as the entry route: one candidate was referred on 3 September 2026 and received the OA the next day. The application date and hiring route for the other assigned accounts are not reported. External new-grad candidate accounts more often describe applying online and, less often, recruiter outreach or campus recruiting; those are outside the assigned evidence set and are recorded privately.

ChannelWhat candidates reported
Friend referralOne 2026 new-grad account (two published versions) got a referral from a friend and received the OA the following day.
Direct online applicationReported in external new-grad accounts, not in the assigned reports β€” scope noted in research notes.
Recruiter outreach / campusNot established for this role in the assigned reports.

At a glance: application channel β€” referral in the detailed account; screening criteria β€” not reported; time to OA β€” one day in that account.

Stage 2: Shortlisting, how candidates moved forward

Shortlisting in the reviewed account was automated: the OA was followed by an email from HR to schedule the technical screening. No rΓ©sumΓ©-screen criteria, GPA rule, or cutoff score is stated in the assigned reports. One candidate reported passing all OA test cases in about half an hour and still being invited forward; the same candidate's prep notes warn that all-test-cases-passed is not a guarantee of advancement β€” that is the candidate's opinion, not a published scoring rule.

StepWhat candidates reported
OA invitedSent by email shortly after referral/application.
OA result"All test cases passed in half an hour" in one account; no numeric score reported.
Next contactHR email to schedule the technical screening, roughly four days after the OA in one account.
Prep documentsNot reported for new grad in the assigned reports.

Stage 3: Online assessment (OA)

How it works. The online assessment (OA) is a timed coding test, usually on HackerRank: a browser editor with a prompt, sample inputs, and hidden test cases. Across the reviewed accounts it is one long, multi-part problem, not several unrelated algorithm questions β€” you process events or commands, keep state, and satisfy new rules in later parts. Choose a language you can write quickly.

At a glance

  • Duration: 60 minutes in the detailed accounts; one candidate finished in about 30 minutes.
  • Questions per round: one multi-part question in the assigned reports.
  • Topics: event/command processing, state transitions, hash maps, parsing, sorting and tie-break rules, money in integer cents.
  • Format: HackerRank or similar; camera/screen sharing reported in some external accounts, not confirmed in the assigned reports.

Reported questions. The table counts distinct main questions, not their parts or follow-ups. Rows marked "external" come from scoped new-grad candidate accounts recorded in the private research notes; no external URLs appear in this article.

Question summarySkill or patternReported follow-upLevel / scopeCodinzhub question or experience
"Split tender": process a chronological stream of gift-card, charge, and refund events; first deduct gift cards, then charge the credit card. Parts add expiration priority, ZIP-based surcharges, and refund routing.Event simulation, maps, sorting with tie-breaks, integer moneyFour parts; part 4 refunds create non-expiring gift cards used laterNew grad, location not reportedSplit-tender OA experience
Payment command state machine: implement CREATE / APPROVE / CAPTURE / CANCEL operations with fixed-width command arguments and valid state transitions; CANCEL voids anything not yet approved.State machine, object modelling, uniform parsing"Progressing through levels"; exact transitions from memory onlyNew grad, location not reportedState-machine OA experience
Four-step object-oriented design question solvable with a hash map and Dijkstra's algorithm; all parts had to be solved fast. (external, older, limited detail)OOP design, graph shortest pathNot reportedNew grad, 2024Plain text β€” external candidate report; see research notes
Single multi-subtask text-parsing question using basic dictionaries and text parsing. (external, limited detail)String parsing, dictionariesSubtasks unlocked in sequenceNew grad, BucharestPlain text β€” external candidate report; see research notes
One task with three subproblems that queried a dataset in a way similar to SQL joins and queries. (external, limited detail)Data querying, groupingThree subproblems in one taskNew grad, DublinPlain text β€” external candidate report; see research notes

Two new-grad accounts describe state-machine-style OAs. They are kept as distinct rows because the prompts differ, but they may come from the same question family; treat that as a caveat, not a confirmed match.

More questions. A verified Stripe practice record, design ledger and Bikemap integration, is available in the question bank. It is a system-design practice item, not a new-grad OA question that was reported to us.

Stage 4: Technical screen / team screen

How it works. The technical screen (or team screen) is a live 45–60 minute coding interview with an engineer. You share a screen or use a collaborative editor, talk through your approach, and solve a practical multi-part problem. External new-grad accounts say communication and code quality matter as much as finishing β€” candidate-reported, not official policy.

At a glance

  • Duration: not reported in the assigned technical-screen account; external new-grad accounts report 45–60 minutes.
  • Questions per round: two coding problems in the assigned first-round onsite account.
  • Topics: parsing, hash maps, amount/date matching, tie-break rules.
  • Format: live, interviewer present, hints reported in one account.

Reported questions.

Question summarySkill or patternReported follow-upLevel / scopeCodinzhub question or experience
Given an invoice ID embedded in a payment memo, match it against a list of invoices and output the result; print a not-found message when nothing matches.Parsing, hash map lookupHandle extra whitespace; O(n) approach described by candidateNew grad, "first-round onsite"Invoice-matching experience
Extend matching to two modes: use memo matching when the memo is in the standard format, otherwise match by payment amount and pick the earliest-due invoice when several share the amount.Incremental design, filtering, sorting by dateBuilt directly on the first problemNew grad, "first-round onsite"Invoice-matching experience
Practical multi-part string-parsing question where each part adds a requirement; focus on correctness, structure, and edge cases. (external, limited detail)Parsing, incremental designRequirements added each partNew grad, USPlain text β€” external candidate report; see research notes

The two invoice problems are listed separately because the source describes two coding problems, but the second explicitly extends the first. They share a scenario and should not be read as two unrelated questions.

Stage 5: Virtual onsite (VO)

How it works. The virtual onsite (VO) is a block of live remote interviews. The detailed 2026 account booked one day for AI coding and the next for Integration + Bug Squash, then was rejected two days later. External accounts describe a programming exercise plus integration and bug-squash rounds, sometimes with a manager conversation. Round names and counts vary, so treat any single sequence as one candidate's experience.

AI coding round

A multi-part practical round where an AI coding agent is allowed. The detailed account names the round but does not describe the prompt. External accounts describe checking rules against transactions. Confirm AI permission for this stage specifically. Duration and question count: not reported. No new-grad question content is established. Coverage shortfall: five questions.

Integration round

You work inside an existing codebase, read documentation, call an external library or service, parse responses, and add functionality without breaking what works. The detailed account's compiled materials list Bikemap, Payment Reconciliation, and Request Replay, while noting these are likely retired. These are prep topics, not confirmed questions asked, and are not counted. Coverage shortfall: five questions.

Bug-squash round

You get a repository, reproduce failing tests, locate a defect, and fix it while explaining your reasoning. Install and test your debugger before the call. The detailed account's compiled Python material names Mako, Requests, and Colander, and Java names Moshi; the described Requests defect is a POST body consumed on an HTTP 307 redirect, leaving an empty resent body with a non-zero content-length header and a timeout. These are prep notes, not confirmed questions. Coverage shortfall: five questions.

More questions for the VO. The verified Stripe question-bank record on ledger design and Bikemap integration can be used for practice. It is a system-design item, not a reported new-grad VO question.

Stage 6: Final decision

The detailed 2026 account was rejected on 15 October 2026, two days after the VO, with no feedback reported. External new-grad accounts mention a manager or "experience and goals" conversation, sometimes after the technical rounds, covering motivation, ownership, and career goals. No offer-stage details, compensation figures, or service-level timelines are established by the assigned reports, so none are stated here.

Stripe experiences shared on Codinzhub

College or backgroundRole and reported outcomeWhat was askedExperience
Not statedNew-grad Software Engineer (2027 NG), rejected after VOOA; technical screen; AI coding, integration and bug-squash VORejected after AI coding and integration + bug squash
Not statedNew-grad Software Engineer (2027 NG), rejected after VO β€” near-duplicate version of the account aboveSame timeline and compiled materialsPassed the tech screen, rejected after the VO
Not statedNew-grad Software Engineer, outcome not reportedFour-part split-tender OAFour-part split-tender online assessment
Not statedNew-grad Software Engineer, outcome not reported60-minute payment state-machine OAA 60-minute payment state-machine OA
Not statedNew-grad Software Engineer, outcome not reportedFirst-round onsite with two invoice-matching problemsFirst-round onsite, two invoice-matching problems

The Codinzhub next-round playbook

These are editorial recommendations informed by the reported demands, not claims that any action caused an offer.

To prepare for the OA

  1. Write complete programs under a clock. Use a 60-minute timer and a blank editor; the state-machine candidate said the main constraint was writing all the code.
  2. Read the full statement and every example first. Output format and tie-break rules are spread across parts; missing one changes the answer.
  3. Keep money in integer minor units. The split-tender examples use cents and state that surcharge calculations need no rounding.
  4. Write a helper per rule β€” one to parse an event, one to choose a card, one to format output β€” so later parts are additions, not rewrites.

To prepare for the technical screen

  1. Say your approach before you type; candidate accounts say communication and code quality matter as much as completion.
  2. Dry-run a not-found case and a tie case β€” a memo with no ID, two invoices with equal amounts, and extra whitespace.
  3. Preserve earlier behaviour when a part extends an old one; branch only for the new mode.

To prepare for the VO

  1. Set up your IDE, debugger, and plugins before the call β€” one reviewed account lost time to setup inside the round.
  2. For integration, practise reading docs and issuing HTTP requests in a small project that calls an API and handles errors.
  3. For bug squash, trace back from the failing test, form one hypothesis, change one thing, and explain each step aloud.
  4. For AI coding, say what you expect the agent to produce, then review and test its output.

Variations within this role

  • Location. Assigned accounts state no location. External new-grad reports describe the same practical style in the US, Canada, Ireland, Romania, and India, with 60-minute OAs common. Round counts and names differ, so do not assume one global sequence.
  • Hiring route. One detailed account entered by referral and got the OA in one day; other routes are not established for this role.
  • Interview year. The 2026 "2027 NG" accounts name an AI coding round absent from older reports. This may be a process change, but the evidence is too small to prove it.
  • Level boundary. This guide excludes questions from intern, SDE2, staff, and senior Stripe reports, even when they appear in the same source files.

Do's and don'ts

DoDon'tWhy it matters
Confirm the allowed language and whether AI tools are permitted for each stage with your recruiter.Assume an AI-coding permission carries over to the OA or bug-squash round.Permissions are stage-specific in the reports; generalising can cost you the round.
Write modular code with one helper per rule.Rewrite everything when a new part arrives.Later parts explicitly build on earlier ones.
Test empty input, duplicates, ties, and the "not found" case.Stop after the provided examples pass.Hidden tests in the OA and tie-break rules in the matching problems punish untested edges.
Read the whole prompt, including output format, before coding.Start typing after the first paragraph.The split-tender and state-machine prompts hide format details deep in the text.
Explain your reasoning and respond to hints.Go silent or ignore a suggestion.Candidate accounts say communication and code quality are heavily weighted.
Set up debugger, IDE, and libraries before the call.Install tools during the bug-squash round.Setup time is time you cannot spend finding the defect.
Prepare real stories with a situation, your action, an outcome, and what you learned.Rehearse invented achievements or a fixed answer pattern.The manager round asks about ownership, motivation, and feedback.

Most-asked topics

Priority below means "recurring in the reviewed new-grad accounts," not a measured frequency. No percentages are claimed.

TopicWhat it meansEvidence-backed priorityReported examplesCodinzhub practice
State machines and command processingModelling allowed transitions between states (e.g., created β†’ approved β†’ captured)RecurringPayment command OA; compiled integration materialsState-machine OA
Parsing structured inputSplitting strings or command lines into fields and handling missing positionsRecurringSplit-tender events; invoice memo parsing; text-parsing OA reportsInvoice-matching experience
Hash maps and lookupsStoring balances or invoices by ID for fast retrievalRecurringGift-card balances; invoice ID lookupSplit-tender OA
Sorting and tie-break rulesChoosing earliest expiry, earliest due date, or lexicographic IDRecurringExpiration priority; earliest-due invoiceInvoice-matching experience
Incremental multi-part designAdding requirements without breaking earlier partsRecurring across all assigned reportsSplit tender; invoice matching; state-machine levelsPractice bank record
Debugging unfamiliar codeFinding and fixing a defect against failing testsRecurring in VO reportsCompiled Requests / Mako / Colander bugsVO rejection account
Integration with external APIsReading docs, calling an API, parsing responsesRecurring in VO reports, not confirmed as a asked question in the assigned accountsCompiled Bikemap / reconciliation / request-replay materialPractice bank record
AI-assisted codingUsing an agent to implement and then verifying itNamed in 2026 accounts; question content not establishedAI coding round in the 2027 NG accountVO rejection account

The question patterns that keep coming back

The incremental, multi-part problem

You get Part 1, then each later part adds a rule: the split-tender OA adds expiry, surcharges, and refunds; invoice matching adds amount and forgiveness matching; the state-machine OA progresses through levels. The first part is a scaffold. Keep parsing, storage, and formatting in separate functions so a new rule touches one place. Practise by writing one problem as four explicit "parts" and re-running earlier cases after each change.

State modelling with explicit transitions

Commands arrive in order and only some transitions are legal. The state-machine OA lists CREATE, APPROVE, CAPTURE, and CANCEL with fixed-width arguments; CANCEL voids anything not yet approved. An illegal operation should be a no-op, not a crash. Store state per entity in a map and validate before mutating; unit-test every allowed and disallowed transition.

Matching with tie-break rules

A payment is matched by memo ID first, then by amount, then by amount within a tolerance, with ties going to the earliest-due invoice; gift cards are drained by earliest expiry, with lexicographic ID as a tie-break. This is a priority order, not one condition β€” encode it explicitly rather than relying on iteration order. Write the priority list as comments before you sort.

Money, ranges, and formatting

Amounts are integer cents; surcharges apply to the credit-card portion only; ZIP ranges map to rates; output strings list debited cards in a fixed order. Formatting is part of the specification β€” a correct calculation with the wrong string still fails. Copy the output schema into a comment and assert your formatted string against it for every example.

Debugging and integration in a real repository

The VO hands you existing code and a defect or an API to add. Compiled notes include a Requests POST body lost on a 307 redirect; integration notes describe reading docs and parsing responses. The skill is navigating someone else's code, not recalling an algorithm. Fork a small open-source library, break one test, and practise finding the cause with a debugger.

Preparing for the experience-and-goals / manager conversation

No behavioural questions are reported in the assigned accounts, so this is based on scoped external new-grad reports. Themes include "Why Stripe?", a complex project, ownership, trade-offs, collaboration, feedback, and AI use. Give one real story per theme: set the situation, name what you did, state the outcome, and reflect. STAR (Situation, Task, Action, Result) can keep you concise β€” but do not invent achievements or memorise a script. Expect follow-ups on why you made a technical decision and what impact it had.

Practice problems that match the experiences

These are practice analogues, chosen to exercise the same skills β€” they are not claims that Stripe asked these exact problems. Difficulty is the platform's own label where shown; we do not assign a difficulty to the custom reported questions.

#Practice problemPatternRelated reported question or variant
1Merge Intervals (LeetCode 56)Intervals / range handlingZIP-code surcharge ranges in the split-tender OA
2Design HashMap (LeetCode 706)Key-value storageGift-card balances and invoice-ID lookup
3Two Sum (LeetCode 1)Hash map lookupMatching a payment to an invoice by ID
4Group Anagrams (LeetCode 49)Grouping with a map keyAggregating transactions by user or card
5Decode String (LeetCode 394)String parsingSplit-tender token parsing, fixed-width command parsing
6Evaluate Reverse Polish Notation (LeetCode 150)Sequential command evaluationPayment command state machine
7Basic Calculator (LeetCode 224)Nested conditions / parenthesesCompound rule conditions in reported AI-coding material (different role; analogue only)
8Course Schedule (LeetCode 207)State / dependency modellingValid transition checks in the state-machine OA
9No verified practice match β€” build a small project that calls an external API, parses the response, and handles errorsAPI integrationIntegration round / Bikemap-style material
10No verified practice match β€” clone a small open-source repo, break one test, fix it with a debuggerDebuggingBug-squash round / Requests 307 material

How to handle a question you have never seen

  1. Clarify the problem and restate the examples. Ask what the inputs are, what a valid operation looks like, and what to return when nothing matches. Repeat one sample back in your own words.
  2. State an initial approach out loud. Even a brute-force version gives you something to improve and lets the interviewer correct a misunderstanding early.
  3. Identify the bottleneck. In these rounds the bottleneck is usually state handling or a tie-break rule, not asymptotic speed.
  4. Improve the approach. Replace a scan with a map, encode the priority order explicitly, and keep older parts working.
  5. Implement in small helpers. Write the parser, the state updater, and the formatter separately so each can be tested on its own.
  6. Test by hand. Dry-run an empty input, a single element, a duplicate, a tie, and the not-found case. Then run the provided examples.
  7. Handle follow-ups as new requirements. Ask whether old cases must still pass (in these reports, they usually do), then add the smallest branch that satisfies the new rule.

Why candidates were rejected

The detailed 2026 account reports rejection after the VO with no stated reason. No explicit recruiter feedback appears in the assigned reports, so no cause is asserted. Two outside cautions, with source type: one candidate's opinion that a weak bug-squash round can be decisive, and one external account that got generic "brush up on LeetCode" feedback. Both are individual reports, not company policy.

Common preparation mistakes (editorial advice)

  • Skipping boundary cases such as no match, equal amounts, or an empty event stream.
  • Rewriting earlier parts when a new requirement arrives, which breaks previously passing cases.
  • Treating the output string format as an afterthought.
  • Arriving with an unconfigured debugger and losing round time to setup.
  • Accepting AI-generated code without reading or testing it.

If you remember only five things

  1. Stripe's new-grad rounds are practical, multi-part implementation tasks β€” not classic algorithm puzzles.
  2. Read the whole prompt and copy the output format before you code; hidden details live in later parts.
  3. Keep earlier parts passing when a new rule arrives, and test ties and not-found cases yourself.
  4. Set up your IDE and debugger before the call; integration and bug squash reward navigating unfamiliar code.
  5. Confirm stage-specific rules β€” especially AI usage and allowed languages β€” with your recruiter; the reports do not establish a universal policy.

FAQ

Is the Stripe new-grad OA LeetCode-style?

Not in the reviewed accounts. It is one long, multi-part implementation problem using commands, parsing, state, and hash maps. Treat LeetCode practice as general fluency, not a question predictor. (State-machine OA)

How long is the OA, and how many questions?

Sixty minutes with one multi-part question in the detailed accounts; one candidate finished in about half an hour. Timing can vary by location, so confirm it in your invite.

What is a "bug squash" round?

A live debugging round: you get existing code and failing tests, find the defect, and fix it while explaining yourself. The reports name Mako, Requests, Colander, and Moshi in prep material but do not confirm which problem was asked.

Do new grads get a system design round?

None is reported in the assigned accounts. A Stripe system-design practice record exists in the question bank, but that is a practice item, not evidence new grads are asked it.

Which language should I use?

Choose the language whose standard library and debugger you know best; the accounts mention Java and Python. A different-role intern report mentioned a prep document ranking C/C++ below Java and JavaScript β€” not a new-grad rule, so confirm with your recruiter.

Does Stripe allow AI tools?

A 2026 new-grad account names an AI coding round where AI assistance was part of the exercise. No assigned report establishes AI permission for the OA, screen, or bug-squash round. Ask at each stage.

Are the rounds the same in every country?

The evidence does not support one answer. External new-grad reports describe a similar practical style but different round counts and names. Your recruiter can confirm your location's sequence.

About this guide

Researched from five assigned Codinzhub new-grad records plus scoped Reddit, Medium, Glassdoor, and other candidate accounts found through web search. The two near-identical "2027 NG" records were deduplicated into one experience. Questions were paraphrased faithfully; parts and follow-ups were not inflated, and analogues were never presented as reported questions. All searches and sources are in a separate, non-public research notes file; external research links are excluded from this article.

To report an error or add an account, use the PracHub interview-guide section or the experience pages above. Processes vary by team, year, and location; only Stripe and your recruiter can confirm the current format.

Other company and role guides

These are related Codinzhub guides for nearby roles and companies. They are separate guides, not part of this role's evidence. Each link was checked against the published site.

Editorial completion checklist

  • Separate guide for the exact role and level (new-grad / 2027 NG Software Engineer only)
  • Reddit research completed and recorded privately
  • External research expanded when internal experiences were limited (Medium, Glassdoor, plus scoped candidate sites)
  • At least five actual sourced questions per assessment/interview round β€” met for OA only; VO rounds have zero confirmed new-grad questions
  • Important company-specific findings checked and highlighted (practical multi-part style, speed, AI-round scope, language lead)
  • Application and shortlisting sections included
  • Do's and don'ts included
  • Most-asked topics and recurring patterns included
  • Matching practice problems included
  • Relevant question-bank practice links verified (LeetCode problem pages and one PracHub record)
  • SEO metadata and beginner readability reviewed
  • Contextual Codinzhub links and related guides verified β€” includes the verified same-company Stripe Software Engineer guide; no separate new-grad Stripe guide was found
  • External research/resource links excluded from the public article
  • No calendar-based study plan included
  • Remaining gaps documented and draft/completion status accurate β€” guide marked DRAFT
RoundDistinct reported questionsMinimum five metRemaining gap
Online assessment (OA)5Yes (3 rows are low-detail external reports)None, but confidence is limited
Technical screen / team screen3No2 more distinct questions needed
VO β€” AI coding0No5 questions β€” round named, prompt not reported for new grad
VO β€” Integration0No5 questions β€” only compiled prep material, likely retired
VO β€” Bug squash0No5 questions β€” only compiled prep material, not confirmed asked
Manager / behavioural4No1 more distinct question; all from scoped external accounts

Keep preparing on Codinzhub

Search the question bank

The questions from each round above, with practice links for similar problems. Log in to search every question we collected for this role, including questions shared on Codinzhub.

Showing 20 of 32 questions

  • "Split tender": process a chronological stream of gift-card, charge, and refund events; first deduct gift cards, then charge the credit card. Parts add expiration priority, ZIP-based surcharges, and refund routing.

    Level: Four parts; part 4 refunds create non-expiring gift cards used later.

    Event simulation, maps, sorting with tie-breaks, integer moneyCodingOnline assessment
  • Payment command state machine: implement CREATE / APPROVE / CAPTURE / CANCEL operations with fixed-width command arguments and valid state transitions; CANCEL voids anything not yet approved.

    Level: "Progressing through levels"; exact transitions from memory only.

    State machine, object modelling, uniform parsingCodingOnline assessment
  • Four-step object-oriented design question solvable with a hash map and Dijkstra's algorithm; all parts had to be solved fast. (external, older, limited detail)

    Level: Not reported.

    OOP design, graph shortest pathCodingOnline assessment
  • Single multi-subtask text-parsing question using basic dictionaries and text parsing. (external, limited detail)

    Level: Subtasks unlocked in sequence.

    String parsing, dictionariesCodingOnline assessment
  • One task with three subproblems that queried a dataset in a way similar to SQL joins and queries. (external, limited detail)

    Level: Three subproblems in one task.

    Data querying, groupingCodingOnline assessment
  • Given an invoice ID embedded in a payment memo, match it against a list of invoices and output the result; print a not-found message when nothing matches.

    Level: Handle extra whitespace; O(n) approach described by candidate.

    Parsing, hash map lookupCodingPhone or technical screen
  • Extend matching to two modes: use memo matching when the memo is in the standard format, otherwise match by payment amount and pick the earliest-due invoice when several share the amount.

    Level: Built directly on the first problem.

    Incremental design, filtering, sorting by dateCodingPhone or technical screen
  • Practical multi-part string-parsing question where each part adds a requirement; focus on correctness, structure, and edge cases. (external, limited detail)

    Level: Requirements added each part.

    Parsing, incremental designCodingPhone or technical screen
  • State machines and command processing

    Level: Recurring.

    Modelling allowed transitions between states (e.g., created β†’ approved β†’ captured)CodingRound not stated
  • Parsing structured input

    Level: Recurring.

    Splitting strings or command lines into fields and handling missing positionsCodingRound not stated
  • Hash maps and lookups

    Level: Recurring.

    Storing balances or invoices by ID for fast retrievalCodingRound not stated
  • Sorting and tie-break rules

    Level: Recurring.

    Choosing earliest expiry, earliest due date, or lexicographic IDCodingRound not stated
  • Incremental multi-part design

    Level: Recurring across all assigned reports.

    Adding requirements without breaking earlier partsCodingRound not stated
  • Debugging unfamiliar code

    Level: Recurring in VO reports.

    Finding and fixing a defect against failing testsCodingRound not stated
  • Integration with external APIs

    Level: Recurring in VO reports, not confirmed as a asked question in the assigned accounts.

    Reading docs, calling an API, parsing responsesCodingRound not stated
  • AI-assisted coding

    Level: Named in 2026 accounts; question content not established.

    Using an agent to implement and then verifying itCodingRound not stated
  • 1

    Level: Intervals / range handling.

    Merge Intervals (LeetCode 56)CodingRound not stated
  • 2

    Level: Key-value storage.

    Design HashMap (LeetCode 706)CodingRound not stated
  • 3

    Level: Hash map lookup.

    Two Sum (LeetCode 1)CodingRound not stated
  • 4

    Level: Grouping with a map key.

    Group Anagrams (LeetCode 49)CodingRound not stated
Page 1 of 2
Ready for the next topic?

Keep track of what you’ve learned.