Capgemini Interview Questions

Four, in order: an online assessment, a coding round, a technical interview and an HR interview. Capgemini also lists a group discussion for select roles, so read your drive notification rather than assuming it applies. The online assessment and coding round are often scheduled on the same day, with the two interviews following after shortlisting.

Exceller is the banner Capgemini uses for its fresher engineering intake in India — the equivalent of TCS's NQT funnel or Cognizant's GenC family. It is a hiring programme rather than a job title: you apply to Exceller, sit the Exceller assessment pattern, and are mapped to a role and band afterwards. Treat the programme name as the thing that tells you which assessment pattern you will face.

Four: technical MCQs with pseudocode, an English and communication test, a game-based cognitive section, and a behavioural or PowerSkills section built from workplace scenarios. The technical section draws on data structures, OOP, DBMS and operating-system concepts. The mix matters — three of the four sections are not conventional aptitude, which is where most preparation goes wrong.

Treat every section as its own gate. Published breakdowns of the current pattern describe the stages as eliminatory: clearing one is what earns you the next, and a strong score in one does not compensate for failing another. The consequence is that the English and behavioural sections cannot be treated as padding around the technical rounds.

The old standalone logical-reasoning MCQ block has been replaced by the game-based cognitive section in recent cycles. Quantitative and verbal ability still appear, and reasoning is still being measured — through the games rather than through multiple choice. Practising reasoning MCQs is not wasted, but practising only reasoning MCQs will leave you unprepared for the round as it is actually delivered.

Two problems is the pattern most candidates report, at roughly medium difficulty, with C, C++, Java and Python as the usual language options. Counts and timings vary by drive, so take the figure in your own notification over any published one. The recurring topics are arrays, strings, hashing, recursion and greedy approaches — not dynamic programming or graph theory, so depth on the basics beats breadth.

Reported patterns for recent Exceller cycles tie the offer band to how many of the coding problems you solve — clearing neither, one, or both maps to progressively higher tracks. The bands themselves move by cycle and location, so your offer letter is the only authority on the number. The mechanism is the useful part: coding is where the package is decided, not the aptitude sections.

It is set per drive, not once for the company, and the notification for your drive is the authority. What it will always specify: the degrees accepted, the graduating batch years, a minimum percentage or CGPA across 10th, 12th and graduation, the policy on active backlogs, and the maximum permitted academic gap. Check all five before you spend a week preparing, because the backlog and gap clauses disqualify more candidates than the percentage floor does.

Fresher offers in Indian IT services commonly carry a service agreement, and the terms differ by cycle, role and location. Your offer letter is the only authority on whether one applies to you and what it says. Ask for the clause in writing before you sign, and read the exit terms specifically — the number that matters is what leaving early actually costs, not the stated duration.

Candidate reports cluster around 20 to 35 minutes, and it varies by panel. That is short enough that the interviewer will pick two or three threads and go deep on them rather than surveying your whole syllabus. In practice the threads are your project, one data-structures question and one database question, so prepare those three to interview depth rather than spreading effort evenly.

Reported at roughly 10 to 20 minutes, and it is a genuine filter rather than a formality. The questions concentrate on cultural fit, communication, and your willingness on night shifts and work location. A candidate who hedges on shift and relocation in a 12-minute conversation gives the round its clearest reason to say no.

Capgemini lists group discussion as a stage for select roles rather than for every intake, so it may or may not be in your process. Where it runs, it assesses communication, teamwork and analytical thinking — meaning the panel is watching how you handle other speakers as much as what you argue. Making space for a quieter participant registers more strongly than dominating the airtime.

The Exceller assessment pattern is a fresher funnel; lateral hiring skips it. An experienced process is typically a screening call, one or two technical rounds focused on your actual stack and delivery history, and a manager or HR discussion. Expect questions about what you owned rather than what you studied — the split of design versus implementation on your last project, and why specific decisions were taken.

Through the official candidate portal only. Capgemini states that interview communications come through its official systems, with Microsoft Teams invites, and not from personal email addresses. Any interview scheduled from a personal address, or any request for payment at any stage, is a recruitment scam and should be treated as one.

A short set of interactive games — commonly four, drawn from a larger pool, in roughly 20 to 30 minutes — that replaces the conventional reasoning MCQ block. You are not answering questions from a paper; you are playing timed exercises while the system records how you play. Reported names include the Grid Challenge, the Digit Challenge and the Motion Challenge.

