# Plaid Interview Guide 2026: Fintech Infrastructure, Transaction Categorization, and Open Banking

Source: https://www.techinterview.org/post/3233460313/plaid-interview-guide-2026-fintech-infrastructure-transaction-categorization-and-open-banking/
Updated: 2026-04-16 · techinterview.org

## Plaid Interview Guide 2026: Fintech Infrastructure, Financial Data, and Open Banking

Plaid powers the financial data layer for 8,000+ apps including Venmo, Robinhood, Coinbase, and SoFi. They connect 12,000+ financial institutions to developer-friendly APIs. Engineering at Plaid means building resilient, compliant data pipelines for mission-critical financial data. This guide covers SWE and data engineering interviews.

## The Plaid Interview Process

- **Recruiter screen** (30 min) — background, fintech interest, compliance awareness

- **Technical screen** (1 hour) — 1–2 coding problems with discussion

- **Onsite** (4–5 rounds):

  2× coding (algorithms + practical data processing problems)

  - 1× system design (financial data pipeline, fraud detection, or bank integration)

  - 1× domain depth (fintech regulations, OAuth flows, data reliability)

  - 1× behavioral / Plaid values

Plaid interviews unique to fintech: expect questions about financial data formats (OFX, ISO 8583, ACH), bank connection reliability, and regulatory compliance (PCI DSS, SOC 2, CCPA).

## Core Technical Domain: Financial Data Processing

### Transaction Categorization Pipeline


