Interview experience
Mphasis Interview Questions and Answers (2026)
Real Mphasis interview questions - candidate interview experiences and HR round prep, in one place.
Overview
Section titled “Overview”Mphasis’s fresher process (Associate Software Engineer / Software Engineer) runs an aptitude-plus-coding OA, an optional GD/JAM, one or two technical interviews on DSA and core CS, and a closing HR round.
Mphasis interview process at a glance
Section titled “Mphasis interview process at a glance”| Round | Duration | What they test |
|---|---|---|
| Online Assessment | Varies | Aptitude, logical reasoning, verbal ability, technical MCQs, 1-2 coding problems |
| Group Discussion / JAM (some campuses) | 15-20 min | Communication, structured thinking |
| Technical Interview | 30-45 min | DSA, OOPs, DBMS/SQL, OS, networks, chosen language, projects |
| Managerial round (some drives) | 20-30 min | Project depth, team fit |
| HR Interview | 20-30 min | Background, motivation, role fit |
Common technical interview questions and answers
Section titled “Common technical interview questions and answers”Q: How do you perform a level-order traversal of a binary tree?
Use a queue. Enqueue the root, then loop while the queue is non-empty: record the current queue size as the number of nodes on this level, dequeue exactly that many nodes, print or collect each value, and enqueue each node’s non-null left and right children. Capturing the size at the start of each iteration is what lets you emit the tree level by level rather than as one flat list. Every node is enqueued and dequeued once, so it is O(n) time; space is O(w) where w is the maximum width of the tree, which is about n/2 for a complete tree. A recursive alternative computes the height and prints each level separately, but that is O(n squared) on a skewed tree, so the queue version is the answer to give.
Q: How do you reverse a singly linked list?
Iteratively with three pointers. Set prev to null and curr to head; in each step save next = curr.next, point curr.next back at prev, then advance prev = curr and curr = next. When curr becomes null, prev is the new head. That is O(n) time and O(1) space, and the order of the four assignments matters - if you reassign curr.next before saving next, you lose the rest of the list. A recursive version recurses to the tail and re-links on the way back, which is also O(n) time but O(n) stack space, so it can overflow on a long list. Handle the empty list and single-node list explicitly; both should simply return the head unchanged.
Q: How do you check whether a string of brackets is balanced?
Push every opening bracket onto a stack. On a closing bracket, the string is invalid if the stack is empty or the top does not match the corresponding opening bracket; otherwise pop and continue. At the end the string is balanced only if the stack is empty, which catches unclosed openers. It is O(n) time and O(n) space. Store the pairs in a hash map from closing to opening bracket so adding a new bracket type does not mean adding another if-branch. Counting brackets instead of using a stack is the classic wrong answer - it accepts a string like a close-then-open sequence, which has equal counts but is not balanced.
Q: What is the difference between an array, an ArrayList and a LinkedList?
An array is fixed-size contiguous memory: O(1) indexing, excellent cache locality, but you cannot grow it. An ArrayList wraps a dynamic array - indexing stays O(1), appending is O(1) amortised because the backing array doubles when full, but inserting or deleting in the middle is O(n) because elements shift. A LinkedList stores nodes with pointers, so inserting or deleting is O(1) once you hold the node, but reaching position i costs O(n) and every node carries pointer overhead with poor cache behaviour. In practice ArrayList wins for most workloads even for mid-list inserts at small sizes, because a block move of contiguous memory is far faster than chasing scattered pointers; choose LinkedList only when you genuinely need queue or deque behaviour at both ends.
Q: Explain the four pillars of OOP as they appear in Java.
Encapsulation: fields are private and access goes through methods, so an object can enforce its own invariants - a BankAccount can reject a withdrawal that would make the balance negative. Inheritance: a subclass extends a base class with the extends keyword, reusing state and behaviour, and Java allows only single class inheritance to avoid the diamond problem, with interfaces filling the gap. Polymorphism: a base-type reference can hold any subclass object and calls dispatch at run time to the overridden method, which is what lets a List variable hold an ArrayList or a LinkedList without the caller changing. Abstraction: abstract classes and interfaces publish what an object does without the how, so implementations can change without breaking callers. Together they give code that is easier to extend than to modify - the reason interviewers keep asking.
Q: Write a SQL query showing departments with more than five employees and their average salary.
Aggregate with GROUP BY and filter the aggregate with HAVING: SELECT d.dept_name, COUNT(*) AS headcount, AVG(e.salary) AS avg_salary FROM employees e JOIN departments d ON e.dept_id = d.dept_id GROUP BY d.dept_name HAVING COUNT(*) > 5 ORDER BY avg_salary DESC; The distinction interviewers are testing is WHERE versus HAVING: WHERE filters individual rows before grouping, HAVING filters groups after aggregation, so a condition on COUNT or AVG can only live in HAVING. Note also that every non-aggregated column in the SELECT list must appear in the GROUP BY, and that COUNT(*) counts rows while COUNT(column) skips NULLs.
Q: What are the layers of the OSI model, and where do HTTP, TCP and IP sit?
The seven layers from top down are Application, Presentation, Session, Transport, Network, Data Link and Physical. HTTP is an Application-layer protocol; TLS sits at the Presentation layer in the OSI mapping; TCP and UDP are Transport-layer, adding ports and, for TCP, reliability; IP is Network-layer, handling logical addressing and routing between networks; Ethernet and MAC addressing are Data Link, handling delivery within one network segment; and the Physical layer is the actual signalling. The practical TCP/IP model collapses this into four layers - Application, Transport, Internet and Network Access. The concrete detail to be able to state is that a router works at layer 3 using IP addresses, while a switch works at layer 2 using MAC addresses.
Q: What is the difference between a mutex and a semaphore?
A mutex is a locking mechanism for mutual exclusion: exactly one thread holds it at a time, and it has ownership, meaning only the thread that locked it may unlock it. A semaphore is a signalling mechanism holding a counter: wait decrements and blocks at zero, signal increments and wakes a waiter, and it has no ownership, so one thread can signal what another waits on. A counting semaphore initialised to N limits concurrent access to N units of a resource - for example ten database connections in a pool. A binary semaphore looks like a mutex but is not the same thing, because the missing ownership rule means it cannot support priority inheritance and any thread can release it. Use a mutex to protect a critical section; use a semaphore to bound resource usage or to coordinate producer and consumer threads.
Frequently asked questions about Mphasis interviews
Section titled “Frequently asked questions about Mphasis interviews”What is the Mphasis interview process like for freshers?
Mphasis fresher hiring (Associate Software Engineer / Software Engineer) usually runs 3-4 stages: 1. Online assessment - quantitative aptitude, logical reasoning, verbal ability, technical MCQs and 1-2 easy-to-medium coding questions, 2. Group discussion or JAM (only in some campus drives), 3. Technical interview (30-45 min) - DSA, core CS subjects and your projects, sometimes split into a second managerial round, 4. HR interview (20-30 min) - background, motivation and role fit. Candidate reports put the end-to-end timeline at roughly 2-4 weeks. Patterns vary by drive, so confirm with your placement cell.
What questions are asked in the Mphasis interview?
Mphasis interviews commonly cover: Aptitude (quant, logical reasoning, verbal ability), Coding (1-2 easy-to-medium problems on arrays, strings, linked lists and trees - reported examples include level-order traversal of a binary tree and cycle detection in a linked list), Core CS (OOPs, DBMS and SQL queries, operating systems, computer networks), Language basics (Java, Python or C++ depending on your resume), Project discussion (stack choices, your actual contribution, hardest bug), and HR questions (Why Mphasis?, relocation and shift flexibility, career goals).
How many rounds are there in the Mphasis interview?
Most Mphasis fresher drives have 3 to 4 rounds: online assessment, an optional group discussion or JAM round, one or two technical interviews (a managerial round is added in some drives), and an HR interview. Some off-campus processes start with a short recruiter screening call instead of a GD. The exact round list changes by campus and year.
What is the Mphasis technical interview like?
The Mphasis technical interview typically lasts 30-45 minutes and covers: DSA - arrays, strings, linked lists, stacks, queues and basic tree problems, with a focus on approach and complexity, Core CS - OOPs concepts, DBMS and SQL joins/aggregations, operating systems, computer networks, Programming language - fundamentals of whichever language you claim on your resume (Java, Python, C or C++), Projects - architecture, your specific contribution and what you would change. Interviewers generally care more about how you reason through a problem than about a perfect first answer.