Bitgo Interviews

My interview journey at BitGo for an SDE-1 Backend position, after 2.4 years of experience in investment banking, began with a 30-minute telephonic screening. This initial round was quite light, focusing on my professional background and fundamental backend concepts. We discussed my daily responsibilities, general backend architecture, basic Java principles, and several Spring Boot topics such as beans, autowiring, exception handling flows, and the distinctions between filters and interceptors, along with REST controller basics. I found this round to be quite easy.

Next, I moved on to an online assessment, which combined Data Structures and Algorithms with a code explanation component. I was given two coding questions to solve and then had to walk through my logic. The first question involved finding the shortest path in a graph; I had to parse string-formatted edge inputs, build the graph, and then apply BFS to find the path between a source and target. The second question was a Fibonacci variant: given an array, I needed to find the first Fibonacci number greater than or equal to the sum of all array elements. After simply computing the sum, I generated Fibonacci numbers until the condition was met. There was also a follow-up to explain the complexity and discuss alternative approaches. I'd categorize this round as Easy to Moderate in difficulty.

The final and most challenging round was an hour-long Low-Level Design (LLD) session. My task was to design a simplified version of MySQL, with the expectation of delivering working code. This required implementing functionalities like creating databases, tables, inserting and querying rows, and demonstrating basic relational behavior. I also needed to handle commands through parsing, maintain all data using in-memory data structures, and strictly adhere to OOP and SOLID principles throughout my design. While I managed to implement most of the features, I couldn't quite finish one minor part within the given time.

Following these rounds, I unfortunately received a rejection email.

My interview process for the Backend Engineer E3 role at BitGo began with recruiter outreach through Instahyre.

Round 1: Online Assessment (Coderbyte)
This was an online assessment administered via Coderbyte. Honestly, I don't recall the specific questions from this round.

Round 2: DSA Pair Programming (Coderbyte)
This round involved live coding and discussions on two data structures and algorithms problems:
1. A BFS problem on a grid, which was quite similar to the classic Rotting Oranges problem.
2. Finding the longest path in a general graph. This problem was conceptually similar to LeetCode's Binary Tree Maximum Path Sum, but adapted for a graph structure, and I was also required to print the actual path.

Round 3: Machine Coding (LLD)
The task here was to implement the stoi (string to integer conversion) function. While it seemed like a DSA problem, I approached it with a strong focus on low-level design principles. I ensured I followed proper Object-Oriented Design (OOD), covered all relevant edge cases clearly, and completed the implementation in approximately 35 minutes. To demonstrate extensibility, I even incorporated a Strategy Pattern, which would allow for future parsing rules. The interviewer mentioned that all requirements were fulfilled and the round concluded early.

Final Outcome
Despite what seemed like a positive outcome in the LLD round, I was ultimately rejected. No detailed feedback was provided regarding the rejection.

I had an interview experience for an SDE2 position at bitGo. I have 5 years of experience, with a one-year gap due to medical reasons, and my prior background is in finance and insurance companies.

The interview process consisted of several rounds:

1. Online Assessment (OA): This round had two questions covering topics like tries and anagrams.

2. Round 2: This was a technical round where I was asked a question about finding the diameter of a graph, with the specific condition that the graph would not contain any cycles.

3. Round 3 (Machine Round - LLD): This round focused on Low-Level Design, and I was given a task to design a SQL database.

4. Round 4 (Hiring Manager): This discussion-based round involved questions about bitGo, my past work experiences, and blockchain technology.

5. Round 5 (Cultural Fit): This round consisted of general questions to assess cultural fit within the company.

6. Round 6 (HLD): The final technical round was a High-Level Design discussion where I had to design a Transaction Indexer System.

After completing all rounds, the final verdict was a rejection, as they found better-matching candidates.

My interview process with BitGo involved several stages.

Online Assessment

The Online Assessment included two coding problems:

1. A problem to find the shortest path between a given source and target.
2. A question related to anagrams, which felt familiar as I had seen similar OA questions mentioned by others.

Round 1 (DSA)

This round focused on Data Structures and Algorithms.

