Capgemini Exceller Previous Year Questions & Sample Paper

Capgemini Exceller previous year papers are most useful for one thing: the patterns they reveal. Exact questions rarely repeat across drives, but the shapes do, and knowing them tells you what to drill.

There is a catch in 2026. The framework changed, so many older sample papers show only pseudocode and quant and miss the newer AI Literacy and AI-assisted stages. This guide covers the real patterns per section and how to practise them without chasing a leaked answer key. For the full structure, start with the Capgemini Exceller framework guide.

What previous-year Capgemini Exceller papers tell you

Capgemini rotates its question bank across drives, which it runs through the Exceller program described on its technical graduates page. So the honest read on any previous-year paper is this: it is a pattern map, not a preview. Use it to learn the format and pace, then practise the underlying skills.

The examples in this guide are illustrative of the question types, written by FACE Prep to show format. They are not reproduced from any Capgemini paper.

Technical module: question patterns

The technical section repeats a small set of predictable patterns, which is good news for focused prep:

• Pseudocode output tracing: read a loop or nested condition and select the output.
• DSA on arrays and strings: duplicates, reversals, and simple searches.
• Hashing, sorting, and complexity: pick the time or space complexity of a snippet.
• CS fundamentals: the right SQL clause, an OOP concept, or a DBMS definition.

Our Capgemini placement papers with solutions collection is built around these repeating patterns, which makes it a practical drill set for this section.

AI Literacy: what recent questions look like

AI Literacy is the newest part of the paper, and older samples skip it entirely. The question style is conceptual, not code:

• Concept type: identify which limitation of a language model a short scenario shows.
• Prompt type: choose the clearer, better-structured prompt for a stated task.
• Responsible-AI type: pick the safe practice, such as validating output before trusting it.

A few hours on generative-AI basics covers most of this. The Capgemini technical assessment guide breaks the section down in full.

Debugging and coding: sample patterns

The code stages follow set shapes. Debugging gives you a broken snippet to fix; the coding component asks for one to two problems in C, C++, or Java under a tight timer. The recurring topics:

• Arrays and strings: manipulation and traversal.
• Hashing and searching: lookups and counts.
• Recursion and simple greedy logic.
• Boundary handling: empty input, single element, and the largest case.

Practise fixing broken code, not only writing new code, since the debugging stage tests a different skill from authoring.

Communication and cognitive: format recap

These stages are not question-bank rounds, so sample papers help less. Communication is AI-scored across listening, speaking, reading, and writing. The cognitive stage uses timed games for memory, attention, and reasoning. For both, format familiarity and timed practice beat any paper.

Why old sample papers can mislead you

A previous-year paper is only as useful as it is current, and 2026 is a year where that matters. The framework changed, so a paper from an older drive can send you in the wrong direction in two ways.

First, it can show sections that have moved or been renamed. Older Capgemini papers lead with pseudocode and quantitative aptitude and stop there. The current technical module keeps the pseudocode-style tracing but adds an AI Literacy section that older papers do not contain. Practise only the old paper and you walk in blind to a whole section.

Second, an old paper can set the wrong expectation for the coding stages. Earlier guides sometimes treated coding as optional or bolted-on. In recent drives, candidate reports describe debugging and coding as central, and as the main separator between the Analyst and Senior Analyst package tiers. A sample that underplays code will underprepare you for where the marks and the money actually sit.

The fix is not to discard old papers. It is to date them. Use an older paper for the patterns that have not changed, such as array and string logic, DBMS and OOP fundamentals, and output tracing. Then layer current practice on top for AI Literacy and the code stages. A paper is a pattern map, and a map from last year is still useful for the roads that did not move.

How to use sample papers well

Sit them timed, one section at a time. Mark every pattern you missed, then drill those specific weak areas before your next mock. Aim for a steady pace of about one minute per question in the technical section, since slow reading is what runs candidates out of time. Capgemini notes in its recruitment process guidance that steps vary by drive, so treat any sample as a pattern guide.

A simple routine turns papers into progress. Sit one full technical section under a timer, then score it honestly and sort your misses into buckets: tracing errors, weak fundamentals, unfamiliar AI Literacy concepts. Spend your next few study sessions on the largest bucket only, and re-sit a fresh section a few days later to confirm the gap has closed. Repeat until no single bucket dominates. This diagnose-and-drill loop is far more effective than reading through paper after paper hoping to recognise a question, because it fixes the underlying skill rather than the surface memory.

One caution on sources. Different sites report slightly different section counts and timings, because these genuinely vary by drive and year. Do not treat any single figure as fixed. Use the numbers to practise pace, and confirm the current specifics with your placement cell before your drive.

Once you have found your weakest section, go deep on it: the technical assessment guide for AI Literacy and DSA, and the placement-papers set for tracing practice. Start with a full timed technical section today, because the gap it reveals is the most useful thing a previous-year paper can give you.