```
import re
from typing import Dict, List, Optional, Tuple
from collections import defaultdict

class TransactionCategorizer:
    """
    Rule-based + ML hybrid transaction categorization.
    Plaid categorizes 100M+ daily transactions across 12K+ institutions.

    Each bank formats transactions differently:
    - Chase: "AMAZON.COM*MK1234 AMAZON.COM WA"
    - Bank of America: "AMAZON PRIME*MK1234"
    - Wells Fargo: "AMZN MKTP US*MK1234 WA"

    Challenges:
    - 12K+ institution-specific merchant name formats
    - Ambiguous merchants (e.g., "TARGET" could be grocery or clothing)
    - Recurring subscriptions vs one-time purchases
    - Multi-currency, international transactions
    """

    CATEGORIES = {
        'FOOD_AND_DRINK': ['MCDONALD', 'STARBUCKS', 'DOORDASH', 'GRUBHUB',
                           'UBEREATS', 'CHIPOTLE', 'SUBWAY', 'PIZZA'],
        'TRAVEL': ['DELTA', 'UNITED', 'AMERICAN AIRLINES', 'MARRIOTT',
                   'HILTON', 'AIRBNB', 'UBER', 'LYFT'],
        'SHOPPING': ['AMAZON', 'WALMART', 'TARGET', 'COSTCO', 'EBAY', 'ETSY'],
        'ENTERTAINMENT': ['NETFLIX', 'SPOTIFY', 'HULU', 'HBO', 'DISNEY',
                          'STEAM', 'PLAYSTATION', 'XBOX'],
        'UTILITIES': ['AT&T', 'VERIZON', 'COMCAST', 'PG&E', 'CONEDISON'],
        'HEALTHCARE': ['CVS', 'WALGREENS', 'KAISER', 'OPTUM', 'CIGNA'],
        'FINANCIAL': ['CHASE', 'WELLS FARGO', 'BANK OF AMERICA', 'VENMO',
                      'ZELLE', 'PAYPAL', 'COINBASE', 'ROBINHOOD'],
    }

    def __init__(self):
        # Build reverse lookup: merchant keyword -> category
        self.keyword_to_category = {}
        for category, keywords in self.CATEGORIES.items():
            for kw in keywords:
                self.keyword_to_category[kw] = category

        # ML-predicted categories from training data (simplified)
        self.learned_merchants: Dict[str, str] = {}

    def normalize_merchant(self, raw_name: str) -> str:
        """
        Clean bank-specific formatting from merchant names.

        Rules:
        1. Remove transaction IDs (alphanumeric sequences)
        2. Remove state abbreviations
        3. Strip asterisks, extra spaces
        4. Uppercase for matching
        """
        name = raw_name.upper()
        # Remove transaction codes like *MK1234 or #12345
        name = re.sub(r'[*#][A-Z0-9]+', '', name)
        # Remove state codes (2 uppercase letters at end)
        name = re.sub(r'b[A-Z]{2}b$', '', name)
        # Remove extra whitespace
        name = ' '.join(name.split())
        return name

    def categorize(self, raw_merchant: str, amount: float,
                   merchant_category_code: Optional[str] = None) -> Tuple[str, float]:
        """
        Categorize a transaction.
        Returns: (category, confidence)

        Priority:
        1. MCC code (authoritative when available)
        2. Exact merchant match from learned database
        3. Keyword matching (rule-based)
        4. Default to UNCATEGORIZED
        """
        # 1. MCC-based categorization (Merchant Category Codes from Visa/Mastercard)
        if merchant_category_code:
            mcc_category = self._mcc_to_category(merchant_category_code)
            if mcc_category:
                return (mcc_category, 0.95)

        normalized = self.normalize_merchant(raw_merchant)

        # 2. Learned merchant database
        if normalized in self.learned_merchants:
            return (self.learned_merchants[normalized], 0.90)

        # 3. Keyword matching
        for keyword, category in self.keyword_to_category.items():
            if keyword in normalized:
                return (category, 0.75)

        # 4. Detect recurring subscription pattern
        if amount in [9.99, 14.99, 19.99, 4.99, 12.99]:
            return ('SUBSCRIPTION', 0.50)

        return ('UNCATEGORIZED', 0.0)

    def _mcc_to_category(self, mcc: str) -> Optional[str]:
        """Map Merchant Category Code to Plaid category."""
        mcc_map = {
            '5411': 'FOOD_AND_DRINK',  # Grocery Stores
            '5812': 'FOOD_AND_DRINK',  # Eating Places, Restaurants
            '5912': 'HEALTHCARE',       # Drug Stores and Pharmacies
            '4511': 'TRAVEL',           # Air Carriers, Airlines
            '7011': 'TRAVEL',           # Hotels and Motels
            '5999': 'SHOPPING',         # Miscellaneous Retail
        }
        return mcc_map.get(mcc)


class RecurringTransactionDetector:
    """
    Detect recurring payments (subscriptions, rent, utilities).

    Key signals:
    - Same merchant, similar amount, regular time interval
    - Amount stable within ±5% (subscription) or exact (insurance)
    - Interval: weekly (7±1 days), biweekly (14±2), monthly (28-31 days)
    """

    def detect_recurring(
        self,
        transactions: List[Dict],  # [{merchant, amount, date}]
        tolerance_pct: float = 0.05
    ) -> List[Dict]:
        """
        Group transactions by merchant and identify recurring patterns.

        Time: O(T log T) for sorting + O(T) for analysis
        """
        by_merchant = defaultdict(list)
        for txn in transactions:
            by_merchant[txn['merchant']].append(txn)

        recurring = []
        for merchant, txns in by_merchant.items():
            if len(txns) < 2:
                continue

            txns_sorted = sorted(txns, key=lambda t: t['date'])
            amounts = [t['amount'] for t in txns_sorted]
            dates = [t['date'] for t in txns_sorted]

            # Check amount stability
            avg_amount = sum(amounts) / len(amounts)
            amount_stable = all(
                abs(a - avg_amount) / avg_amount <= tolerance_pct
                for a in amounts
            )

            if not amount_stable:
                continue

            # Check interval regularity
            intervals = [(dates[i+1] - dates[i]).days
                        for i in range(len(dates) - 1)]

            avg_interval = sum(intervals) / len(intervals)
            interval_stable = all(
                abs(iv - avg_interval) = 3:
                recurring.append({
                    'merchant': merchant,
                    'avg_amount': avg_amount,
                    'avg_interval_days': avg_interval,
                    'transaction_count': len(txns),
                    'detected_pattern': self._classify_interval(avg_interval),
                })

        return recurring

    def _classify_interval(self, days: float) -> str:
        if abs(days - 7) <= 1:
            return 'weekly'
        elif abs(days - 14) <= 2:
            return 'biweekly'
        elif 28 <= days <= 31:
            return 'monthly'
        elif 85 <= days <= 95:
            return 'quarterly'
        elif 355 <= days <= 375:
            return 'annual'
        return f'every_{int(days)}_days'
```


## System Design: Open Banking API

Common Plaid question: *"Design Plaid's bank connection and data sync infrastructure."*


```
"""
Plaid's Architecture:

Developer App ? [Plaid API] ? [Bank Integration Layer] ? Bank

Bank Integration Layer:
1. Direct API integrations (Major banks: Chase, BofA, Wells Fargo)
   - Official APIs (Open Banking / PSD2 in Europe)
   - Proprietary bank APIs (negotiated partnerships)
2. Screen scraping (smaller banks with no API)
   - Headless browser automation
   - TOTP/SMS OTP handling
   - Fragile but covers 12K+ institutions

Data Flow:
Bank raw data ? [Parser] ? [Normalizer] ? [Enricher] ? [Storage]

Each bank has different:
- Authentication flows (username/password, MFA, OAuth)
- Data formats (JSON, OFX, CSV, HTML screen scraped)
- Account types (checking, savings, investment, credit)
- Field names (transaction_date vs posted_date vs date_settled)

Key reliability challenges:
- Banks change their websites/APIs without notice ? parsing breaks
- MFA prompts require user interaction ? webhook + retry
- Rate limiting from banks ? queue and throttle
- Data freshness SLAs: transactions available within 24h for most banks

Security requirements (all mandatory for Plaid):
- SOC 2 Type II certified
- PCI DSS Level 1 (handles cardholder data)
- CCPA/GDPR compliant (user can delete all their data)
- End-to-end encryption; bank credentials never stored (OAuth preferred)
"""
```


