Stripe·Software Engineer·Onsite - Coding / Algorithms·Intermediate

Intermediate

May 2026

Summary

Stripe's onsite loop now includes an AI Programming Exercise round where you're expected to use an embedded AI assistant to solve a multi-part transaction rules parsing problem in about 30 minutes. The whole thing felt less like a coding test and more like a test of whether you can actually direct an AI without just rubber-stamping whatever it produces.

Questions Asked (1)

Given a list of transactions and a set of rules (each rule specifies accept or block, plus a conditional expression), parse the rules and evaluate whether each transaction matches. Later parts introduce boolean logic like AND/OR conditions.

Algorithms & Data StructuresTechnical Trade-offsAdaptability & Ambiguity

Author's notes

The first parts are fine, mostly string matching, but then it compounds and if you haven't read the README carefully you start making wrong assumptions.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the rule syntax and transaction schema, then design a parser that builds an AST for conditions. Implement an evaluator that traverses the AST, supporting boolean operators with short-circuit evaluation, and discuss extensibility for future rule types.

Pro tip: Mention that you'd use a recursive descent parser for conditions and a visitor pattern for evaluation, which makes adding new operators easy. Also, emphasize the importance of short-circuit evaluation for performance and correctness.

1. Clarify Requirements and Edge Cases

Ask about the rule format, transaction fields, and expected behavior for missing fields or invalid rules. Confirm whether rules are evaluated in order and if multiple matches are possible.

2. Design the Parser

Define a grammar for conditions (e.g., field operator value, with AND/OR and parentheses). Implement a tokenizer and recursive descent parser to produce an abstract syntax tree (AST).

3. Implement the Evaluator

Write a function that takes a transaction and an AST, recursively evaluates nodes, and returns a boolean. Use short-circuit evaluation for AND/OR to optimize and avoid errors.

4. Integrate with Transaction Processing

Iterate over transactions and rules, applying the evaluator. Determine the final action (accept/block) based on rule matches, considering priority or first-match semantics.

5. Discuss Extensibility and Trade-offs

Talk about how to add new operators (e.g., NOT, comparison operators) and the trade-offs between a simple interpreter and a compiled approach. Mention testing strategies.

Key Points to Mention

Use of recursive descent parsing for boolean expressions with proper operator precedence.
Short-circuit evaluation for AND/OR to improve performance and handle null values safely.
Design patterns like Visitor or Interpreter for evaluating the AST.
Handling of missing fields or type mismatches in transactions (e.g., default values or errors).
Rule priority and conflict resolution (e.g., first-match vs. most-specific match).
Extensibility: how to add new operators or rule types without major refactoring.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.