Bank of America Data Engineer Interview Guide

The Bank of America data engineer loop, round by round: what each stage tests, example questions with the guidance interviewers actually score, the mistakes that sink strong candidates, and how to prepare.

Last updated: Proudly published by: Jeff Wahl

3 real Bank of America interview questions

Reported by candidates from real loops, tagged by domain, round, level, and year. Expand for what the round is scoring.

SQLL3
Write a SQL query to find the 2nd highest salary at the company; schema: employee(employee_id, salary)
Phone screen · screen sql
+
PythonL4
Write a PySpark function against a transactions DataFrame that calculates monthly total per account, identifies top 3 accounts by monthly spend, and computes average per transaction_type; schema: transactions(transaction_id INT, account_id INT, transaction_date DATE, transaction_amount FLOAT, transaction_type VARCHAR)
Onsite · python
+
Data modelingL5 · 2024
Design a relational database schema for a loan system with Customers, Loan_Types, Loans, and Loan_Transactions tables, then write a query to calculate the outstanding loan balance for each customer
Onsite · data modeling
+

Expected schema: Customers(customer_id PK, name,...), Loan_Types(loan_type_id PK, type_name, interest_rate), Loans(loan_id PK, customer_id FK, loan_type_id FK, principal_amount, start_date), Loan_Transactions(transaction_id PK, loan_id FK, paid_amount, transaction_date). Outstanding balance query: JOIN Loans with Loan_Transactions, SUM principal_amount - SUM paid_amount per customer. Tests foreign key design, one-to-many relationships, and aggregation across joined tables.

The technical bar

The technical bar centers on pipeline architecture and data modeling, which tracks with the kind of work the bank actually runs: batch-heavy, compliance-adjacent, and built on Docker, Hadoop and Hive. A strong answer in the loop doesn't just describe a correct design; it accounts for schema evolution, idempotency under replay, and what happens when an upstream feed is late or malformed. The screen leans on Python, so expect to write something executable rather than describe it conceptually. At the modeling layer, the bar is a working knowledge of slowly changing dimensions, surrogate keys, and audit trail design, because regulatory reporting depends on being able to reconstruct state at any historical point. An answer that would pass at a fast-moving tech shop will stall here if it doesn't address lineage, data quality gates, or how the pipeline behaves during a backfill across several months of regulated data.

Prepare for the interview
01 / Open invite
02min.

Walk into Bank Of America knowing the SQL pattern they'll test.

a Bank Of America SQL query, the same shape a screen would give you.
The diff against expected. Where ties broke. What you missed.
sandbox
1SELECT user_id,
2 COUNT(*) AS sessions
3FROM events
4WHERE ts >= NOW() - INTERVAL '7 day'
5
Execute your solution0.4s avg.
AirbnbInterview question
Solve a Bank Of America problem
Where offers are lost

The most common failure mode in this loop is candidates who over-index on novelty and under-deliver on rigor. Engineers who lead with "I'd use a streaming-first architecture" before understanding the batch cadences in place, or who propose greenfield lakehouse designs without acknowledging migration complexity, read as insufficiently grounded for BofA's operating environment. The inverse behavior that reads as a hire is methodical problem decomposition: naming the failure cases explicitly, proposing guardrails, and showing you've thought about the SLA before the schema. Given that 61 reports land at the mid band and only 5 at senior, the loop is clearly calibrated to produce a lot of mid-level placements. Candidates who present as senior but skip over the fundamentals in a rush to the advanced design get leveled down or cut; the bar for L5 requires you to demonstrate sustained rigor across the full loop, not just 1 strong round.

Try a Bank of America-style SQL round

Find every user active on 3 or more CONSECUTIVE days. This gaps-and-islands shape shows up in nearly every DE SQL round. Edit the query and run it against the seed data.

/* Users active on 3+ consecutive days. */
/* Hint: date minus a per-user ROW_NUMBER is constant within a streak. */
WITH streaks AS (
SELECT
user_id,
activity_date,
activity_date - CAST(
(ROW_NUMBER() OVER (
PARTITION BY user_id
ORDER BY activity_date
))
AS INT
) AS grp
FROM user_sessions
)
SELECT
user_id
FROM streaks
GROUP BY user_id, grp
HAVING COUNT(*) >= 3
What the loop filters for

Bank of America's loop is filtering for engineers who treat correctness as a constraint, not a goal. At a bank that runs AML monitoring, CCAR reporting, and FINRA recordkeeping on the same infrastructure, a pipeline that produces a wrong number at the wrong moment has regulatory consequences, not just engineering ones. The process is designed to surface whether you internalize that operating reality or treat it as someone else's problem. That means the evaluation tilts toward judgment under ambiguity: can you reason about failure modes before they happen, communicate tradeoffs to non-engineers clearly, and make defensible calls on schema and data contracts without needing explicit direction? Engineers who flourish here tend to be the ones who ask "what breaks downstream" before they ask "what's the fastest path to done."

Bank of America is hiring data engineers now

The roles behind this loop. Prep against the levels and locations they are actually filling.

Prep allocation

Put your first hours into pipeline architecture prep, specifically the failure and recovery scenarios: late arrivals, duplicate records, failed stages, and backfill correctness. That domain owns the loop focus and is where the most differentiation happens. The Python screen is not a filter you can skip; practice writing clean, testable transformation logic, because the screen likely involves actual code, not pseudocode. Data modeling fundamentals, especially around audit trails and historical reconstruction, should be your 3rd priority. What you can reasonably deprioritize: distributed systems theory at the depth required in big-tech loops, real-time streaming design, and modern cloud-native tooling that isn't yet reflected in the Kubernetes, Hadoop, and Hive stack. If you're targeting L5, the delta isn't a harder algorithm question; it's demonstrating that your design instincts consistently account for compliance and operability without being prompted. The typical successful candidate at the mid band has solid SQL and Python fundamentals and can explain the tradeoffs in a batch pipeline design without over-engineering the answer.

Bank of America
Hiring now
Bank of America data engineer · live from career pages
1
open roles
Levels hiring
L41
Updated 1 open listing across 1 city

Bank of America compensation and culture

The numbers, tech stack, and team structure live on the company overview.

Compare Bank of America with other data engineering employers

How the role, pay, and loop stack up against peer companies.

02 / Why practice

Prepare at Bank of America interview difficulty

  1. 01

    Reading a solution is not the same as writing one

    Every engineer who has frozen on a query they had read a dozen times knows the gap. The only preparation that closes it is producing the answer yourself, under time, before the interview does it for you

  2. 02

    76% of hiring managers reject on the coding task, not the resume

    From HackerRank's 2024 Developer Skills Report. Candidates who look strong on paper still fail the live screen if they haven't done timed, executable practice

  3. 03

    5 problem shapes cover 80% of data engineer loops

    Dedup, sessionization, top-N-per-group, slowly-changing dimensions, partition tricks. Writing the shapes by hand turns the unfamiliar into pattern recognition

Related Guides