Real Mphasis interview questions - candidate interview experiences and HR round prep, in one place.
Explore: Interview experience · HR interview questions · Overview · Placement papers · Preparation guide
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.
Interview experience
Mphasis interview experiences covering Online Assessment, Group Discussion / JAM (some campuses), Technical Interview, Managerial round (some drives), +1 more. Round-wise notes, common questions, and what candidates report clears each stage.
HR interview questions
Mphasis HR interview questions with sample answer frameworks - motivation, relocation, STAR stories, and culture-fit prompts.
| 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 |
These answers are compiled from public candidate reports and prep guides, not from an official notice, and drives differ. The instruction screen of your own test is the final word.
| Question | Answer |
|---|---|
| How many questions and how long? | About 95-100 MCQs in 120 minutes. 2025-26 prep pages list 25 each for logical reasoning, quantitative aptitude and verbal ability, plus 20 (placementpreparation.io) or 25 (PrepInsta) computer-programming MCQs. Some drives add a separate coding block. |
| Does it have negative marking? | No. PrepInsta and placementpreparation.io both list no negative marking on the Mphasis MCQs, so attempt every question. |
| Is there a sectional cutoff? | Yes. Candidates must clear each section separately, and missing one usually ends the process even with strong scores elsewhere. Mphasis does not publish the values; PrepInsta’s 2025 page estimates about 60 percent each for quant, verbal and logical. |
| How much is the cutoff? | Not published; shortlists depend on the drive. PrepInsta’s 2025 drive listing asks for 60 percent throughout and no backlogs for BE/BTech/MCA in CS, IT, ECE, telecom and EEE. Gap rules are not published, so check your drive mail. |
| Which platform is it on? | AMCAT for most drives, though some drives use other platforms. Your invite names the platform. |
| Is there coding? | Reports conflict. placementpreparation.io says some drives add 2 problems in 45 minutes in C, C++, Java or Python; PrepInsta’s 2025 pattern has no coding round, only programming MCQs. Some batches report Automata Fix instead, where you debug pre-written code in about 20 minutes. |
| Is there a bond? | Yes, by candidate reports, though Mphasis does not publish the terms. A December 2024 Glassdoor report says HR asks whether you will sign the bond, and one 2026 account describes a 24-month training agreement. Read the terms in your offer letter. |
Most fresher hiring is for Associate Software Engineer, and the panel follows your resume language. These are topics candidates report in 2025-26 interview experiences; they show the level, not a fixed list.
| Area | Reported questions and topics |
|---|---|
| DSA and coding | Arrays, linked lists, stacks and queues with operations and time complexity; DFS and BFS explained; level-order traversal of a binary tree; cycle detection in a linked list; small snippets written live with screen share. |
| Language and code tracing | Data types, pointers and memory management, string operations, exception handling, and predicting the output of short C, C++ or Java snippets. |
| DBMS and SQL | Normalization, joins, ACID properties, and “write any SQL query”, often a GROUP BY with HAVING. |
| Projects | Final-year project objectives, tech stack, architecture, your own contribution and the challenges you hit. |
Asked in every interview: why Mphasis and what you know of its services, 3-5 year goals, strengths and weaknesses, a teamwork or pressure situation, and whether you will relocate to Bangalore, Chennai, Pune or Hyderabad and accept the bond.
Candidate reports consistently describe Mphasis fresher screening on AMCAT (not HackerRank): roughly 80-100 MCQs across logical reasoning, quantitative aptitude, verbal ability, and computer-programming fundamentals (output prediction, OOP, DBMS, data structures), often with sectional cutoffs set per drive. Total MCQ time is commonly 90-120 minutes; many drives add 1-2 coding problems (arrays, strings, basic logic) in a separate timed block. Partial credit on coding varies by year.
Some campus batches also report Automata Fix (roughly 20 minutes): you locate and fix bugs in pre-written code rather than writing from scratch. Others include SWAR/SVAR, an automated spoken-English assessment (~20-25 minutes, multiple stages) that can eliminate candidates before interviews if fluency or pronunciation falls below the cutoff. There is typically no negative marking on MCQs, but missing one sectional cutoff usually ends the process regardless of strong scores elsewhere.
Prep focus: timed sectional mocks (especially verbal, which catches quant-heavy prep), one language drilled for both MCQs and small programs, and honest communication practice if your drive mail mentions voice assessment.
Campus drives are the process this page focuses on: an AMCAT-style online test with sectional cutoffs, sometimes Automata Fix or a SWAR/SVAR spoken-English test, an optional group discussion or JAM round, a technical interview and HR. The placement cell sets eligibility and dates, and the offer usually comes within 2-4 weeks.
Off-campus and pool drives often skip the group discussion and start with a short recruiter screening call before the online test and interviews. Experienced hires go through role-specific technical rounds rather than the fresher AMCAT test. Whichever route you take, the drive mail is the final word on rounds, platform and bond terms.
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.
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.
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.
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.
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.
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.
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.
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.
Use Floyd’s tortoise-and-hare algorithm: advance a slow pointer one node at a time and a fast pointer two nodes at a time. If the list has a cycle, the fast pointer eventually laps the slow pointer and they meet inside the loop; if the fast pointer reaches null, there is no cycle. That is O(n) time and O(1) space. To find where the cycle starts, reset one pointer to the head and move both one step at a time; the meeting point after the reset is the cycle entry node. Interviewers often ask for both detection and entry-point recovery.
One portable pattern: SELECT MAX(salary) AS second_highest FROM employees WHERE salary < (SELECT MAX(salary) FROM employees); For ties, use SELECT DISTINCT salary FROM employees ORDER BY salary DESC LIMIT 1 OFFSET 1; (dialect-dependent). Window functions are the cleaner interview answer: SELECT salary FROM (SELECT salary, DENSE_RANK() OVER (ORDER BY salary DESC) AS rnk FROM employees) t WHERE rnk = 2; Be ready to explain NULL when fewer than two distinct salaries exist.
A process is an independent execution unit with its own address space, file descriptors, and OS bookkeeping; creating one is relatively expensive. A thread is a lightweight unit of execution inside a process that shares the process memory but has its own stack and program counter, so threads communicate cheaply through shared variables but need synchronisation to avoid races. Multiple threads in one process can run concurrently on multi-core CPUs; a crash in one thread can take down the whole process unless isolation mechanisms exist.
The browser parses the URL, checks cache/HSTS, resolves the host via DNS (recursive resolver to authoritative servers), opens a TCP connection (often TLS handshake for HTTPS), sends an HTTP request, receives the response, and renders HTML while fetching subresources. Mention that DNS returns an IP address, TCP provides reliable delivery, and HTTP is the application-layer request/response protocol; load balancers and CDNs may sit in front of the origin server.
When values lie in the range 1..n for an array of length n, mark presence by negating the value at index (value - 1) on first visit; a second visit finds an index already negative, signalling a duplicate. That uses O(1) extra space but mutates input. If mutation is forbidden, sort first (O(n log n)) and scan adjacent pairs, or use a hash set when extra space is allowed - state the constraint before picking an approach.
First normal form: atomic columns, no repeating groups. Second normal form: 1NF plus every non-key attribute depends on the whole primary key (no partial dependencies in composite keys). Third normal form: 2NF plus no transitive dependencies where a non-key attribute depends on another non-key attribute. Normalisation reduces redundancy and update anomalies; denormalisation is sometimes chosen deliberately for read performance - interviewers want you to know both directions.
An abstract class can hold state, constructors, both abstract and concrete methods, and supports single inheritance. An interface (Java 8+) can declare default and static methods but is primarily a contract of behaviour, and a class may implement multiple interfaces. Use an abstract class when subclasses share substantial common implementation; use an interface when you need a capability tag or multiple inheritance of type.
No. Prep guides and candidate reports say the Mphasis AMCAT-style test has no negative marking, so attempt every question. Each section has its own unpublished cutoff, and missing one usually ends the process.
On some drives, yes. placementpreparation.io reports 2 problems in about 45 minutes in C, C++, Java or Python, usually arrays, strings or basic logic, while PrepInsta’s 2025 pattern lists only programming MCQs. Other batches get Automata Fix instead, where you debug pre-written code in about 20 minutes.
Mphasis fresher hiring (Associate Software Engineer / Software Engineer) usually runs 3-5 stages: 1. AMCAT-style online assessment - aptitude, verbal, programming MCQs, sectional cutoffs, and often 1-2 coding questions; some drives add Automata Fix (code debugging) or SWAR/SVAR spoken-English assessment, 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, relocation, shift flexibility and BFSI/client-fit questions. Candidate reports put the end-to-end timeline at roughly 2-4 weeks. Patterns vary by drive, so confirm with your placement cell and careers.mphasis.com.
Candidate reports describe an AMCAT-based test with roughly 80-100 MCQs across logical reasoning, quantitative aptitude, verbal ability and computer programming fundamentals, often timed around 90-120 minutes with sectional cutoffs. Many drives add 1-2 easy-to-medium coding problems. There is typically no negative marking on MCQs, but failing any sectional cutoff can eliminate you. Some batches also include Automata Fix (debug pre-written code) or a SWAR/SVAR voice round for spoken English.
Mostly DSA, core CS, your projects and HR fit. 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).
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.
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.
Good fit: You can finish a 90-minute mixed paper, you will move to Bengaluru if asked, and you can explain your project without reading the resume aloud.
Harder path: You padded the resume with frameworks you cannot spell; you skipped quant; you want only remote product work. Mphasis HR is a logistics-plus-fit round.
Use this as a default four-week loop before a mPhasis drive. Adjust to your invite timeline.
10-day crash version: Days 1-4 timed DSA, days 5-7 resume projects + CS fundamentals, days 8-9 mock interviews out loud, day 10 HR STAR stories on the HR page.
Candidate-reported fresher/early-career packages for mPhasis often cite Associate / ASE ~₹4-5 LPA (candidate-reported). Treat forum numbers as ranges, not guarantees - confirm the written offer letter for your team and location.
Interview process details and sample questions on this site are editorially organized from public candidate reports and hiring write-ups, with round structure, prep notes, and company-specific framing added by our team. For round-by-round stories, see the mPhasis interview experience page. For OA papers and coding drills, use mPhasis on placementpapers.app. OA quick answers and topic-wise questions draw on placementpreparation.io’s Mphasis recruitment-process page, PrepInsta’s Mphasis pattern and eligibility page (2025 drive), and 2024-2026 Glassdoor candidate reviews for Associate Software Engineer (read as search snippets).