1. The first problem involved analyzing a meeting transcript to find the top k most talkative people in the meeting. I had to decide on a proper input format myself. My approach was to use a heap.
2. The second problem was the classic LeetCode Min Stack problem.

Round 2 (LLD)

This was a Low-Level Design round. I was tasked with designing a notification service. The requirements included building a backend application (using Express or any Node.js framework) with APIs for creating notifications (POST), getting a single notification, and getting all notifications with filters. The expectation was to use Factory and Strategy patterns, and to save data in memory without database persistence. I learned a friend of mine had a similar round but used Python and was rejected.

Round 3 (HLD)

The High-Level Design round challenged me to design a system for creating and managing multiple cryptocurrency wallets. Key requirements included user login, the ability to create wallets for specific asset types like Bitcoin, and functionality for depositing and withdrawing funds. The system also needed to support multiple crypto assets such as Bitcoin, ETH, and SOL.

Round 4 (Hiring Manager/Culture Fit)

This final round consisted of standard behavioral and culture fit questions, such as discussing my reasons for wanting to switch roles and details about my current work.

The overall verdict was a 'Hire'.

I wanted to share a recent interview experience with BitGo that left me both disappointed and reflective — not because of the result, but because of the process.

Interview Rounds Overview

Round 1: Online Assessment

• Rotate Array
• Count Anagrams

Round 2: DSA Round

• Next Permutation

Round 3: Low-Level Design (LLD)

Problem: Design a Notification Service with the following features:

• Create Notification
• List Notifications
• Update Notification Status
• Send Notifications

What Went Well

I cleared both Round 1 and Round 2 comfortably.
In the LLD round, I implemented all required features, followed clean code principles, proper OOPs design, and handled modularity and extensibility well.

Where It Fell Apart

During the discussion, I truthfully mentioned that I’ve worked extensively on frontend in my current full-stack role — and as a result, I haven’t developed many standalone backend APIs recently.

Despite a strong technical performance, I was rejected — and the feedback email didn’t provide any specific or constructive reason for it.

What This Says About the Process

• If being honest about past roles counts against a candidate more than their actual performance in the round, is the process really fair?
• If candidates aren’t given clear feedback, how are we supposed to grow?

Final Thoughts

I’ve shared this not to rant — but to raise awareness. A good interview process values transparency, technical ability, and potential. It shouldn't penalize honesty, nor fall short in giving proper closure to candidates who take the process seriously.

If anyone else had a similar experience, feel free to share.
We all deserve better hiring processes.

1. Count Anagram You’re given a single string of space‑separated words. Some words may be exact duplicates, and others may be anagrams of each other. After removing exact duplicates, count how many words are “extra” members of any anagram group.

   Input: "aa aa odg dog gdo" Dedup’d words: ["aa", "odg", "dog", "gdo"] Anagram groups: "aa" → group size 1 → contributes 0 "odg"/"dog"/"gdo" → group size 3 → contributes 2 Output: 2

2. Rotate & Concatenate Array Problem: Given an array of non‑negative integers arr of length 𝑛 the first element k = arr[0] tells you how many positions to left‑rotate the entire array. After rotating, write out each element in order and parse the concatenated string as one integer. Input arr = [2, 3, 4, 1, 6, 10] k = 2 → rotated = [4,1,6,10,2,3] → "4161023" → 4161023

   arr = [3,2,1,6] k = 3 → rotated = [6,3,2,1] → "6321" → 6321

Online Assessment

Question 1: Find shorted path between given source and target. Input was in the string format. So we need to create a graph first and the do BFS

Question 2: Fibonacci Series. Given array return fibbonacci number greater or equal to sum of array elements.

Round 1 DSA

Question: Given a transcript of meeting, find top k most talkative person in the meeting. No input format was given, we need to decide this.

I could not derive the test cases, interviwer gave some test cases all of them passed. He mentioned you should be able to think of test cases (whihch is very much obvious).

My Solution (rate this code):

