Intuit | SDE2 | Bangalore | Dec 2024
Summary
I interviewed for an SDE2 role at Intuit in Bangalore in December 2024. After multiple rounds covering online assessment, phone screens, and onsite challenges focusing on DSA, API implementation, and system fundamentals, I was ultimately rejected. The primary feedback I received pointed to issues with error handling and exception management in my API solutions.
Full Experience
Application and Online Assessment
I was directly reached out to by a recruiter on LinkedIn for an SDE2 position. Following the initial contact, I received an Online Assessment (OA) which I needed to complete within two days. The OA consisted of two Data Structures & Algorithms (DSA) questions – one focused on linked lists and another on arrays, both of which I found to be of medium difficulty. Additionally, there were five Multiple Choice Questions (MCQs) testing core technical concepts.
Two days later, the recruiter informed me that I had scored 94% on the OA, which led to an invitation for the phone screen rounds.
Phone Screen Rounds
1st Phone Screen
In this round, I was presented with a graph-based DSA problem that was very similar to the 'Rotten Tomatoes' problem. I discussed my approach thoroughly, implemented the solution in the provided coding environment, and successfully ran the code during the interview, demonstrating its correctness.
2nd Phone Screen
For the second phone screen, I tackled a medium-level DSA problem, which closely resembled 'finding the maximum rectangle in a histogram'. I clearly explained my thought process and approach to the interviewer, and once we aligned on the strategy, I proceeded to code the solution. My code worked as expected and passed the test cases.
A few days passed, and I received positive feedback from these rounds. The recruiter then informed me that I would be moving forward to the onsite interview stage. They also provided access to a code repository that I was required to set up locally in preparation for the upcoming rounds.
Onsite Interview Rounds
1st Round
This was a 90-minute session that began with an in-depth discussion about my current projects and the technology stack I'm working with. Subsequently, the focus shifted to tasks related to the shared code repository. My responsibilities included:
- Implementing a new POST API: The API's purpose was to save player details into a database. I was asked to consider the payload structure, error handling mechanisms, and logging strategies. I successfully implemented this API and verified its functionality using Postman.
- Integrating an LLM API: I received a URI for an existing Large Language Model (LLM) API. My task was to create an API that would take a prompt as input, call the given LLM API, and then return its response. I completed this integration and demonstrated it to the panel.
2nd Round
This round was purely focused on Data Structures and Algorithms. I was given a problem that was similar to 'next permutations of an array'. I walked through my approach, coded the solution, and successfully passed all the test cases provided by the interviewer.
3rd Round
The initial 30 minutes of this round were dedicated to engineering fundamentals and best practices discussions. Following this, I was asked to implement pagination functionality on the GET API that was part of the shared code repository. I completed this task and effectively demonstrated the new paginated functionality using Postman.
4th Round (Hiring Manager Round)
This 30-minute session was with the hiring manager. The questions primarily revolved around my day-to-day responsibilities, how I collaborate within a team, and my cultural fit within the organization. It was a behavioral-focused discussion.
Outcome
Two days after the onsite interviews, the recruiter contacted me to convey that the feedback was not positive. I was specifically told that the main issues identified were related to the error codes I used and improper exception handling within my API implementations. This experience was a valuable learning opportunity, highlighting areas for significant improvement in my API design and robustness.
Interview Questions (6)
During my first phone screen, I was asked to solve a graph-based DSA problem that was very similar to the 'Rotten Oranges' problem. The core task was to determine the minimum time required for all fresh oranges in a given grid to become rotten. Each minute, any fresh orange adjacent (4-directionally) to a rotting orange also becomes rotten. If it's impossible for all fresh oranges to rot, I should return -1. I discussed my approach, implemented the solution, and successfully ran the code during the interview.
In my second phone screen, I was given a medium-level DSA problem. This problem was analogous to 'finding the maximum rectangle in a histogram'. I was provided with an array of integers representing the heights of bars in a histogram, where each bar has a width of 1. My goal was to find the area of the largest rectangle within this histogram. I explained my approach to the interviewer, and upon their agreement, I proceeded to code the solution, which worked correctly.
During an onsite round, I was tasked with implementing a new POST API designed to save player details into a database. The interviewer engaged me in discussions about the optimal payload structure for player data, how to effectively handle various error conditions (e.g., invalid input, database errors), and the logging mechanisms I would integrate for debugging and monitoring. I successfully implemented the API and confirmed its functionality through testing with Postman.
I was provided with a specific URI for an existing Large Language Model (LLM) API and given the task to create a new API that would act as an intermediary. My API needed to accept a user-provided prompt as input, forward this prompt to the given LLM API, and then relay the LLM's response back to the client. I successfully implemented this integration and demonstrated its working to the interview panel.
In a DSA-focused onsite round, I was asked a problem similar to 'next permutations of an array'. The problem required me to find the next lexicographically greater permutation of numbers in a given array of integers. If no such greater arrangement is possible (i.e., the array is in descending order), I was to rearrange it to the lowest possible order (ascending order). The modification had to be done in-place. I explained my approach, coded the solution, and passed all test cases provided by the interviewer.
I was given an existing GET API from the shared code repository and tasked with implementing pagination functionality for it. This involved modifying the API to accept query parameters such as page_number and page_size. The API then needed to return only a subset of the data corresponding to the requested page, along with relevant metadata like the total count of items. I successfully completed this task and demonstrated the paginated output using Postman.