Problem-solving, attention to detail, working memory and pattern identification. The important difference from an MCQ section is that behaviour is measured alongside outcome — how quickly you adapt after a wrong move, whether your accuracy holds as speed increases, how consistent you are across rounds. A score is being built from the pattern of your play, not just from a count of right answers.

You cannot revise content for it, because there is no syllabus. What transfers is familiarity with the format: play a few working-memory and pattern-recognition games beforehand so the interface is not new, and practise reading instructions once and correctly. Most avoidable loss in this round comes from spending the first attempts learning the rules.

Accurate, then fast. Several of these formats penalise errors more heavily than they reward volume, and an erratic pattern reads worse than a slower consistent one. Establish accuracy in the opening moves, then let speed rise only as far as it holds — a run of careless mistakes at high speed is the worst signal you can leave.

Assume not. Treat every game as single-attempt and read its instructions carefully before starting, because the practice round — where one exists — is short and is not always separated from the scored round. The practical consequence is that the instruction screen is worth more of your attention than it feels like at the time.

A scenario-based section that puts workplace situations to you and asks how you would respond — a slipping deadline, a disagreement with a teammate, an instruction you think is wrong. It has no right answers in the arithmetic sense, and it does check consistency: the same underlying trait is probed from several directions. Answer as one person rather than picking whatever sounds most professional each time.

Grammar, vocabulary, sentence correction and reading comprehension, and in some cycles a written or spoken component. It carries more weight at Capgemini than candidates expect, because much of the work is client-facing across time zones. Treat it as a scored round rather than a formality.

They give you a short language-neutral algorithm and ask what it outputs, or what a variable holds when it finishes. The reliable method is a trace table: write the variables as columns and each iteration as a row, then fill it in mechanically. Reading the code and reasoning about it in your head is where almost every wrong answer comes from.

It prints 2. Both operands are integers, so division truncates toward zero and the remainder is discarded — the 0.5 is lost, not rounded. Pseudocode sections test this repeatedly, usually inside a loop where the truncation compounds, so check the declared types of both operands before dividing.

Count how many times the innermost statement runs as a function of the input. Two independent loops each running n times give O(n²); a loop whose bound depends on the outer index gives about n²/2, which is still O(n²). When the inner variable is multiplied or divided rather than incremented, that loop is logarithmic and the answer is O(n log n).

Pre-increment (++i) updates the variable and then yields the new value; post-increment (i++) yields the current value and updates afterwards. Inside an array index or a condition, that one-step offset changes which element is touched and can shift a loop by a full iteration. In a trace table, record the value used and the value after separately rather than in one column.

With pass by value the function receives a copy, so changes do not survive the return; with pass by reference it receives the variable itself and changes persist. The question is usually built so that the two readings give different printed output. Identify which convention the pseudocode declares before tracing, because the trace is otherwise correct and the answer still wrong.

10 seconds. Convert 72 km/h to metres per second by multiplying by 5/18, which gives 20 m/s, then divide the 200 m length by 20. The thing to get right is the distance: passing a pole means covering the train's own length, while passing a platform means covering the train plus the platform.

7.2 hours. Work in rates rather than times: the pipes fill 1/12 and 1/18 of the tank per hour, summing to 5/36, so the tank fills in 36/5 hours. The same method handles an outlet pipe — subtract its rate instead of adding it.

Percentages and successive percentage change, profit and loss, ratio and proportion, averages, time and work, time speed and distance, simple and compound interest, and permutations with basic probability. The section rewards speed on standard forms rather than cleverness. Knowing that a 20% rise followed by a 20% fall leaves you 4% down saves more marks than any single formula.

Roughly a minute, since the section runs about 40 questions in 40 to 50 minutes — and pseudocode tracing eats far more than a minute. The workable approach is two passes: answer the definitional MCQs quickly on the first pass, then spend the remaining time on traces. Sitting on one trace for five minutes is the standard way to lose this section.

It prints 1. The mod operator returns the remainder after division, not the quotient — 10 divided by 3 is 3 with 1 left over. Watch for negative operands, where languages disagree on the sign of the result, and for mod 2 as the standard test for whether a number is even.

15, the sum of 1 through 5. The general form is n(n+1)/2, which is worth recognising because the section often asks for the sum to 100 or 1,000 where tracing by hand is not viable. Check whether the loop bound is inclusive: "to 5" and "below 5" differ by the last term.