import java.util.*;
import java.io.*;
class Node {
  String personId;
  int freq;
  int length;
Node(String pId, int length) {
this.personId = pId;
this.length = length;
freq = 1;
}
@Override
public String toString() {
return personId;
}
}
/**
// key: personId, value: Node
//   Node: {
//     String personId,
//     int freq;
//     int length;
// }
*/
class Main {
public static List<Node> topKPersons(String transScript, int k) {
String[] entries = transScript.split("\|");
PriorityQueue&lt;Node&gt; pq = new PriorityQueue&lt;&gt;((a, b ) -&gt; a.freq != b.freq ? b.freq -a.freq : b.length - a.length);
Map&lt;String, Node&gt; map = new HashMap&lt;&gt;();

for(String entry: entries) {
  // System.out.print(entry);
  String[] pair = entry.split(":");
  if(pair.length != 2)
    continue;
  String pId = pair[0];
  String speech = pair[1];

  if(!map.containsKey(pId)) {
    Node node = new Node(pId, speech.length());
    map.put(pId, node);
  } else {
    Node node = map.get(pId);
    node.freq++;
    node.length += speech.length();
  }
}

for(Map.Entry&lt;String, Node&gt; it : map.entrySet()) {
  // String pId = it.getValue();
  Node node = it.getValue();
  pq.add(node);
  // if(pq.size() &lt; k)
  //   pq.add(node);
  // else {
  //   Node node = pq.remove();
  //   pq.add(node);
  // }
}

List&lt;Node&gt; res = new ArrayList&lt;&gt;();
for(int i=0 ; i&lt;k &amp;&amp; !pq.isEmpty(); i++) {
  res.add(pq.remove());
}
return res;

}
public static void main (String[] args) {
String trasnScript =
"person1:|person2:|person1:hello|person3:hello|person2:hello";
List<Node> res = topKPersons(trasnScript, 1);
System.out.println(res);
}
}

We left with 5 minutes after test cases and code analysis. I asked what was expectation how many problems were expected to solve, but he did not clarify this.

YOE: 3.5 years

Role: SDE2

Pre Screening round : Two Easy coding questions on Coderbyte.

Round 1 : https://leetcode.com/problems/longest-increasing-path-in-a-matrix/solutions/

I was able to solve the question in 30 minutes. Interviewer was super friendly and nice, He was helping out whenever you get stuck.

Waiting for results of first round, Will update in case next set of rounds happen.

Update on the results : ( Very unexpectedly they rejected me, even after i solved the question, and interviewer was satisfied with the implementation and approach. I solved, submitted, and optimized it in 30 minutes itself)

BIT-GO (Screening Round)

Platform: Coderbyte

Solved Question 1 with 100% Success rate. Solved almots 97% for 2nd question.

Recuirter said, they didn't get any response from Coderbyte side.

Round 1: Data Structures & Problem Solving

Question : Return the shortest distance from A -> F Input : {"5","A","B","C","D","F","A-B","A-C","B-C","C-D","D-F"} Ouput : Shortest path from A to F: A -> C -> D -> F

I haven't practiced shortest distance problems, so I wasn't able to explain the correct approach for this one.

My interview journey for the Staff Backend Engineer position at BitGo began with an Online Assessment. This OA primarily consisted of two Data Structures and Algorithms questions, both centered around graphs.

Following the OA, I moved to the first interview round, which focused on another DSA problem. The interviewer presented a medium-difficulty sliding window problem for me to solve.

For the second and final round, the focus shifted to Low-Level Design (LLD). I was given the task of implementing the classic Snake and Ladder game. While I managed to complete the implementation, it definitely took me more time than I had anticipated.

In the end, I received a rejection.

I applied for the Senior Backend Engineer role at BitGo in Bangalore, coming from an SDE-2 position at a Japan-based Fintech company with 3.5 years of experience. My current compensation was ₹24,82,000 INR per annum.

First Round | June 2024 (Low-Level Design)

For the first round, the interviewer presented me with a challenge to implement a Snake and Ladder game, along with several bonus improvements tailored for a senior-level engineer. I focused on designing a robust and extensible system, and I successfully cleared this round.

Second Round | July 2024 (Data Structures and Algorithms)

