Cognizant Interview Questions & Placement Prep (2026)
Everything you need for the Cognizant hiring process across PAN India: eligibility rules for GenC PAT (₹4 LPA), GenC Pro (₹5.4 LPA) and GenC Next (₹6.75 LPA), both reported aptitude formats, the three technical clusters (Java+SQL+Web UI, Python+SQL+Cloud, C#+SQL+Web UI), repeated coding and SQL patterns, and full technical + HR interview preparation.
Communication assessment (~60 tasks / ~58 min) + Aptitude (80 Qs / 100 min or 30 MCQ + games / 80 min) + Technical cluster (105–120 min) + PI & HR
Last updated:
Exam Pattern
Communication assessment (~60 tasks / ~58 min) + Aptitude (80 Qs / 100 min or 30 MCQ + games / 80 min) + Technical cluster (105–120 min) + PI & HR
| Section | Questions | Time | Type | Difficulty |
|---|---|---|---|---|
| Registration & PPT | — | — | Info session | Non-elimination |
| Communication Assessment | ~60 tasks | ~58 min | AI / audio based | Elimination |
| Aptitude (Pattern A) | 80 (25 Quant + 35 Logical + 20 Verbal) | 100 min | MCQ | Elimination |
| Aptitude (Pattern B) | 30 MCQ + ~4 games | 80 min | MCQ + game-based | Elimination |
| Technical Assessment | Coding + SQL + Web UI / Cloud | 105–120 min | Cluster based | Elimination |
| Personal Interview | — | 25–40 min | Technical + project | Elimination |
| HR Interview | — | 10–20 min | HR | Elimination |
Section-Wise Syllabus
Everything that appears in the assessment, grouped by section.
0. Eligibility & Drive Rules
Who can apply
- • Degrees: B.E. / B.Tech / M.E. / M.Tech
- • Branches: CSE/IT, ECE, EEE, ME, CE, Bioengineering/Biosciences, Chemical Engineering, Physical Sciences
- • Location: PAN India
- • Bond: none mentioned
Academic criteria
- • GenC PAT & GenC Pro PA: minimum 60% throughout X, XII/diploma, UG and PG
- • GenC Next PA: minimum 70% throughout X, XII/diploma, UG and PG
- • Rounding 59.9% → 60% or 69.9% → 70% is NOT accepted
- • No standing arrears permitted
- • Must be willing to work from any Cognizant office, in assigned shifts and technology
Round status
- • Registration — non-elimination
- • Pre-Placement Talk (PPT) — non-elimination
- • English/Verbal, Aptitude, Technical, Personal Interview, HR — all elimination
What the PPT covers
- • Cognizant work culture and service lines
- • GenC, GenC Pro and GenC Next role mapping
- • Salary structure and joining conditions
- • Assessment rules
- • Work location and shift flexibility
- • Documents required at interview and onboarding
- • Listen for whether your batch gets ONE common test or a role-specific test — Cognizant often maps the role from performance in a common process
1. Communication Assessment (Elimination)
Pattern A — frequently reported (60 tasks / 58 min)
- • Reading sentences — 8 tasks
- • Repeat sentences — 16 tasks
- • Jumbled sentences — 10 tasks
- • Question and answer — 24 tasks
- • Storytelling — 2 tasks
Pattern B — also reported (~55–60 min)
- • Reading aloud — approx. 20–23 sentences
- • Grammar & sentence correction — approx. 30–35 questions
- • Listening comprehension — approx. 15–16 questions
- • Open-ended speaking — approx. 4 prompts
Topics to prepare
- • Reading aloud with correct pronunciation
- • Articles: a, an, the
- • Prepositions
- • Tenses
- • Subject–verb agreement
- • Active and passive voice
- • Direct and indirect speech
- • Sentence correction
- • Fill in the blanks
- • Vocabulary in context
- • Listening comprehension
- • Sentence rearrangement
- • Short story retelling
- • One-minute opinion speaking
Speaking strategy
- • Speak at a moderate speed; do not imitate an accent
- • Pronounce word endings clearly
- • Avoid fillers: 'umm', 'like', 'basically'
- • If you slip, continue instead of restarting
- • Practise with headphones and a quiet microphone
- • Record yourself reading aloud 15–20 minutes daily
- • Practise repeating increasingly long sentences
- • For open prompts speak 45–60 seconds with beginning, middle and conclusion
- • Clear, understandable English beats difficult vocabulary
2. Aptitude — Quantitative
Arithmetic
- • Percentages
- • Profit, loss and discount
- • Simple and compound interest
- • Ratio and proportion
- • Partnership
- • Averages
- • Mixtures and allegations
- • Time and work
- • Pipes and cisterns
- • Time, speed and distance
- • Boats and streams
- • Problems on ages
Number based
- • Number system
- • Divisibility
- • HCF and LCM
- • Remainders
- • Decimal and fractional calculations
- • Simplification
- • Surds and indices
- • Algebraic equations
- • Progressions
Advanced / engineering aptitude
- • Permutations and combinations
- • Probability
- • Geometry
- • Mensuration
- • Clocks
- • Calendars
- • Data interpretation
- • Tables, pie charts and bar graphs
High-priority order (study first)
- • 1. Percentages
- • 2. Ratio and proportion
- • 3. Profit, loss and discount
- • 4. Averages
- • 5. Time, work and pipes
- • 6. Time, speed and distance
- • 7. Number system and remainders
- • 8. Probability
- • 9. Permutations and combinations
- • 10. Data interpretation
3. Aptitude — Logical, Games & Verbal
Logical reasoning
- • Number and letter series
- • Word patterns
- • Coding-decoding
- • Analogies and classification
- • Blood relations
- • Direction sense
- • Seating arrangement
- • Puzzles
- • Syllogisms
- • Statement and conclusion
- • Data sufficiency
- • Venn diagrams
- • Ranking and ordering
- • Cubes, paper folding and spatial reasoning
- • Visual and pattern-based reasoning
Game-based aptitude (Pattern B)
- • Grid challenge — short-term visual memory
- • Motion/path challenge — spatial reasoning and shortest path
- • Switch challenge — rule identification, input-output logic
- • Digit challenge — mental arithmetic and working memory
- • Inductive pattern game — identify the next pattern
- • Deductive logic game — apply constraints systematically
- • Do not click randomly: games reward speed AND accuracy
Verbal ability
- • Synonyms and antonyms
- • Contextual vocabulary
- • Error identification
- • Sentence improvement
- • Sentence completion
- • Tenses, articles, prepositions, conjunctions
- • Subject–verb agreement
- • Active and passive voice
- • Direct and indirect speech
- • Reading comprehension
- • Para jumbles and sentence ordering
4. Technical Cluster 1 — Java + SQL + Web UI (~120 min)
Typical task split
- • 2 Java coding problems
- • 2 SQL queries
- • 1 Web UI task (HTML + CSS + JavaScript)
Java topics
- • Variables and data types
- • Operators
- • Conditional statements
- • Loops
- • Methods
- • Arrays
- • Strings and StringBuilder
- • Searching and sorting
- • Collections: ArrayList, HashMap, HashSet, Stack, Queue
- • Exception handling
- • Classes and objects
- • Inheritance, polymorphism, abstraction, encapsulation
- • Interfaces and constructors
- • Date and time APIs
- • Basic recursion
- • Time and space complexity
Web UI topics
- • HTML page structure
- • Forms and input validation
- • Tables, lists, links and images
- • Semantic HTML
- • CSS selectors and box model
- • Flexbox and basic responsive layout
- • JavaScript variables and functions
- • DOM selection and event handling
- • Form validation, arrays and objects
5. Technical Cluster 2 — Python + SQL + Cloud (~105 min)
Typical task split
- • 2 Python coding problems
- • 2 SQL queries
- • Cloud fundamentals MCQs
Python topics
- • Variables and data types
- • Strings and slicing
- • Lists, tuples, sets and dictionaries
- • Functions and lambda expressions
- • Recursion
- • Sorting and searching
- • File handling
- • Exception handling
- • Modules and libraries
- • Iterators and generators
- • OOP, inheritance and polymorphism
- • Basic data structures
- • Time complexity
Cloud fundamentals
- • Definition and characteristics of cloud computing
- • IaaS, PaaS and SaaS
- • Public, private, hybrid and community cloud
- • Virtual machines, containers, virtualisation
- • Scalability and elasticity
- • Availability and fault tolerance
- • Regions and availability zones
- • Compute, storage and database services
- • Object versus block storage
- • Identity and access management, basic security
- • Backup and disaster recovery
- • AWS, Azure and Google Cloud terminology
6. Technical Cluster 3 — C# + SQL + Web UI
C# / .NET
- • C# syntax and control flow
- • Classes and objects
- • Interfaces
- • Inheritance
- • Exception handling
- • Collections
- • LINQ basics
Plus
- • SQL joins and aggregation
- • Basic Web UI implementation (HTML, CSS, JavaScript)
- • Confirm cluster availability from the actual registration form
7. SQL (appears in every cluster)
Query syntax
- • SELECT and DISTINCT
- • WHERE
- • ORDER BY
- • GROUP BY and HAVING
- • Aggregate functions
- • Inner, left, right and self joins
- • Subqueries and correlated subqueries
- • CASE expressions
- • NULL handling
Database concepts
- • DDL, DML, DCL and TCL
- • Primary and foreign keys
- • Constraints
- • Views
- • Indexes
- • Normalisation
- • Transactions
Most Asked Topics
Highest-frequency areas across recent test papers.
Communication tasks
Sentence repetition, jumbled sentences, grammar correction, listening comprehension and 45–60 second storytelling.
Arithmetic core
Percentages, ratio, averages, profit & loss, time-work and time-speed-distance dominate the quantitative section.
Game-based reasoning
Grid memory, path finding, switch logic, digit challenge, inductive and deductive puzzles in the newer format.
Array & string coding
Move zeroes, first non-repeating character, Kadane's max subarray, anagram check and balanced parentheses recur most.
SQL ranking queries
Second/third highest salary via subquery or DENSE_RANK(), above-department-average salary and LEFT JOIN … IS NULL.
OOP theory
Overloading vs overriding, interface vs abstract class, four pillars with real examples.
Project deep dive
Architecture, database tables, authentication, hardest bug, testing and scaling — asked in every PI.
Flexibility questions
Willingness to relocate PAN India, work in any shift and any technology is explicitly checked.
Free Resources
Curated practice links per section.
Communication & Verbal
Aptitude & Reasoning
Coding (Java / Python / C#)
SQL, Cloud & Web UI
Interview experiences
50+ DSA Practice Problems
Solve in order — arrays and strings first, then sorting and recursion.
Strings (10)
- Reverse a string without a built-in reverse function
- Check whether a string is a palindrome
- Find the first non-repeating character
- Count the frequency of each character
- Remove duplicate characters while preserving order
- Check whether two strings are anagrams
- Count words in a sentence
- Find the longest word
- Longest substring without repeating characters
- Check balanced parentheses
Arrays (12)
- Find the largest and second-largest elements
- Find missing and duplicate numbers
- Move all zeroes to the end
- Remove duplicates from a sorted array
- Rotate an array
- Find a pair with a given sum
- Maximum subarray sum (Kadane's algorithm)
- Merge two sorted arrays
- Find the majority element
- Count the frequency of array elements
- Find the intersection of two arrays
- Basic matrix traversal problem
Searching, sorting & structures (5)
- Implement binary search
- Sort an array using a standard algorithm
- Implement a stack
- Implement a queue
- Use a hash map for frequency counting
Math & recursion (7)
- Fibonacci using iteration and recursion
- Factorial demonstrating recursion
- Convert decimal to binary
- Check Armstrong numbers
- Check prime numbers
- Check perfect numbers
- Validate date-related input
Previous Year Questions & Patterns
Repeat coding questions with the expected approach.
Communication — representative tasks
- Repeat: 'The development team will release the updated application after completing the security testing.' — preserve subject, tense, key nouns and sequence.
- Jumble: project / completed / successfully / the / team / has → 'The team has completed the project successfully.'
- Correct: 'Neither the manager nor the employees was available.' → '... nor the employees were available.'
- Listening: 'The company postponed the meeting because the client had not submitted the required documents.' Why was it postponed? → Because the client had not submitted the required documents.
- Storytelling prompt: 'Describe a time when you solved a difficult problem.' — use Situation, Problem, Action, Result, Learning.
Aptitude — worked examples
- A product costing ₹800 is sold at 15% profit → SP = 800 × 115/100 = ₹920.
- A finishes in 12 days, B in 18 days → 1/12 + 1/18 = 5/36, together 36/5 = 7.2 days.
- Boys : girls = 3 : 2, total 50 → boys = 50 × 3/5 = 30.
- Bag has 4 red and 6 blue balls → P(red) = 4/10 = 2/5.
- Syllogism: All programmers are learners; some learners are testers → 'Some programmers are testers' does NOT necessarily follow.
Coding — representative questions
- Move zeroes: [0,1,0,3,12] → [1,3,12,0,0]. Write index for non-zeros, then fill zeros. O(n) time, O(1) space.
- First non-repeating character: 'swiss' → 'w'. Frequency map, then rescan.
- Maximum subarray sum: [-2,1,-3,4,-1,2,1,-5,4] → 6 from [4,-1,2,1] using Kadane's algorithm.
- Anagram check: 'listen' & 'silent' → true. Frequency array or hash map (sorting acceptable for small input).
- Balanced parentheses: '{[()]}' → Balanced. Use a stack matching each closer with the latest opener.
Important note on PYQs
- Cognizant does not officially release papers — online 'actual papers' are candidate-recalled or reconstructed.
- Treat every PYQ set as a pattern reference, not guaranteed questions.
- Prepare the task types and topic clusters rather than memorising counts.
20+ SQL Query Bank
Write these out by hand — joins and subqueries are asked in both the test and the interview.
Ranking & salary queries
Second-highest salary (subquery)
SELECT MAX(salary) AS second_highest_salary
FROM employees
WHERE salary < (
SELECT MAX(salary)
FROM employees
);Second-highest salary (DENSE_RANK)
SELECT salary
FROM (
SELECT salary,
DENSE_RANK() OVER (ORDER BY salary DESC) AS rnk
FROM employees
) x
WHERE rnk = 2;Third-highest distinct salary
SELECT salary
FROM (
SELECT salary,
DENSE_RANK() OVER (ORDER BY salary DESC) AS rnk
FROM employees
) x
WHERE rnk = 3;Joins & aggregation
Employees earning above their department average
SELECT e.employee_id,
e.employee_name,
e.department_id,
e.salary
FROM employees e
JOIN (
SELECT department_id, AVG(salary) AS avg_salary
FROM employees
GROUP BY department_id
) d
ON e.department_id = d.department_id
WHERE e.salary > d.avg_salary;Departments with more than five employees
SELECT department_id, COUNT(*) AS employee_count
FROM employees
GROUP BY department_id
HAVING COUNT(*) > 5;Customers with no orders
SELECT c.customer_id, c.customer_name
FROM customers c
LEFT JOIN orders o
ON c.customer_id = o.customer_id
WHERE o.order_id IS NULL;Duplicate email addresses
SELECT email, COUNT(*) AS frequency
FROM users
GROUP BY email
HAVING COUNT(*) > 1;DBMS & Core Interview Q&A
Short answers you should be able to say out loud.
Difference between WHERE and HAVING?
WHERE filters rows before grouping; HAVING filters groups after GROUP BY and can use aggregates.
INNER JOIN vs LEFT JOIN?
INNER returns only matching rows; LEFT returns all left-table rows with NULLs where no match exists.
COUNT(*) vs COUNT(column)?
COUNT(*) counts all rows; COUNT(column) skips NULLs in that column.
What does COALESCE do?
Returns the first non-NULL value from its argument list — useful for replacing NULL aggregates with 0.
Primary key vs unique key?
Primary: one per table, NOT NULL. Unique: multiple allowed and can hold one NULL.
DELETE vs TRUNCATE vs DROP?
DELETE (DML) removes selected rows and can be rolled back; TRUNCATE (DDL) removes all rows quickly; DROP removes the table structure entirely.
What is normalisation?
Organising data to reduce redundancy and anomalies through 1NF, 2NF, 3NF and BCNF.
What is an index?
A structure that speeds up lookups at the cost of extra storage and slower writes.
What are ACID properties?
Atomicity, Consistency, Isolation and Durability — the guarantees of a reliable transaction.
View vs table?
A view is a stored query producing a virtual table; it holds no data of its own.
OOPs Concepts + 10 Code Snippets
Theory plus the exact snippets asked in the technical round.
Encapsulation
Bundle data with the methods that operate on it; keep fields private with public accessors.
Abstraction
Expose only what matters; hide implementation behind interfaces or abstract classes.
Inheritance
Derive a class from a base class to reuse and extend behaviour.
Polymorphism
Compile-time overloading versus runtime overriding.
Overloading vs overriding
Overloading: same name, different parameters, same class. Overriding: same signature, subclass replaces behaviour.
Interface vs abstract class
Interface: contract only (Java allows multiple). Abstract class: partial implementation plus state, single inheritance.
Constructors
Initialise objects; can be overloaded and chained.
Exception handling
try / catch / finally with checked and unchecked exceptions; never swallow errors silently.
1. Move zeroes (Java)
void moveZeroes(int[] a) {
int w = 0;
for (int v : a) if (v != 0) a[w++] = v;
while (w < a.length) a[w++] = 0;
}2. First non-repeating character (Java)
char firstUnique(String s) {
Map<Character, Integer> f = new LinkedHashMap<>();
for (char c : s.toCharArray()) f.merge(c, 1, Integer::sum);
for (char c : s.toCharArray()) if (f.get(c) == 1) return c;
return '_';
}3. Kadane's maximum subarray (Java)
int maxSubArray(int[] a) {
int best = a[0], cur = a[0];
for (int i = 1; i < a.length; i++) {
cur = Math.max(a[i], cur + a[i]);
best = Math.max(best, cur);
}
return best;
}4. Anagram check (Java)
boolean isAnagram(String a, String b) {
if (a.length() != b.length()) return false;
int[] f = new int[26];
for (int i = 0; i < a.length(); i++) { f[a.charAt(i) - 'a']++; f[b.charAt(i) - 'a']--; }
for (int v : f) if (v != 0) return false;
return true;
}5. Balanced parentheses (Java)
boolean isBalanced(String s) {
Deque<Character> st = new ArrayDeque<>();
String open = "([{", close = ")]}";
for (char c : s.toCharArray()) {
if (open.indexOf(c) >= 0) st.push(c);
else if (close.indexOf(c) >= 0) {
if (st.isEmpty() || open.indexOf(st.pop()) != close.indexOf(c)) return false;
}
}
return st.isEmpty();
}6. Encapsulation (Java)
class Account {
private double balance;
public void deposit(double amt) { if (amt > 0) balance += amt; }
public double getBalance() { return balance; }
}7. Interface vs abstract class (Java)
interface Payable { double pay(); }
abstract class Employee implements Payable {
protected String name;
abstract String role();
}8. Move zeroes (Python)
def move_zeroes(a):
w = 0
for v in a:
if v != 0:
a[w] = v
w += 1
for i in range(w, len(a)):
a[i] = 0
return a9. Frequency count (Python)
from collections import Counter
def first_unique(s):
f = Counter(s)
return next((c for c in s if f[c] == 1), None)10. LINQ basics (C#)
var topEarners = employees
.Where(e => e.Salary > 50000)
.OrderByDescending(e => e.Salary)
.Select(e => e.Name)
.ToList();Operating System Basics
Scheduling, deadlock and memory management essentials.
Operating Systems
- • Process versus thread; context switching cost.
- • Deadlock and its four necessary conditions.
- • Paging and segmentation.
- • Virtual memory and page replacement.
- • Scheduling algorithms: FCFS, SJF, SRTF, Round Robin, Priority.
- • Race conditions; mutex versus semaphore.
Computer Networks
- • OSI layers and their responsibilities.
- • TCP versus UDP.
- • HTTP versus HTTPS.
- • DNS resolution flow.
- • IP address versus MAC address.
- • Three-way TCP handshake.
- • Client-server architecture and REST API basics.
Role-specific emphasis
- • GenC PAT (₹4 LPA): basic aptitude, communication, programming fundamentals, one language, SQL basics, OOP, DBMS, OS and project.
- • GenC Pro (₹5.4 LPA): stronger technical performance — DSA, SQL, OOP, Web/Cloud, project depth and certifications.
- • GenC Next (₹6.75 LPA): medium-level DSA, two coding problems under time pressure, advanced SQL and the selected cluster (Web UI or Cloud).
- • Prepare at GenC Next level even if you only meet the 60% bar — role mapping often follows performance.
4-Week Preparation Roadmap
From zero to test-ready in 28 days.
Aptitude and Communication
- 30 quantitative questions
- 30 logical reasoning questions
- 20 verbal questions
- 20 minutes reading aloud
- 10 sentence-repetition exercises
- Two one-minute speaking recordings
Goal: Finish percentages, ratio, averages, profit & loss, number system, tenses, subject–verb agreement and sentence correction.
Programming and SQL
- Two array/string coding problems
- One searching or sorting problem
- Five SQL queries
- 30 minutes OOP revision
Goal: Finish arrays, strings, hashing, sorting, searching, stack & queue, joins, aggregation, subqueries, constraints and transactions.
Selected Technical Cluster
- Cluster 1: Java collections, exception handling, OOP, two Java programs, SQL joins/subqueries, one HTML/CSS/JS form task
- Cluster 2: Python data structures, functions & OOP, two Python programs, SQL joins/aggregation, cloud fundamentals
- Cluster 3: C# collections, OOP and exception handling, SQL, HTML/CSS/JavaScript
Goal: Be able to finish a cluster-style task set (2 coding + 2 SQL + UI/cloud) inside the time limit.
Full Mocks and Interviews
- Three communication mocks
- Three aptitude mocks
- Three 80–120 minute technical mocks
- Five SQL timed sets and five coding sessions
- Two technical and two HR mock interviews
Goal: After every mock log attempted vs correct, time lost, weak topics, failed test cases and SQL syntax errors.
Exam Day Strategy
Score targets and time allocation.
Section targets
- Communication: Moderate pace, clear endings, no fillers; never restart after a small slip.
- Quantitative: 25 Qs in ~35 min — secure arithmetic first, leave heavy DI for the end.
- Logical / Games: 35 Qs in ~45 min or 4 games in ~50 min — accuracy matters as much as speed.
- Verbal: 20 Qs in 20 min — one minute per question, do not re-read comprehension twice.
- Technical: Bank the two SQL queries first, then coding; a fully passing solution beats two partials.
- Interviews: Only claim resume technologies you can explain; answer relocation and shift questions with a clear yes.
Coding time split (50 min)
- SQL Q1 & Q2 — ~15 min total (fastest guaranteed marks)
- Coding Q1 — ~20 min (Easy: array/string)
- Coding Q2 — ~30 min (Medium: hashing/logic)
- Web UI or Cloud MCQs — ~25 min
- Buffer — ~10 min for edge cases and re-runs
Interview Process
What follows the online test.
Personal (Technical) Interview — Elimination
- • OOP principles with examples; overloading versus overriding; interface versus abstract class.
- • Stack versus queue; array versus linked list; binary search and when it applies.
- • Time complexity; why hash-table lookup is usually O(1); recursion and base conditions.
- • Write code live: palindrome, Fibonacci or prime check; explain sorting algorithms.
- • What happens when a Java/Python program raises an exception.
- • DBMS: normalisation (1NF/2NF/3NF), keys, joins, WHERE vs HAVING, indexes, ACID, commit/rollback, view vs table, second-highest salary query.
- • OS: process vs thread, context switching, deadlock, paging, virtual memory, scheduling, race conditions, mutex vs semaphore.
- • Networks: OSI layers, TCP vs UDP, HTTP vs HTTPS, DNS, IP vs MAC, three-way handshake, REST basics.
Project Discussion
- • What problem does it solve, and why this technology?
- • What was your individual contribution?
- • Explain the architecture and the database tables you created.
- • How did you handle authentication?
- • What was the most difficult bug and how did you test the application?
- • How would you scale it, and what would you improve in version two?
- • Never list a technology on your resume that you cannot explain.
HR Interview — Elimination
- • Tell me about yourself. Why Cognizant? Why should we hire you?
- • Why did you choose your engineering branch? Strengths and weaknesses?
- • Are you willing to relocate and work in shifts?
- • Where do you see yourself in three to five years?
- • Tell me about a team conflict, and about a failure and what you learned.
- • How do you learn a new technology? What do you know about Cognizant?
- • Do you have any questions for us?
- • For 'Why Cognizant?' connect large-scale projects, multi-domain exposure, training opportunities, your programming/database skills and your flexibility.
Mock Test Plan
Four simulations to run before the real test.
Mock 1 — Communication Simulation
- • 8 reading + 16 repetition + 10 jumbled + 24 Q&A + 2 storytelling
- • 58 minutes, headphones on, recorded for playback review
Mock 2 — Aptitude Pattern A
- • 25 Quant (35 min) + 35 Logical (45 min) + 20 Verbal (20 min)
- • Strict 100-minute timer
Mock 3 — Aptitude Pattern B
- • 30 quantitative MCQs in 30 min
- • 4 games in 50 min — grid, path, switch, digit
Mock 4 — Technical Cluster
- • 2 coding + 2 SQL + Web UI or cloud MCQs
- • 105–120 minutes without breaks
Mock 5 — Interview Simulation
- • Technical + project: 30 min
- • HR: 15 min covering relocation, shifts and motivation
Final Checklist
Tick all of these before test day.
Recent Interview Experiences
First-hand write-ups from students who actually sat the Cognizant Technology Solutions process.
Be the first to share a Cognizant Technology Solutions interview experience.
Frequently Asked Questions
What is the eligibility for Cognizant GenC, GenC Pro and GenC Next?
B.E./B.Tech/M.E./M.Tech across CSE/IT, ECE, EEE, ME, CE, Bioengineering/Biosciences, Chemical Engineering and Physical Sciences. GenC PAT and GenC Pro need 60% throughout X, XII/diploma, UG and PG; GenC Next needs 70% throughout. Rounding 59.9% to 60% or 69.9% to 70% is not accepted and no standing arrears are allowed.
What are the Cognizant packages for each role?
GenC PAT is approximately ₹4 LPA, GenC Pro PA is approximately ₹5.4 LPA and GenC Next PA is approximately ₹6.75 LPA. No bond is mentioned in the notice.
Which rounds are elimination rounds?
Registration and the pre-placement talk are non-elimination. The English/Verbal communication assessment, aptitude, technical assessment, personal interview and HR interview are all elimination rounds.
What is the Cognizant aptitude test pattern?
Two formats are reported. Pattern A: 25 numerical (35 min), 35 logical (45 min) and 20 verbal (20 min) — 80 questions in 100 minutes. Pattern B: 30 quantitative MCQs in 30 minutes plus about four cognitive games in 50 minutes. Prepare for both until your test invitation confirms the format.
What are the Cognizant technical clusters?
Cluster 1: Java + ANSI SQL + Web UI (~120 min, typically 2 Java problems, 2 SQL queries and one HTML/CSS/JS task). Cluster 2: Python + SQL + cloud fundamentals (~105 min). Cluster 3 (reported in some drives): C#/.NET + SQL + Web UI.
Are previous-year Cognizant papers available?
Cognizant does not officially release papers. Online collections are candidate-recalled or reconstructed, so use them as pattern references — practise the recurring coding, SQL, Web UI and cloud formats rather than memorising specific questions.
How long should I prepare for Cognizant?
Four focused weeks: Week 1 aptitude and communication, Week 2 programming and SQL, Week 3 your selected technical cluster, Week 4 full mocks and interview practice.
Want the full structured prep for Cognizant Technology Solutions?
The Premium Vault covers Aptitude, Core CS, DSA, SQL and HR rounds with module-wise courses and drill sheets.
Related Prep
Next steps chosen from the Cognizant Technology Solutions pattern and other IT Services (Mass Hiring) recruiters.
Other IT Services (Mass Hiring) companies
Core CS subjects for this pattern
DBMS & SQL Essentials
Normalisation, keys, transactions and the SQL queries asked in written rounds.
OOPs Essentials for Interviews
The four pillars with the exact code snippets interviewers ask you to explain.
Operating System Essentials
Processes, scheduling, deadlock and memory management in interview-ready form.