← Stripe Interview Insights

Stripe·Software Engineer·Online Assessment (OA)·Intermediate

Intermediate
Jun 2026

Summary

Stripe SWE interview with a KYC verification coding problem. The question was more rules-heavy than algorithmically complex, which honestly threw me off a bit because I kept second-guessing the edge cases instead of just implementing the logic cleanly.

Questions Asked (1)

Q1

Given a list of business account records (each containing 6 KYC fields like business_name, business_full_name, and full_statement_descriptor) and a blocklist of generic descriptors, write a function that outputs VERIFIED or NOT_VERIFIED for each record. The rules are: all 6 fields must be present and non-empty, the full_statement_descriptor must be between 5 and 31 characters inclusive, it must not match any blocklist entry (case-insensitive), and at least 50% of the words in either business_name or business_full_name must appear in the full_statement_descriptor.

Algorithms & Data StructuresTechnical Trade-offsAPI & Integrations
Author's notes

The word overlap rule is where I lost time.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the requirements and edge cases, then outline a modular function that checks each rule in sequence, short-circuiting on failure. Discuss how to handle word matching (e.g., tokenization, case-insensitivity, partial matches) and the 50% threshold, and mention potential optimizations like pre-processing the blocklist into a set.

Pro tip: Emphasize the importance of normalizing inputs (e.g., trimming whitespace, lowercasing) before validation to avoid subtle bugs, and consider using a set for blocklist lookups to achieve O(1) time complexity.

1. Clarify requirements and edge cases

Ask questions to confirm details like what constitutes a 'word' (e.g., splitting on whitespace or punctuation), whether the 50% match is strict or inclusive, and how to handle special characters. This shows thoroughness and prevents misinterpretation.

2. Outline the validation logic

Describe a function that iterates over each record and applies the rules in order: check all fields present and non-empty, validate descriptor length, check blocklist, and finally compute word overlap. Explain that you would short-circuit to avoid unnecessary work.

3. Detail the word matching algorithm

Explain how to tokenize business_name and business_full_name into words, normalize case, and compute the percentage of words that appear in the full_statement_descriptor. Mention that you would consider either exact word matches or substring matches, and clarify the assumption.

4. Discuss efficiency and scalability

Mention that the blocklist should be stored in a set for O(1) lookups, and that the function should process records in a single pass. If needed, discuss how to handle large inputs with streaming or batch processing.

5. Test with examples and edge cases

Walk through a few examples, including a valid record, one with missing fields, one with a blocklisted descriptor, and one that barely meets the 50% threshold. This demonstrates correctness and attention to detail.

Key Points to Mention

  • Input normalization: trim whitespace, lowercase for case-insensitive comparisons.
  • Blocklist as a set for O(1) lookup and case-insensitive matching.
  • Tokenization strategy: split on whitespace and punctuation, handle empty tokens.
  • 50% threshold calculation: count matching words in either business_name or business_full_name, and ensure the denominator is the total words in that field.
  • Short-circuit evaluation to improve performance.
  • Edge cases: empty strings, descriptors exactly 5 or 31 characters, blocklist entries that are substrings.

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