12. The variable takes 3, 6, 9 and then 12, and only at 12 does the condition fail and the loop exit — so the printed value is past the bound, not the last value inside it. Off-by-one answers here come from assuming the loop stops at 9.

It prints 3 and 2. Post-increment hands over the old value and then increments, so b receives 2 while a becomes 3. Written as ++a instead, both would be 3. This is the most common single trap in the pseudocode section, usually buried inside a loop condition.

It returns the original string. Running i across the whole length swaps every pair twice, undoing the first pass, so the loop must stop at n/2. A middle character in an odd-length string needs no swap. The same half-range rule applies to reversing an array in place.

n(n+1)/2 times, because the inner loop runs once on the first pass, twice on the second, and so on. That is O(n squared) even though the inner bound is not n — a triangular loop is the usual way this section disguises quadratic complexity.

1, 3 and 5. The continue statement skips the rest of the current iteration and moves to the next, so the even values are never printed. Contrast it with break, which would abandon the loop entirely at i = 2 and print only 1.

3.5 and 3. The single slash performs true division and returns a float; the double slash floors the result to an integer. In C or Java, 7 / 2 on two integers already gives 3 — so the same expression yields different answers depending on the language the question implies.

It works arithmetically and needs no temporary variable, but it overflows if a + b exceeds the type's range, and it is slower to read than an explicit temp. The XOR variant has the same appeal and a worse failure: it zeroes the value when both operands are the same variable.

24. The calls unwind as 4 * 3 * 2 * 1, which is 4 factorial. Trace recursion by writing the stack downwards to the base case and then multiplying back up. The base case is what the question is really testing: without n <= 1 returning 1, the recursion never terminates.

[3, 1, 7, 9]. Only the 7 and 1 comparison triggers a swap. This is a single pass of bubble sort, and the array is not yet sorted — a full sort needs repeated passes until one completes with no swaps, which is what makes it O(n squared).

1. A do-while evaluates its condition after the body, so the body always runs at least once even when the condition is false from the start. A plain while loop with the same condition would never execute. Questions use this to test whether you read the loop form or only the condition.

Walk the string tracking the start of each word, and on each space copy the word you just finished onto the front of the result. One pass, O(n) time and O(n) space. The edge cases interviewers check are multiple consecutive spaces and leading or trailing whitespace, so decide whether you preserve or collapse them and say which.

Hold two variables, largest and second, both initialised below the minimum possible value, and update them as you scan: if the current element beats largest, second takes the old largest. O(n) time, O(1) space. State how you handle duplicates of the maximum — whether [5, 5, 3] answers 5 or 3 is a specification question, not a bug.

Use two pointers from both ends, skipping any non-alphanumeric character and comparing lowercased values, moving inwards until they meet. O(n) time, O(1) space. Reversing the string and comparing also works and is easier to write, but it costs O(n) extra space — mention both and say why you picked one.

Count every character in one pass into a map or a fixed 26-slot array, then scan the string again and return the first with a count of one. Two passes, O(n) time. Counting alone is not enough: the answer depends on original order, which is why the second pass walks the string rather than the map.

Keep a write index starting at 1 and scan from the second element, copying an element forward only when it differs from the one before it. The write index ends as the new length. O(n) time, O(1) space. It relies on the array being sorted — on unsorted input you need a set or a sort first.

Compute n(n+1)/2 and subtract the actual sum; the difference is the missing value. O(n) time, O(1) space, and one pass. XOR of the indices against the values does the same without any overflow risk, which is the follow-up when the interviewer points out that the sum can exceed an int for large n.

Compare character counts rather than sorting: one pass incrementing for the first string, one decrementing for the second, then confirm every count is zero. O(n) time against sorting's O(n log n). Length differing is an immediate no, and agree upfront whether case and spaces count.

Iterate with two variables, each step summing them and shifting along — O(n) time and O(1) space. For the nth term alone the loop is identical; nothing needs storing. The point of the question is usually to see whether you reach for naive recursion, which recomputes the same subproblems and costs exponential time.

Reduce k modulo the length first, then reverse the first k elements, reverse the rest, and reverse the whole array. O(n) time, O(1) space, three passes. The naive approach — shifting one position k times — is O(n times k) and is what the question is designed to catch.

Scan once with a set of the values already seen, and for each element check whether target minus that element is in the set. O(n) time, O(n) space. Sorting and walking two pointers inwards is O(n log n) with no extra space. Both beat the nested-loop scan, and duplicates need a decision on whether pairs may repeat.

