Stripe SWE OA Pass Guide 2026: Transaction Logs + Email Normalization + Sliding Window Rate Limiter

Stripe SWE OA is the most "day-to-day work" style assessment among top fintech firms: problem statements read like PRDs, inputs look like production logs, and what's expected is code you'd happily sign off on in a review. Algorithm complexity rarely traps you—but if you skip one boundary case or pick sloppy variable names, hidden tests silently dock you. This article unpacks three of Stripe's 2026 highest-frequency SWE OA problems—Transaction Log Balancing, Email Normalization, and Sliding Window Rate Limiter—with full Python solutions and Stripe-rubric-aware writing tips.

Stripe SWE OA Overview

Dimension	Detail
Platform	HackerRank for Work
Duration	90-120 minutes
Question count	2-3 problems, some split into 4 parts
Difficulty	LeetCode Easy~Medium, but boundary-heavy
Hidden tests	12-20
Scoring axes	Correctness / Readability / Boundaries / Modularity

Problem 1: Transaction Log Balancing

Description

Given a list of payment logs in the format:

"{user_id} {event_type} {amount}"

event_type is credit (deposit) or debit (withdrawal); amount is an integer. Return the final balance per user.

Input:

logs = [
    "alice credit 100",
    "bob debit 50",
    "alice debit 30",
    "bob credit 20",
]

Output: {"alice": 70, "bob": -30}

Approach

The challenge isn't the algorithm—it's parsing + dictionary aggregation. Stripe's hidden tests hit:

amount = 0 logs
Alternating credit/debit for one user
Mixed-case event_type (e.g., Credit, CREDIT)
Extra whitespace in lines

Python Solution

from collections import defaultdict
from typing import Dict, List

def compute_balances(logs: List[str]) -> Dict[str, int]:
    balances: Dict[str, int] = defaultdict(int)
    for line in logs:
        parts = line.strip().split()
        if len(parts) != 3:
            continue
        user_id, event_type, amount_str = parts
        amount = int(amount_str)
        event = event_type.lower()
        if event == "credit":
            balances[user_id] += amount
        elif event == "debit":
            balances[user_id] -= amount
    return dict(balances)

Time: O(n), n = number of logs
Space: O(u), u = unique users

Stripe Scoring Notes

defaultdict(int) removes a redundant if user_id not in balances branch—Stripe prefers fewer branches
event_type.lower() is the single most common hidden-test failure
Type hints earn readability points

Problem 2: Email Normalization

Description

Implement Stripe's email normalization rules:

Ignore all . characters in the local part (before @)
Ignore everything after + in the local part
Keep the domain (after @) unchanged

Determine whether two emails are equivalent under these rules.

Example:

e1 = "[email protected]"
e2 = "[email protected]"
# True

Python Solution

def normalize(email: str) -> str:
    local, _, domain = email.strip().lower().partition("@")
    local = local.split("+", 1)[0].replace(".", "")
    return f"{local}@{domain}"

def are_same_email(e1: str, e2: str) -> bool:
    return normalize(e1) == normalize(e2)

Time: O(L) per email
Space: O(L)

Stripe Scoring Notes

.strip() and .lower() are mandatory; without them, the case " [email protected] " fails
partition("@") is safer than split("@")—the latter raises on missing @, while partition returns an empty domain
Splitting out normalize is a hard Stripe code-review rubric: single responsibility + unit-testable

Problem 3: Sliding Window Rate Limiter

Description

Simulate Stripe's API rate limiting: a user can issue at most 3 requests in any 10-second sliding window.

Input: sorted timestamps (seconds).
Output: a boolean array indicating whether each request is accepted.

Example:

requests = [1, 2, 3, 4, 11, 12]
# Output: [True, True, True, False, True, True]

Python Solution

from collections import deque
from typing import List

def rate_limiter(
    requests: List[int],
    window_size: int = 10,
    max_requests: int = 3,
) -> List[bool]:
    q: deque = deque()
    results: List[bool] = []
    for t in requests:
        while q and q[0] <= t - window_size:
            q.popleft()
        if len(q) < max_requests:
            q.append(t)
            results.append(True)
        else:
            results.append(False)
    return results

Time: O(n) amortized
Space: O(max_requests)

Stripe Scoring Notes

Use deque, not list—list.pop(0) is O(n) and fails large hidden cases
The window check is strict: q[0] <= t - window_size, not <
Parameterize window_size and max_requests so Part 2 ("per-user window") is a one-line extension

Three Hidden Rubric Axes

1) Readability (35%)

Stripe's internal code-review culture is famously strict. The closer your OA code looks to production, the higher your score:

Names: compute_balances, not solve or func1
Single responsibility: separate normalize/compare functions
Explicit type hints

2) Boundary Coverage (40%)

About 60% of Stripe hidden tests target edges:

Empty inputs: [], ""
Malformed strings: missing fields, extra spaces, mixed case
Numeric edges: amount=0, large timestamps

3) Correctness (25%)

Correctness has the smallest weight—Stripe's problem statements make the main flow easy to write. The trap is getting the main flow right but failing on formatting.

FAQ

What's the Stripe SWE OA pass rate?

Around 35-40%. The dominant failure mode is "right idea, wrong code"—usually around case sensitivity or whitespace. Re-check strip/lower/split before submitting.

Same HackerRank platform as other companies?

Yes, HackerRank for Work—but Stripe disables the "run example" feature. You must self-test with your own asserts. Always run a full boundary set locally before submitting.

How algorithmically hard is the Stripe OA?

Not very. The ceiling is LeetCode Medium, often Easy. But problems are long—Stripe likes 4 progressive parts in one problem; clean execution on parts 1-2 already nets 70%+.

Can I use Python? Should I write type hints?

Yes—Python / Java / Go / Ruby / TypeScript are all allowed. Type hints aren't required but earn readability points. Stripe's codebase uses mypy heavily, and graders are biased toward typed Python.

What's the interview path after OA?

OA → Recruiter Phone Screen → 4-5 VO rounds (Integration, Debug, Pair Coding, System Design, Behavioral). The cycle is slower than Meta/Google—usually 3-5 weeks from OA to onsite.

Preparing for the Stripe SWE OA?

oavoservice offers end-to-end Stripe SWE/SDE OA support: problem decomposition, boundary case checklists, real-time HackerRank assistance. We maintain full breakdowns of Stripe's BIN range, payment reconciliation, and subscription billing problems, and can tailor practice plans to your target role (NG / Intern / L4).

Add WeChat Coding0201 to get 1-on-1 Stripe OA coaching.

#Stripe #StripeOA #SWE #SDE #PaymentSystem #OARealQuestions

Contact

Email: [email protected]
Telegram: @OAVOProxy