Nutanix Interviews

As a 2024 passout with 1.5 years of experience at a US Core Bank, I applied for Nutanix's MTS-1 role via referral. The interview process began with a recruiter reaching out after a few weeks. Round 1 involved solving two graph-related LeetCode problems: Alien Dictionary and Word Ladder II. The interviewer was friendly, and I was invited to the next round the following day. Round 2 was a problem-solving and debugging round where I had to clone an open-source database driver codebase and explain specific features like connection logic and indexing. Round 3 was an HLD round where I designed a chat application, discussing tradeoffs with the interviewer. Round 4 focused on technical questions around Kafka and messaging systems, along with a discussion about my role and open-source experience. I received a final offer after a few days.

🧩 Hiring Drive Experience

R1

[All Nodes Distance K in Binary Tree](https://leetcode.com/problems/all-nodes-distance-k-in-binary-tree/description/)

Follow-up

Solve without using extra memory.

R2

[Smallest Subsequence of Distinct Characters](https://leetcode.com/problems/smallest-subsequence-of-distinct-characters/description/)

Follow-up

Modify to get the largest subsequence.

R3

Distributed Job Scheduler – Machine Coding, focus on thread safety, strong focus on writing modular code.

R4

MoveInSync – High-level design (routing matching, schedules etc).

R5

Hiring Manager Round – Discussion around projects, approach, and salary.

R6

Key-Value DB – Discussed CAP trade-offs and master-slave design.

(This additional round was conducted as they couldn’t finalize candidates after R5 — a bit unusual.)

[Offer Details](https://leetcode.com/discuss/post/7168779/offer-evaluation-india-by-anonymous_user-wqxk/)

I participated in the Online Assessment for the MTS II - Python Automation Testing position at Nutanix. The OA was conducted on the Hackerrank platform. I was presented with a problem that involved Data Engineers needing to schedule long-running tasks on remote servers in a cost-effective manner. The challenge was to utilize both a paid server, which had variable costs and processing times for each task, and a free server, which processed tasks in a fixed time unit but only when the paid server was occupied. My goal was to determine the minimum total cost to complete all tasks by scheduling them optimally. The problem statement was quite detailed, providing an example and specific constraints to guide the solution.

question 1: https://leetcode.com/problems/longest-common-subsequence/description/ question2:https://leetcode.com/problems/sqrtx/submissions/668823403/

Hey everyone! Sharing my Nutanix experience process for the MTS-1 role, hope it helps those preparing.

Recruiter Call

Got a call from the recruiter after resume screening. They briefly explained the Job role, process and shared details for the next step.

Online Assessment (OA)

• Platform: HackerRank
• Questions: 2 Medium-level and MCQ's on CS Fundamentals(SQL,Linux,DSA etc)
  • One was a modified version of Asteroid Collision Problem
  • The other was a Sliding Window type problem
• Cleared the OA and received a mail for the next round

Technical Interview (Zoom)

• The interviewer joined and started with some CS fundamentals
  • Questions on Operating Systems and Memory Management, Linux,Computer Networks.
• Then asked me to open HackerRank CodePair (link was already shared)
• Coding Question on Matrix (Leetcode medium level):
  • I explained the intuition, time complexity.
  • He asked Follow-up questions,discussed about Edge-Cases and he also asked to optimize the solution.

We discussed about my internship project and experience and personal projects in the last 10–15 mins. The interviewer was friendly and encouraging.

Great learning experience overall! Wishing good luck to everyone preparing.

Round 1: Command-Line Archive Utility Objective: Build an archive utility (like a basic tar) with the following features — without using any existing archive/compression libraries.

Requirements:

Archive a Folder: Recursively create an archive from a folder while preserving the directory structure. ./archive-tool create ./my-folder archive1

Extract an Archive: Reconstruct the original folder structure. ./archive-tool extract archive1 ./restored-folder

List Archive Contents: Show all file paths in the archive. ./archive-tool list archive1

Extract a Specific File: ./archive-tool extract-file archive1 file.txt ./restored-folder

Verbose Mode: Add --verbose for detailed logs during operations.

Constraints:

No usage of tools like zipfile, zlib, java.util.zip, etc.

Only use standard libraries.

Handle errors gracefully (e.g., invalid paths, corrupt archives).

This round was focused on file system traversal, binary file creation/reading, and designing your own archive format.

Round 2: Graph Construction + Longest Chain & Cycle Given several user-defined functions like: def a(): b(), c() def b(): ... def c(): ... Tasks:

Build an adjacency list from the function call dependencies. Example: a → [b, c]

Find the Longest Chain: Longest path from any function to the deepest nested call (like DFS longest path).

Find the Longest Cycle: If there's a cycle, return the longest one.

Focus was on parsing, graph building, DFS, and cycle detection.

Outcome: Both rounds went well and I received positive feedback. The recruiter later informed me that the position is currently on hold.

Attended the Hiring drive for Nutanix for May. Consisted of 2 rounds.

HR called the night before the interview to schedule it the next day. They told me both the rounds will have DS/Algo problems to solve.

Round 1 : 2 problems (60 mins)

Solved both of them optimally in time along with all edge cases.

a. Given a string s, remove duplicate letters so that every letter appears once and only once. You must make sure your result is lexicograpically smallest one.

b. "maximize the minimum distance" problem — similar to placing cows in stalls with max spacing.

Round 2 : System Coding Round (nowhere close to what HR told me about what was expected from the interview)

Task : Implement a Memory Based Sparse File Class

I had three functions to implement. There were questions around best way for storing the data, concurrency and optimization of the functions. Also wanted to discuss about the compression algorithms but ran out of time)

HR told they will get back to me after 2 days (after they are done with the hiring drive. Hoping for the best right now!

Hi,

So I wasn't explicitly told about the position that's why I have put MTS-2 and MTS-3 both as I was told it could be anything among these depending on interview feedback.

A recruiter reached out to me on LinkedIn and we had a brief discussion after which I got an Online Assessment, I do not remember what were the questions but there were 2 questions and I remember thinking to myself that they are Medium level question with one of them being a DP problem.

After the OA, the recruiter told me that they are scheduling my interviews and there are going to be 4 interviews, i.e. 3 DSA + 1 System Design round.

Round 1

There were 2 DSA questions, they were both pasted directly on a coderpad link and I was supposed to write the full code from including the headers and everything, although the interviewer helped me with the basic headers which were required, he gave them to me directly.

• https://leetcode.com/problems/rotate-array/description/
• https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/description/

Verdict: Strong Hire

Round 2

Again, there were 2 questions in this round.

• Search for the element with minimum value in rotated sorted array. This was exactly the same as finding the pivot element, the wordings were a little different.
• https://leetcode.com/problems/first-missing-positive/description/

The interviewer then asked me to code the first missing positive problem with O(1) space complexity, now I know that means we're not supposed to use variable space so I did code one solution using the index as hash key. The interviewer then asked me to code my solution such that after my algo runs, my original array remains unchanged, as in I can change the array intermediately but I should set it back to original in the end. I tried but wasn't able to come up with the optimization for this. Later on, I got to know that I was given a Neutral feedback in this round.

Verdict: Neutral

Round 3

This round was supposed to be full DSA but we went into discussing my projects and stuff I have worked on so it consumed half an hour and we had another half remaining by the time I got the question.

• https://leetcode.com/problems/rotting-oranges/description/

Verdict: Strong Hire

Round 4

This was a design round and when it was scheduled, I did ask the recruiter if it is going to be an HLD round or LLD round then initially the recruiter didn't respond then after multiple follow-ups, I was told that it would be a mix. I prepared accordingly.

Now when the interview started, the inteviewer told me that we will be discussing the high level design of a database backup service.

I did try my best and we came up with a pretty decent design in my opinion but I feel that if I would have been told that this was specifically an HLD round, maybe I would have prepared better.

Verdict: Neutral to Lean-Hire

Now, for the next 4-5 days, the recruiter basically ghosted me - didn't respond to my calls, emails or messages. The next week my call was picked and I was told that they're still awaiting a decision and maybe 3-4 days after that I was told that I have been rejected owing to the verdicts of Round 2 and 4.

I recently interviewed for an MTS-4 position at Nutanix. I have a total of 6.5 years of experience, with my education being a B.tech from a tier-3 college and an M.tech from IIT.

Round 1: Online Assessment

This round consisted of 2 coding questions, both at a LeetCode medium difficulty level. I was able to solve both of them successfully.

Round 2: Coding Round

This round focused on a coding problem similar to one found on LeetCode Discuss. The specific problem involved recursively deleting leaf nodes in a multi-tree structure. We had a lot of discussion about different approaches, as well as their time and space complexities. I received positive feedback after this round.

Round 3: Low-Level Design (LLD)

The task for this round was to design a paint application, similar to Microsoft Paint. I was expected to deliver running code within an hour, based on the following requirements:

1. The user should be able to draw different shapes (like circles, rectangles, squares, triangles, etc.).
2. If a user draws a rectangle inside another rectangle on the screen, how would I ensure that these are stored in their exact positions in our database?
3. More than one user should be able to draw on the same screen and see each other's changes, similar to Google Docs.

For the first requirement, I suggested taking x,y coordinates from the frontend and storing them in the DB. However, the interviewer indicated that this would involve too much processing on the frontend, and they preferred a backend-heavy system. This round did not go well for me, and I anticipated a rejection.

Round 4: High-Level Design (HLD)

Despite the LLD round not going well, they had already scheduled the HLD round, so I attended it. The problem involved a scenario with N servers, where 2 <= N <= 50. Each server processes data based on its own configuration file. The admin needed a system where they could update a single configuration file, and all other files would automatically get updated. The constraint was that we could not use a common configuration service; the files had to remain with the individual servers.

I initially proposed a common configuration service where all servers could read values, allowing the admin to update just that one service. But the interviewer reiterated that they didn't want a common configuration service and insisted on files residing with the servers. I then came up with different approaches. This round went pretty well; the interviewer was friendly, and we had a healthy discussion.

After two days, I received a call from HR stating that the feedback from the LLD round was not positive, and they would not be proceeding further with my application. I am still looking for a solution for the LLD round, and any suggestions would be helpful.

I received a referral from a former colleague who currently works at Nutanix. With about 6 years of experience as a Senior Software Engineer at a product-based MNC and a CSE degree from IIT, I felt an MTS-4 role would suit my background better, but I proceeded with the MTS-3 interview.

Round 1: Virtual Interview with an MTS-4

This round started with a discussion about one of my projects that matched the role requirements. Following that, I was given two coding questions on HackerRank:

1. Buildings With an Ocean View
2. Rotting Oranges

I successfully cleared this round.

Round 2: In-Person Interview with another MTS-4 (~1 hour)

After clearing Round 1, I was asked if I could attend an in-person interview, which I agreed to since I lived nearby. This round began with discussions about some of my current projects. Then, I was asked to solve two LeetCode problems on a whiteboard, writing a running code in Python. The interviewer wanted at least an initial working solution, followed by optimization if needed.

1. Longest Palindromic Substring
2. Maximum Subarray

I wasn't completely prepared with dynamic programming problems at that point and was a bit hesitant to write the best approach for the first problem, so I ended up implementing the brute-force approach.

Round 3: In-Person HLD Round with a Staff Engineer (~1 hour)

This round involved a discussion around one of my projects on my resume, followed by a High-Level Design (HLD) question. I was tasked with designing an employee expense reimbursement tool, similar to SAP Concur, where employees could submit receipts and receive reimbursements. The design had to include components to interface with both the employee's manager and finance team members. I was well-prepared for this round and believe I performed really well, explaining the HLD starting with requirements, API design, database design, rough back-of-the-envelope estimates, and the overall system flow on the whiteboard.

Round 4: In-Person LLD and Behavioral Round with Hiring Manager (~1 hour)

I wasn't in much touch with Low-Level Design (LLD) when I attended this interview. While I had designed a lot in the past, I never focused on remembering the names of design patterns or principles like SOLID, though I unknowingly used them in my work. The round started with discussions about my current roles, projects, and any experience I had with leading teams. I was then asked to create an LLD for a system that manages all bookmarks created by a user on different browsers on their laptop. I was expected to draw UML diagrams and show interactions. I don't think I did great in this round.

Verdict

I personally felt that the recruiter/HR was completely unprofessional at the end of the interview process. I was told that the interviewers gave me mixed feedback in Round 2 and Round 4, and that I was being put on hold. Despite following up multiple times, I was continuously told that a decision had not yet been taken. I felt I might have been considered as a backup option. Anyway, I moved on and attended other interviews, eventually securing a position at a better company, which I am yet to join. I am grateful to the LeetCode community for motivating me to solve problems and maintain a streak, which kept me in the loop.

I interviewed for the MTS role at Nutanix, which consisted of four rounds.

Round 1: Coding
This round focused on coding, and I was given a problem: Minimum Insertion Steps to Make a String Palindrome. I successfully solved it using dynamic programming.

Round 2: Coding
The second coding round involved the problem Subarray Sum Equals K. There was also another math-related question, but I don't recall the specifics.

Round 3: Low-Level Design (LLD)
In this round, I was asked to write code demonstrating how the malloc() function works, focusing on memory allocation and management. I felt this round went acceptably.

Round 4: Technical Managerial Round
The final round was a technical managerial discussion. I was asked to code a solution for the Multiple Reader, Writer synchronization problem and also to implement deleting the Nth node from a Linked List. The interviewer emphasized code functionality and modularity.

Verdict:
I was selected for the role, with a base salary of 26 Lakhs and 28 Lakhs in RSU split over 4 years. However, due to company-wide cost cutting and layoffs, I sadly did not receive an offer letter. Despite the outcome, I believe everything happens for a reason, and I'm ready to continue my job search.

My interview journey for the Member of Technical Staff position at Nutanix, Bangalore, commenced in January 2020. I brought 1.5 years of experience to the table.

1st Telephonic Round

This round focused on fundamental data structures and Python concepts. I was asked to:

• Construct a complete binary tree from a given array in level order fashion.
• Answer questions regarding Python's threading module, classes, and objects.

2nd Onsite Round

The first onsite round delved deeper into algorithms and problem-solving:

• I was challenged to rearrange positive and negative numbers within an array using constant extra space. I approached this with an O(N²) solution, though the interviewer was looking for an O(N log N) approach.
• Another problem involved evaluating division queries given initial equations (e.g., a/b = 2.0, c/d = 3.0), with the expectation of O(1) query time through precomputations.
• I also had to implement the lower bound using binary search to find the first occurrence of a query element in a sorted array with duplicates.

3rd Onsite Round

This round continued with more complex data structures and algorithms:

• I successfully constructed a binary tree from its postorder and inorder traversals, providing a complete working code and explanation.
• A problem on finding the minimum deletions required to make the frequency of each letter in a string unique was presented.
• I solved the problem of finding the minimum number of bracket reversals needed to make an expression balanced, managing to do so without using any extra space.
• Additionally, I tackled counting subarrays with a sum less than or equal to K. For positive K and array numbers, I used a cumulative sum array with binary search (O(N log N)). I extended this to handle negative K and array elements using a Binary Indexed Tree (BIT) with value shifting.

4th Onsite Round

The fourth onsite round covered concurrency and system design:

• I was given a problem to print array elements using two threads, one for even-indexed elements and another for odd-indexed elements (assuming the original question's typo meant odd indices for the second thread).
• A significant discussion point was sorting a very large file that couldn't fit into memory, with a focus on minimizing disk access. I proposed a merge sort-like solution involving batching during list merging.
• Finally, there was a high-level system design discussion about implementing a views count feature for YouTube, covering topics like distributed servers, distributed caching, load balancing, and consistent hashing.

5th Onsite Managerial Round

The final round was managerial, focusing on technical leadership and architectural considerations:

• Discussion revolved around handling threads within a server using ThreadPoolExecutor, maintaining states for incoming requests, and optimizing resource utilization.