← Plaid Interview Insights

Plaid·Frontend Engineer·Onsite - System Design / Architecture·Senior

SeniorPrefer not to say
May 2026

Summary

System design round at Plaid for a frontend engineer role. The question was essentially 'build Plaid' which sounds flattering until you realize how much surface area that actually covers and how easy it is to spend 20 minutes on the iframe stuff and never get to token encryption.

Questions Asked (5)

Q1

Design a third-party embeddable widget (similar to Plaid Link) that lets users connect their bank accounts to a partner app. Walk through the iframe embed model, the API surface, OAuth and credential flows, the data model, security, and backend storage.

System DesignAPI & IntegrationsTechnical Trade-offs
Author's notes

This question is basically six questions stapled together and they let you find that out the hard way.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the scope and constraints, then walk through the high-level architecture before diving into each component. Focus on the frontend engineer's perspective: how the iframe embed works, the API surface for communication, and security considerations like OAuth and credential handling.

Pro tip: Emphasize the importance of a seamless user experience and security—highlight how the iframe isolates sensitive data and how postMessage communication is secured with origin checks and token validation.

1. Clarify requirements and constraints

Ask questions to understand the partner app's needs, supported banks, regulatory requirements, and expected scale. Define the widget's responsibilities vs. the partner's.

2. Design the iframe embed model

Explain how the widget is embedded via an iframe, the communication between parent and iframe using postMessage, and how to handle sizing, responsiveness, and cross-origin security.

3. Define the API surface and OAuth flow

Outline the public API for partners (initialization, callbacks), the OAuth 2.0 flow for bank authentication, and how credentials are securely transmitted and stored.

4. Detail the data model and backend storage

Describe the data entities (users, items, accounts, transactions), how sensitive data is encrypted at rest, and the backend services for token exchange and storage.

5. Address security and trade-offs

Discuss security measures like CSRF protection, token scoping, iframe sandboxing, and trade-offs between security, usability, and performance.

Key Points to Mention

  • Iframe sandboxing and postMessage with origin validation
  • OAuth 2.0 authorization code flow with PKCE for bank authentication
  • Tokenization and secure storage of access tokens (never in localStorage)
  • Data encryption at rest and in transit (TLS, AES-256)
  • API design: initialization options, event callbacks (onSuccess, onExit), and error handling
  • Trade-offs: iframe vs. Web Components, polling vs. webhooks for status updates

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

Q2

How would you handle MFA and step-up authentication within the bank credential flow, specifically inside an embedded iframe context?

System DesignTechnical Trade-offs
Author's notes

Blanked for a second here.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the constraints of the embedded iframe context (e.g., third-party cookie restrictions, cross-origin communication, and security policies) and then walk through a layered authentication flow that balances security with user experience. Emphasize how you would design the MFA and step-up challenges to be resilient to iframe limitations, using postMessage or redirect-based fallbacks, and discuss trade-offs between friction and risk.

Pro tip: Highlight the importance of aligning with the bank's existing authentication infrastructure and regulatory requirements (e.g., PSD2 SCA) while ensuring the iframe integration doesn't break the user flow—demonstrating awareness of both technical and compliance aspects will set you apart.

1. Clarify constraints and requirements

Ask about the iframe's origin, allowed permissions, and whether the bank's MFA methods (e.g., OTP, biometrics) can be rendered inside the iframe or require a top-level redirect. Confirm regulatory and security requirements early.

2. Design the authentication flow

Outline a flow where initial authentication happens, and step-up is triggered based on risk signals (e.g., transaction amount, device). Describe how MFA challenges are presented—either natively in the iframe or via a secure popup/redirect—and how results are communicated back.

3. Address iframe-specific challenges

Discuss handling cross-origin communication (postMessage with origin validation), third-party cookie blocking (using storage access API or token-based approaches), and fallback mechanisms if iframe embedding is restricted.

4. Ensure security and compliance

Explain how to prevent clickjacking (frame-ancestors CSP), secure data transmission, and comply with standards like OAuth 2.0 for embedded flows. Mention token handling and session management.

5. Discuss trade-offs and edge cases

Compare approaches (e.g., iframe vs. redirect for MFA) in terms of UX, security, and implementation complexity. Cover error handling, timeout scenarios, and user cancellation.

Key Points to Mention

  • Cross-origin communication via postMessage with strict origin checks
  • Third-party cookie restrictions and workarounds (Storage Access API, token-based auth)
  • Risk-based step-up authentication triggers (transaction amount, device fingerprint)
  • Fallback to top-level redirect or popup when iframe embedding is blocked
  • Security headers (CSP frame-ancestors) to prevent clickjacking
  • Compliance with PSD2 SCA or similar regulations for strong customer authentication

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

Q3

What security considerations would you apply to the iframe embed, including PostMessage origin validation, CSRF protection, token encryption at rest, and PII isolation?

System DesignAPI & Integrations
Author's notes

This was the part I felt best about.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by framing the iframe embed as a security boundary and walk through each layer—transport, origin validation, CSRF, data at rest, and PII—in a structured way. Tie each consideration back to Plaid's context (financial data, third-party integrations) and mention concrete browser APIs and standards.