In the second round, I faced two challenging DSA questions. The first asked me to find the maximum sum of non-adjacent elements within a tree, and the second was a similar problem but for an array. I was able to articulate and implement solutions for both problems, achieving linear time complexity for each. While I felt I performed well and the interviewer expressed satisfaction with my approach, I suspected there might have been room for even further optimization. Following this round, I experienced a period of being ghosted by HR. Eventually, I received a call informing me that I did not perform well enough, though I suspect the position might have been filled in the interim. I had initially discussed a compensation expectation of ~32 LPA, which HR seemed ready to offer.

Outcome

Despite my best efforts and what seemed like a positive interview experience, I was unfortunately rejected.

I had a comprehensive interview experience with BitGo for a Backend Engineer E3 (Staff) position in February 2024, conducted remotely. My current experience is over 7 years. The entire process was very efficient, taking only two weeks to complete all five rounds, and I received an offer within two days after the final cultural fit round. All interviewers and HR were exceptionally friendly and polite, making the process pleasant.

Here's a breakdown of my interview rounds:

1. Hiring Manager Call (45 minutes): This round focused on my past work experience and the projects I had delivered.
2. Machine Coding (2.5 hours): I was tasked with a mini-project involving calling external APIs to fetch paginated results, storing this data in a local cache (I used a text file to ensure persistence across service restarts), and then performing a Depth-First Search (DFS) to find a specific result. I managed to complete this task in about an hour, after which we discussed BitGo's culture for the remaining time.
3. Live Coding (1 hour): This round consisted of two specific coding challenges. The first was to implement a Least Recently Used (LRU) cache from scratch. The second problem involved determining if a car trip could be completed given its capacity and a series of passenger onboarding and dropping events, ensuring the number of people in the car never exceeded its capacity at any point.
4. System Design (45 minutes): The first 20 minutes were spent discussing a payment system I had previously designed. For the remaining 25 minutes, I was asked to design a digital wallet for cryptocurrency and elaborate on strategies to scale it for millions of users.
5. Cultural Fit (30 minutes): This final round assessed my compatibility with the company's culture.

I received a 'strong hire' rating in all rounds. Although I received an offer, I am currently planning to decline it as I intend to continue preparing for FAANGMULA companies outside India.

I applied for the SDE2 position at BitGo. My background includes 5 years of experience in India and Abu Dhabi, with a focus on Distributed services, Kafka, and NoSQL/SQL databases, and I'm currently pursuing a Master's in Software Engineering at ASU. I felt confident with leadership principles questions.

The interview process started with a Round 1: 15-minute HR intro call, which I passed.

Next was Round 2: 45-minute call with the Hiring Manager. This round focused on my resume and work experience, and I successfully passed it as well.

The final stage was Round 3: Onsite rounds consisting of 3.5 hours, which included multiple technical sessions:

• Round 3.1 - 45 minutes: Data Merging

  I was asked to merge two sorted arrays (Part 1a) and then generalize it to X sorted arrays (Part 2a), discussing space and runtime complexity for both. I initially used a merge sort approach, achieving O(N) time complexity. After discussion, I also considered an optimized approach using a priority queue. I made sure to discuss my solution before coding, which was helpful.

• Round 3.2 - 45 minutes: Stock Search by Prefix

  This problem involved finding all stocks starting with a given string from a list of company names and their stock values. I immediately identified and implemented the most efficient solution using a Trie data structure, completing it within O(N) time complexity.

• Round 3.3 - 45 minutes: Remove Minimum Parentheses

  I was given a string with alphanumeric characters and parentheses and asked to remove the minimum number of parentheses to make it valid, returning any possible result. I approached this using a stack to validate parentheses and iterate through the string, achieving O(N) time complexity.

• Round 3.4 - 45 minutes: Reorder Linked List

  The final coding challenge was to reorder a singly linked list from L0 -> L1 -> ... -> Ln to L0 -> Ln -> L1 -> Ln-1 -> .... Unfortunately, I was unable to complete this code within the specified O(1) space and O(N) time complexity constraints during the interview.

Overall, I received a rejection.