Encapsulation — a BankAccount class keeping its balance private and exposing deposit and withdraw. Abstraction — a Payment interface whose callers do not know whether it settles by card or UPI. Inheritance — a SavingsAccount deriving from Account to reuse and specialise behaviour. Polymorphism — one draw() call resolving to Circle or Square at runtime. Interviewers almost always ask for an example from code you have written, so prepare one concrete case per pillar.

Overloading is several methods in the same class sharing a name but differing in parameters, resolved by the compiler from the argument types. Overriding is a subclass replacing an inherited method with the same signature, resolved at runtime by the actual object type. Overloading is compile-time polymorphism, overriding is runtime polymorphism — and only overriding participates in dynamic dispatch.

An abstract class can hold state, constructors and implemented methods, and a class may extend only one. An interface declares a contract, holds no instance state, and a class may implement many. Choose an abstract class when subclasses genuinely share implementation, and an interface when unrelated types need to be usable interchangeably.

Whenever the relationship is "has a" rather than "is a", and whenever you want to swap the collaborator later. Inheritance couples you to a base class permanently and its behaviour leaks into every subclass, so a deep hierarchy becomes hard to change safely. A Car holding an Engine can be given a different engine; a Car extending Engine cannot.

== compares references, asking whether two variables point at the same object; .equals() compares content as the class defines it. For Strings created with new, == is false while .equals() is true, which is the classic trap. If you override .equals() you must override hashCode() to match, or hash-based collections will behave incorrectly.

A list is mutable and a tuple is not. That makes tuples hashable, so they can serve as dictionary keys and set members, and it makes them a safer return type when callers should not modify the result. Tuples are also marginally cheaper to create, though immutability rather than speed is the reason to reach for one.

A shallow copy duplicates the outer container but keeps references to the same inner objects, so mutating a nested element shows up in both copies. A deep copy recursively duplicates everything and leaves the two fully independent. The bug this causes is a nested list or dictionary changing in an object you never touched.

A constructor initialises an object at creation and runs before any other method. If you write none, most languages supply a default no-argument constructor that leaves fields at their zero values. The moment you define any constructor, that default disappears — so adding a parameterised constructor can break code that relied on constructing with no arguments.

A static member belongs to the class and exists once regardless of how many objects are created; an instance member belongs to each object and exists per object. Static methods cannot reference instance state because there is no particular object in scope. Mutable static state is also shared across threads, which makes it a common source of concurrency bugs.

Exception handling separates the error path from the normal path using try, catch and finally, so a failure is dealt with where it can be handled rather than crashing the program. Checked exceptions must be declared or caught and represent recoverable conditions such as a missing file; unchecked exceptions represent programming errors such as a null dereference. Catching a broad exception and doing nothing is worse than not catching it, because the failure becomes silent.

An array stores elements contiguously, giving O(1) indexing but O(n) insertion or deletion in the middle and a fixed capacity. A linked list stores nodes with pointers, giving O(1) insertion once you hold the node but O(n) access and worse cache behaviour. Arrays win when you read by index; linked lists win when you rearrange often and already have the position.

Use two pointers, one at each end, swap the characters they reference, then move them toward each other until they meet. That is O(n) time and O(1) extra space. Watch for whether the language even permits it — Java and Python strings are immutable, so "in place" there means converting to a character array or list first.

Iterate once, keeping a hash set of what you have seen, and report any element already present — O(n) time and O(n) space. If extra space is not allowed, sorting first makes duplicates adjacent at O(n log n) time. When the values are known to lie in a fixed range such as 1 to n, you can mark positions inside the array itself and reach O(n) time with O(1) space.

A last-in, first-out structure with push, pop and peek, all O(1). It backs function call management, expression evaluation and bracket matching, undo history, and the iterative form of depth-first search. The giveaway in an interview question is any requirement to process the most recent item first, or to match nested pairs.

A queue is first-in, first-out and a stack is last-in, first-out. That single difference decides traversal order: a queue gives breadth-first search, a stack gives depth-first. Queues model anything processed in arrival order, such as a task or print buffer.

It compares the middle element to the target and discards the half that cannot contain it, repeating until the range is empty — O(log n). It requires the input to be sorted, which is the condition interviewers check that you state. Compute the midpoint as low + (high - low) / 2 rather than (low + high) / 2 to avoid overflow on large bounds.

