Autocoder

Nutanix Interview Questions and Answers

Last updated 2026-11-19

Nutanix builds software for running virtual machines, storage and cloud infrastructure, so its engineering interviews commonly lean towards systems: operating systems, memory, concurrency, distributed systems and storage ideas, alongside data structures and algorithms. This page offers practice questions on those themes, with worked answers.

They are practice questions on commonly reported topics, not real papers. For timed problems see Nutanix coding round questions, and for the operating systems fundamentals see operating systems interview questions.

Rounds as commonly reported

Candidate accounts describe an online assessment with coding and technical MCQs, followed by several technical interviews that mix data structures, operating systems, C or C++ (or Go and Python for some teams) and design, and then a managerial or HR round. Nutanix has not published a fixed process, so treat this as a rough pattern and follow your recruiter's instructions.

Topics to revise

Linked lists, trees, bit manipulation and dynamic programming; processes, threads, synchronisation, virtual memory and file systems; networking basics; and for design, replication, consensus and distributed storage trade-offs.

Hiring status

We hold no sourced hiring dates, numbers or process facts for Nutanix and no /hiring page exists for it on this site, so none are stated. For current roles, use the company's own careers site.

Nutanix Interview Questions and Answers: questions with worked answers

  1. 1

    What is virtualisation, and what is the difference between type 1 and type 2 hypervisors?

    medium

    Virtualisation lets several virtual machines share one physical machine, each with its own virtual hardware and guest operating system. A type 1 hypervisor runs directly on the hardware (bare metal) and is used in data centres for performance and isolation. A type 2 hypervisor runs as an application on a host operating system, which is simpler for desktops but adds overhead. Containers differ: they share the host kernel and isolate with namespaces and cgroups.

  2. 2

    What happens on fork, and what is copy-on-write?

    medium

    fork creates a child process with a copy of the parent's address space. Copying all memory would be slow, so the kernel marks the pages shared and read-only; when either process writes, a page fault makes the kernel copy just that page. The same idea underlies cheap snapshots in storage systems, where unchanged blocks are shared and only modified blocks are written elsewhere.

  3. 3

    Explain deadlock, livelock and starvation.

    medium

    Deadlock: threads wait for each other forever, each holding a resource the other needs. Livelock: threads keep changing state in response to each other but make no progress, like two people repeatedly stepping aside. Starvation: a thread is never scheduled or never gets a resource because others always take priority. Fixes: lock ordering for deadlock, randomised backoff for livelock, fair queues or ageing for starvation.

  4. 4

    Implement a thread-safe bounded buffer in C++.

    hard

    Use a mutex and two condition variables. Producers wait while the buffer is full; consumers wait while it is empty. Always wait with a predicate so spurious wakeups are handled, and notify the opposite condition after changing the queue.

    cpp
    #include <condition_variable>
    #include <mutex>
    #include <queue>
    
    template <class T>
    class Bounded {
        std::queue<T> q_;
        size_t cap_;
        std::mutex m_;
        std::condition_variable not_full_, not_empty_;
    public:
        explicit Bounded(size_t cap) : cap_(cap) {}
        void put(T v) {
            std::unique_lock<std::mutex> lk(m_);
            not_full_.wait(lk, [&] { return q_.size() < cap_; });
            q_.push(std::move(v));
            not_empty_.notify_one();
        }
        T take() {
            std::unique_lock<std::mutex> lk(m_);
            not_empty_.wait(lk, [&] { return !q_.empty(); });
            T v = std::move(q_.front());
            q_.pop();
            not_full_.notify_one();
            return v;
        }
    };
  5. 5

    What is the difference between the stack and the heap, and what causes memory leaks and fragmentation?

    medium

    The stack holds function frames, with automatic allocation and release as calls return; it is fast but small. The heap holds dynamically allocated memory that the program must free. Leaks come from allocated memory that is never released or from lost pointers; tools like Valgrind and AddressSanitizer find them, and RAII with smart pointers prevents most in C++. Fragmentation means free memory is split into pieces too small to use; allocators reduce it with size classes and coalescing.

  6. 6

    Design a distributed key-value store with replication.

    hard

    Partition keys with consistent hashing so adding nodes moves little data. Replicate each key to N nodes (commonly 3) on the ring. Choose the consistency model: with read quorum R and write quorum W, R + W greater than N gives strong reads of the latest write. For stronger guarantees use a consensus protocol such as Raft per partition, where a leader orders writes and a majority must acknowledge. Handle failures with hinted handoff and repair stale replicas using anti-entropy such as Merkle trees.

  7. 7

    Briefly explain Raft.

    hard

    Raft keeps a replicated log consistent. Nodes are followers, candidates or one leader per term. If a follower hears nothing from a leader before a randomised timeout, it becomes a candidate and requests votes; a majority makes it leader. The leader appends client commands to its log, replicates them, and commits an entry once a majority has stored it. Randomised timeouts avoid split votes, and the majority rule ensures any new leader has all committed entries.

  8. 8

    If the replication factor is 3, how many node failures can you tolerate?

    medium

    For data availability with any single copy sufficient, two failures. For a quorum-based system needing a majority of 3, which is 2 nodes, you tolerate one failure while still accepting writes. In general a majority quorum of n nodes tolerates floor((n-1)/2) failures, which is why clusters use odd sizes: 5 nodes tolerate 2, and 4 nodes still tolerate only 1.

  9. 9

    Explain virtual memory and what a TLB does.

    medium

    Each process uses virtual addresses translated to physical frames through page tables. Walking multi-level page tables costs several memory accesses, so the TLB caches recent translations in hardware; a hit makes translation almost free, while a miss triggers a walk. Context switches between processes may flush the TLB unless entries carry address space ids, which is one reason context switches are costly. Huge pages reduce TLB misses for large working sets.

  10. 10

    How does a file system find data using inodes?

    medium

    An inode stores a file's metadata and pointers to its data blocks: a number of direct pointers, then single, double and triple indirect pointers for large files. Directories map names to inode numbers. Opening a path walks the directory entries from the root to the inode, and reading block k follows the right pointer level. Hard links are extra directory entries pointing to the same inode, while symbolic links store a path.

  11. 11

    Tell me about a time you debugged a difficult concurrency or performance bug.

    easy

    Describe the symptom, how you reproduced it (stress tests, logging with timestamps, thread dumps), the hypothesis and tools such as a profiler or sanitiser, the fix and the test you added to prevent regression. Systems teams value careful, evidence-based debugging over guesses.

  12. 12

    Why Nutanix?

    easy

    Tie it to the engineering: virtualisation and distributed storage are hard, low-level problems with real customers. Mention one concept you have learned, such as how snapshots or replication work, and the part of the stack you want to work on. Keep it specific and honest.

Frequently asked questions

Does Nutanix focus on operating systems?

Operating systems, memory and concurrency are commonly reported topics for engineering roles. Revise them alongside DSA.

Which language should I use?

C or C++ is common for core teams, and some teams use Go or Python. Use what the role and platform allow.

Is system design asked to freshers?

Reports suggest freshers see more OS and DSA, while distributed system design is more typical for experienced hires.

Where can I find openings?

On Nutanix's careers site. This site has no sourced hiring data for the company.

Related guides

More in Company Interview Questions

See all in this section