← Bank of America Interview Insights

Bank of America·Software Engineer·Onsite - Multi Round·Senior

SeniorPrefer not to say
Jun 2026

Summary

Did an onsite where the coding section got squeezed into the last 20 minutes after a long intro and system design discussion, then got hit with HTTP response creation and marshalling stuff that no amount of Leetcode grinding prepares you for.

Questions Asked (2)

Q1

Design a system that is fault tolerant. Walk through your approach.

System DesignTechnical Trade-offs
Author's notes

This part actually went fine.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the system's requirements and constraints, then systematically address fault tolerance at each layer (hardware, software, data, network) using redundancy, replication, and graceful degradation. Conclude by discussing trade-offs and how you would validate the design through chaos testing and monitoring.

Pro tip: In a banking context, emphasize data consistency and regulatory compliance—fault tolerance isn't just about uptime, but also about ensuring transactions are never lost or duplicated. Mention specific patterns like idempotency and exactly-once semantics.

1. Clarify Requirements and Constraints

Ask questions to understand the system's scope, expected load, SLAs, consistency needs, and regulatory requirements. This ensures your design addresses the right problems.

2. Identify Failure Modes

Enumerate potential failures: hardware crashes, network partitions, software bugs, data corruption, and human errors. Prioritize based on impact and likelihood.

3. Apply Fault Tolerance Techniques

For each failure mode, propose techniques such as redundancy (active-passive, active-active), replication (synchronous vs asynchronous), partitioning, and graceful degradation.

4. Discuss Trade-offs

Explain the trade-offs between consistency, availability, and partition tolerance (CAP theorem), as well as cost, complexity, and latency implications of your choices.

5. Validate and Monitor

Describe how you would test fault tolerance (e.g., chaos engineering, failure injection) and monitor the system (e.g., health checks, alerting, logging) to ensure it meets SLAs.

Key Points to Mention

  • Redundancy and replication strategies (e.g., active-active, multi-region deployments)
  • Consistency models and CAP theorem trade-offs (e.g., strong vs eventual consistency)
  • Idempotency and exactly-once processing to prevent duplicate transactions
  • Circuit breakers, retries with exponential backoff, and timeouts
  • Data durability and backup/recovery mechanisms (e.g., write-ahead logs, snapshots)
  • Monitoring, alerting, and chaos engineering for proactive fault detection

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

Q2

Implement a method that creates an HTTP response, including marshalling and unmarshalling data from a dictionary, without IDE autocomplete.

API & IntegrationsTechnical Trade-offs
Author's notes

This wrecked me.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the requirements: which HTTP method, status code, headers, and data format (JSON/XML). Then outline a step-by-step implementation: create a response object, set status and headers, marshal the dictionary to the desired format, write to the response body, and handle errors. Emphasize that without IDE autocomplete, you rely on knowledge of standard library APIs and careful syntax.

Pro tip: Mention that you would write the code in small, testable chunks and use print statements or logging to verify each step, since autocomplete is unavailable. Also, note that in a banking context, you must ensure proper error handling and data serialization to avoid security issues like injection attacks.

1. Clarify Requirements

Ask about the expected HTTP method, status code, headers, and data format (e.g., JSON, XML). Confirm whether the dictionary represents request or response data and if any specific library is preferred.

2. Design the Method Signature

Define the method parameters (e.g., dictionary, status code) and return type (e.g., HttpResponse). Consider error handling and whether to throw exceptions or return error responses.

3. Implement Marshalling

Convert the dictionary to the desired format (e.g., JSON) using standard library functions like json.Marshal in Go or json.dumps in Python. Handle potential errors such as unsupported types.

4. Construct HTTP Response

Create an HTTP response object, set the status code, set the Content-Type header, and write the marshalled data to the response body. Ensure proper error handling if writing fails.

5. Test and Validate

Mention writing unit tests to verify the response status, headers, and body. Also, consider edge cases like empty dictionaries or invalid data.

Key Points to Mention

  • HTTP response structure: status code, headers, body
  • Marshalling/unmarshalling concepts and common formats (JSON, XML)
  • Error handling and validation, especially in banking
  • Standard library functions for HTTP and serialization (e.g., net/http, encoding/json in Go)
  • Testing and debugging without IDE autocomplete
  • Security considerations: input sanitization, avoiding injection

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