Bubble sort is O(n²) in the average and worst case and is only ever a teaching example. Merge sort is O(n log n) in all cases but needs O(n) extra space and is stable. Quick sort averages O(n log n) in place but degrades to O(n²) on a bad pivot, which is why real implementations randomise or use median-of-three.

A hash table maps a key to a bucket index through a hash function, giving average O(1) lookup and insertion. Collisions — two keys landing in one bucket — are handled either by chaining, where the bucket holds a list, or by open addressing, where the entry probes for the next free slot. With a poor hash function or a heavily loaded table, lookups degrade toward O(n).

Floyd's algorithm: advance one pointer by a single node and another by two. If they ever meet, there is a cycle; if the fast pointer reaches the end, there is not. It runs in O(n) time with O(1) space, which is what makes it preferable to keeping a set of visited nodes.

DELETE removes rows one at a time against an optional WHERE clause, is logged, and can be rolled back. TRUNCATE removes every row as a single operation, is much faster, and does not fire row-level triggers. DROP removes the table definition itself along with its data, indexes and constraints.

An INNER JOIN returns only rows with a match on both sides. A LEFT JOIN returns every row from the left table, filling the right-hand columns with NULL where no match exists. The common bug is putting a condition on the right table in the WHERE clause, which discards those NULL rows and silently turns the LEFT JOIN back into an INNER JOIN — the condition belongs in the ON clause.

WHERE filters individual rows before grouping; HAVING filters groups after aggregation. That is why an aggregate such as COUNT(*) > 5 can appear in HAVING but not in WHERE. Filtering in WHERE where possible is also faster, because fewer rows reach the grouping step.

SELECT MAX(salary) FROM employee WHERE salary < (SELECT MAX(salary) FROM employee). It handles duplicates of the top salary correctly, which a naive ORDER BY with OFFSET does not. The window-function form is DENSE_RANK() OVER (ORDER BY salary DESC), filtered to rank 2.

A primary key uniquely identifies each row, cannot be NULL, and a table has exactly one. A unique key also enforces uniqueness but permits a NULL and a table may have several. Both are typically backed by an index, so both help lookups on those columns.

Normalisation organises columns and tables to remove redundancy and the update anomalies it causes. 1NF requires atomic values with no repeating groups. 2NF additionally requires every non-key column to depend on the whole primary key, not part of it. 3NF additionally removes transitive dependencies, where a non-key column depends on another non-key column.

Atomicity — a transaction completes entirely or not at all. Consistency — it moves the database from one valid state to another, respecting every constraint. Isolation — concurrent transactions do not observe each other's partial work. Durability — once committed, the change survives a crash. Isolation is the one with levels you choose between, trading strictness against concurrency.

An index is a secondary structure, usually a B-tree, that lets the engine find rows without scanning the table, turning an O(n) scan into roughly O(log n). It costs storage and slows every INSERT, UPDATE and DELETE, because the index must be maintained too. On a write-heavy table, or on a low-cardinality column such as a boolean flag, an index can cost more than it returns.

SQL databases use a fixed relational schema with joins and strong transactional guarantees, and scale primarily by making one machine bigger. NoSQL databases relax the schema and often the consistency model in exchange for horizontal scaling across many machines. The choice follows the access pattern: relational for data with genuine relationships and reporting needs, NoSQL for high-volume documents or key-value lookups with a known query shape.

A process is an independent program with its own memory space; a thread is a unit of execution inside a process, sharing that memory with its siblings. Threads are cheaper to create and switch between, and communicate directly through shared memory. That sharing is also why threads need synchronisation and processes largely do not.

A deadlock is a state where each of a set of processes waits for a resource another holds, so none can proceed. It requires all four of mutual exclusion, hold and wait, no preemption, and circular wait. Breaking any one prevents it — the usual practical fix is imposing a global order in which locks must be acquired, which eliminates circular wait.

An abstraction that gives each process its own contiguous address space larger than physical RAM, with pages moved between memory and disk as needed. It isolates processes from each other and lets a program run without fitting entirely in RAM. The cost is paging: when the working set exceeds physical memory the system thrashes, spending more time swapping than computing.

TCP is connection-oriented and reliable — it sequences packets, acknowledges them, retransmits losses and controls congestion. UDP is connectionless and does none of that, so it is faster and has lower overhead but may lose or reorder data. Web pages, email and file transfer use TCP; live video, voice and gaming prefer UDP, where a late packet is worth less than a dropped one.