Pro tip: Emphasize defense-in-depth: no single control is sufficient, and you should explain how controls complement each other (e.g., origin validation plus CSRF tokens plus short-lived tokens). Also mention that you'd validate the PostMessage origin on both sides and use a strict allowlist, not wildcard.

1. Establish the trust boundary

Describe the iframe as an untrusted context and define what data flows in and out. Identify the parent and child origins and the communication channel (PostMessage).

2. Secure PostMessage communication

Explain origin validation on both sender and receiver: check event.origin against an allowlist, use targetOrigin explicitly (never '*'), and validate message schema.

3. Prevent CSRF and token misuse

Use CSRF tokens, SameSite cookies, and short-lived, scoped tokens for the embed. Ensure tokens are bound to the user session and origin.

4. Protect data at rest and PII

Encrypt tokens at rest with strong key management (KMS), isolate PII so the iframe only receives the minimum necessary data, and avoid logging sensitive fields.

5. Add monitoring and hardening

Include CSP, sandbox attributes, and logging/alerting for anomalous PostMessage traffic or token misuse to detect attacks early.

Key Points to Mention

  • PostMessage origin validation: check event.origin against an allowlist and use explicit targetOrigin; never use '*'.
  • CSRF protection: use anti-CSRF tokens, SameSite cookies, and validate Origin/Referer headers.
  • Token encryption at rest: encrypt tokens with KMS-managed keys and rotate them; avoid storing tokens in localStorage.
  • PII isolation: minimize data shared with the iframe, use tokenization, and ensure PII is not exposed in URLs or logs.
  • Defense-in-depth: combine CSP, iframe sandbox attributes, and short-lived tokens to limit blast radius.
  • Monitoring: log and alert on PostMessage origin mismatches and unusual token usage patterns.

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

Q4

Walk through the API design for initiating a link session, listing available institutions, handling credential submission or OAuth, and returning an exchange token to the partner app.

API & IntegrationsSystem DesignData Modeling
Author's notes

REST versus something more event-driven came up briefly.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by framing the flow as a sequence of API calls from the partner app to Plaid's backend, emphasizing the frontend's role in orchestrating the Link UI and handling responses. Then walk through each step—session initiation, institution listing, credential/OAuth handling, and token exchange—highlighting key API endpoints and data passed between frontend and backend.

Pro tip: Emphasize idempotency and error handling at each step, and mention how the frontend should gracefully handle network failures or user cancellations to ensure a smooth user experience.

1. Initiate Link Session

The partner app's frontend calls Plaid's /link/token/create endpoint with client_id, secret, and user info to obtain a link_token, which initializes the Link UI.

2. List Available Institutions

Using the link_token, the frontend fetches the list of supported institutions from Plaid's /institutions/get endpoint, displaying them for user selection.

3. Handle Credential Submission or OAuth

For credential-based institutions, the frontend securely submits credentials via Plaid's Link SDK; for OAuth institutions, it redirects to the institution's OAuth flow and handles the callback.

4. Exchange Public Token for Access Token

Upon successful authentication, the frontend receives a public_token from Plaid Link and sends it to the partner's backend, which exchanges it for an access_token via /item/public_token/exchange.

5. Return Exchange Token to Partner App

The backend stores the access_token securely and returns a session token or confirmation to the frontend, completing the link flow.

Key Points to Mention

  • Use of link_token for session initiation and its expiration
  • Institution list retrieval and filtering by country/products
  • Secure handling of credentials via Plaid Link SDK (never exposed to partner)
  • OAuth redirect flow and handling of redirect_uri
  • Public token exchange and secure storage of access_token
  • Error handling and user cancellation scenarios

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

Q5

Describe the data model for the core entities: users, financial institutions, linked account items, and access tokens.

Data ModelingSystem Design
Author's notes

Rushed through this near the end.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the scope: as a frontend engineer, focus on how the frontend consumes and interacts with these entities rather than the full backend schema. Then describe each entity's key fields and relationships, emphasizing how they map to UI components and data flows.

Pro tip: Highlight the importance of access tokens being handled securely on the backend and never exposed to the frontend; instead, the frontend should work with item IDs and rely on backend APIs for token management.

1. Clarify scope and assumptions

State that you'll describe the data model from a frontend perspective, focusing on the fields and relationships relevant to UI rendering and state management.

2. Define core entities and fields

For each entity (User, Financial Institution, Linked Account Item, Access Token), list the key fields the frontend needs, such as IDs, names, statuses, and metadata.

3. Describe relationships

Explain how entities relate: a User has many Items, each Item belongs to a Financial Institution and has many Accounts, and Access Tokens are associated with Items but not directly used by the frontend.

4. Map to frontend usage

Illustrate how these entities appear in UI components (e.g., account list, institution selector) and how data flows from API responses to state.

5. Address security and error handling

Mention that access tokens are managed server-side, and describe how the frontend handles errors like expired tokens or revoked items.

Key Points to Mention

  • User entity: id, email, name, and relationship to items
  • Financial Institution: id, name, logo, supported products
  • Linked Account Item: id, institution_id, status (e.g., healthy, login_required), accounts array
  • Access Token: never exposed to frontend; used server-side to fetch account data
  • Relationships: one-to-many from User to Items, Item to Accounts, and Item to Institution
  • Frontend patterns: normalizing state, caching entity data, and handling token-related errors via backend APIs

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