## Behavioral Questions at Plaid

- **"How have you handled a reliability incident in a financial context?"** — Plaid's data is mission-critical; show incident response maturity

- **User trust**: Plaid handles sensitive financial credentials; show understanding of trust as a competitive moat

- **Regulatory awareness**: Know PSD2, Open Banking, CFPB Section 1033 — shows domain depth

- **Product empathy**: Understand that developers are Plaid's customers, but end users are affected by reliability

## Compensation (US, 2025 data)

| Level | Base | Total Comp |
| --- | --- | --- |
| SWE II | $165–195K | $220–290K |
| Senior SWE | $195–235K | $290–390K |
| Staff SWE | $235–275K | $390–530K |

*Plaid is Series D (2021), valued at $13.4B. Strong revenue; IPO expected. Equity meaningful if company goes public at or above last valuation.*

## Interview Tips

- **Know financial data formats**: OFX, QIF, ISO 8583, ACH — shows domain seriousness

- **Resilient system design**: Financial systems can't lose data; idempotency, exactly-once semantics, reconciliation

- **Use Plaid Link**: Connect a test bank account via developer sandbox; understand the user flow

- **Compliance awareness**: Be able to discuss GDPR data deletion, PCI DSS tokenization at a high level

- **LeetCode**: Medium difficulty; string parsing and data transformation problems common

*Practice problems: LeetCode 844 (Backspace String Compare), 937 (Reorder Data in Log Files), 76 (Minimum Window Substring), 1647 (Minimum Deletions to Make Character Frequencies Unique).*

## Related System Design Interview Questions

Practice these system design problems that appear in Plaid  interviews:

- [Design a Payment System](https://www.techinterview.org/post/3233463538/system-design-payment-system/)

- [Design a Stock Trading Platform](https://www.techinterview.org/post/3233460053/design-a-stock-trading-platform/)

## Related Company Interview Guides

- [Datadog Interview Guide 2026: Metrics, Monitoring Systems, and On-Call Culture](https://www.techinterview.org/post/3233460269/datadog-interview-guide-2026-metrics-monitoring-systems-and-on-call-culture/)

- [Cloudflare Interview Guide 2026: Networking, Edge Computing, and CDN Design](https://www.techinterview.org/post/3233460270/cloudflare-interview-guide-2026-networking-edge-computing-and-cdn-design/)

- [Lyft Interview Guide 2026: Rideshare Engineering, Real-Time Dispatch, and Safety Systems](https://www.techinterview.org/post/3233460306/lyft-interview-guide-2026-rideshare-engineering-real-time-dispatch-and-safety-systems/)

- [Vercel Interview Guide 2026: Edge Computing, Next.js Infrastructure, and Frontend Performance](https://www.techinterview.org/post/3233460276/vercel-interview-guide-2026-edge-computing-next-js-infrastructure-and-frontend-performance/)

- [Palantir Interview Guide 2026: Decomp Problems, Knowledge Graphs, and Data Platform Engineering](https://www.techinterview.org/post/3233460303/palantir-interview-guide-2026-decomp-problems-knowledge-graphs-and-data-platform-engineering/)

- [Snowflake Interview Guide 2026: Cloud Data Warehouse, Query Engines, and Distributed SQL](https://www.techinterview.org/post/3233460304/snowflake-interview-guide-2026-cloud-data-warehouse-query-engines-and-distributed-sql/)

- [System Design: E-Commerce Platform (Amazon)](/post/3233460828/system-design-ecommerce/)

- [System Design: Fraud Detection System](/post/3233460837/system-design-fraud-detection/)

- [System Design: Secret Management and PKI](/post/3233460966/system-design-secret-management/)

- [System Design: API Rate Limiting and Throttling](/post/3233460984/system-design-rate-limiting/)

- [System Design: Financial Exchange and Matching Engine](/post/3233461035/system-design-financial-exchange/)

*Explore all our [company interview guides](https://www.techinterview.org/category/company-guides/) covering FAANG, startups, and high-growth tech companies.*

- [System Design: Payment Processing System (Stripe / PayPal)](https://techinterview.org/system-design-payment-processing/)

- [System Design: Event Sourcing and CQRS](https://techinterview.org/system-design-event-sourcing-cqrs/)

## Related System Design Topics

- [System Design: Distributed Transactions and Saga Pattern](https://techinterview.org/system-design-distributed-transactions-saga/)