The browser resolves the hostname to an IP address through DNS, opens a TCP connection to that address, completes a TLS handshake for HTTPS, and sends an HTTP request. The server returns HTML, which the browser parses while fetching the CSS, JavaScript and images it references, then renders the page. Interviewers use this to see how many layers you can name without prompting.

Authentication establishes who you are; authorisation establishes what you are permitted to do. Authentication always comes first, and a system can authenticate you successfully and still refuse the action. Conflating them is how privilege-escalation bugs get written — a logged-in user is not the same thing as a user allowed to edit that record.

HTTPS is HTTP carried inside a TLS-encrypted connection, so traffic cannot be read or altered in transit and the server proves its identity with a certificate. HTTP sends everything in plain text, including credentials and session tokens. The cost is a handshake at connection setup, which modern TLS versions and session resumption have made small.

Lead with the problem and who had it, then your architecture in two or three sentences, then your specific contribution, then one decision you would now make differently. Keep the opening under ninety seconds and let the interviewer choose where to go deeper. Candidates lose this thread by narrating features chronologically instead of stating what the project was for.

Say so plainly — it is common and not a weakness. Describe how you split the work across phases, what you had to learn from scratch, and where you got unstuck. An honest solo account interviews far better than an invented team, because a claimed teammate invites questions you cannot answer.

Give the real reason, including a constraint if that was it: familiarity, a library that solved the core problem, or what the team already ran. Then name one trade-off you accepted. "It was what I knew, and the project needed to ship in six weeks" is a better answer than an invented performance benchmark, because the interviewer is testing whether you reason about decisions at all.

Pick one you genuinely debugged rather than the most technically impressive. Describe the symptom, what you first believed was wrong, how you narrowed it down, and what the cause turned out to be. The method is what is being assessed — a candidate who reproduced the bug and bisected the change set demonstrates more than one who says the fix was a single line.

Restate the scenario in your own words, ask one clarifying question, then reason aloud toward an answer rather than jumping to a conclusion. These questions usually have no single correct response, so your path through it is the content. Saying which assumption you are making keeps you from being marked wrong for a reading the interviewer did not intend.

Give about sixty to ninety seconds: your degree and specialisation, one project or internship with what you actually built, the skills you want to work on, and why this role. Do not recite your résumé top to bottom — the interviewer has it. Close on something that invites the next question, such as the project you are proudest of.

Name something specific and checkable: the scale of its consulting and engineering work, the domains it delivers in, a service line that matches your interest, or the exposure that comes from client-facing delivery. Then connect it to what you want to learn in your first two years. Answers that would fit any employer are the most common way this question is failed.

Answer directly, because the round is genuinely checking it — global delivery means some teams overlap with client time zones. If yes, say yes without qualification. If you have a real constraint, state it plainly along with what you can do, since a clear boundary is easier to staff around than a vague one discovered after joining.

Say yes if you are, and name the locations you would prefer only after that. Capgemini staffs across several Indian cities and placement follows project need, so an unqualified no substantially narrows what you can be offered. If you have a genuine constraint such as a dependent, say so once, factually.

Give one strength with evidence — a strength you can point to in your project is worth more than three adjectives. For the weakness, name a real one and the specific thing you are doing about it. Disguised strengths such as "I am a perfectionist" are recognised instantly and read as evasion.

Describe a direction rather than a title: deeper technical ownership, a domain you want to specialise in, or moving from building features to designing systems. Tie it to something the company plausibly offers. Naming a specific senior job title tends to land badly, because it reads as a plan made without knowing the work.

Match two or three things about yourself to what the role needs, and give evidence for each. For a fresher role that is usually a technical base you can demonstrate, something showing you learn quickly, and a project where you delivered under a deadline. Close on what you would contribute in the first six months, not on how much you want the job.

Use a real, small example and the STAR shape: the situation, what you needed to resolve, what you specifically did, and how it ended. Good answers usually involve separating the disagreement from the person and finding the shared constraint, such as a deadline both sides cared about. Claiming you have never had a disagreement is the weakest available answer.

Ask two, and make them about the work: how a fresher is allocated to a project and how soon, what the training period covers, or what the team you would join is delivering. This is also where you ask any process question you need answered in writing. Asking nothing reads as no interest in the job you have just spent four rounds pursuing.