Why understanding the pattern matters

Cracking Cognizant is about matching your preparation to what the company actually tests. When you know the pattern and the typical problem types, you stop wasting time on irrelevant topics and start building speed and accuracy in the right areas.

Quick pattern snapshot

  • Numerical Ability: ~30 questions, 30 minutes. High speed required.

  • Technical assessment: SQL (date/experience/filters & aggregates), Java coding problems (algorithmic / string & array operations), Web UI basics.

  • Interview rounds: Standard technical + HR follow-ups after the assessments.

Section-wise breakdown & how to attack each part

1) Numerical Ability — what appears and how to practice

Topics to master: Number System, LCM & HCF, Divisibility, Fractions & Decimals, Percentages, Averages, Ratios & Proportions, Algebraic Expressions, Simple & Compound Interest, Time/Speed/Distance (including Boats & Streams), Work & Time, Profit & Loss, Data Interpretation (pie chart types), Simplification, Probability, Permutations & Combinations.

Strategy

  • Daily timed drills. Since the section is strictly timed, practice 10–15 minute micro-tests focused on one topic (e.g., percentages only).

  • Prioritize low-time, high-accuracy topics first during the exam (percentages, averages, ratios) — these are quick scoring opportunities.

  • Master shortcuts but verify correctness. Use algebraic rearrangement and mental math for simplifications rather than blind tricks that break for edge cases.

  • DI practice: Pie charts are common. Practice reading values, converting percentages to absolute numbers, and spotting which slices to combine for comparison questions.

Exam tip: Skip a DI chart that looks dense on first view; mark and return if time remains. You get more marks solving several quick arithmetic problems than burning time on one complex chart.

2) Technical assessment — SQL, Java and Web UI (what to focus on)

SQL — what Cognizant expects

Your PPT lists SQL tasks that check conditional filters, date comparisons, and numeric thresholds (for example: employees with >5 years experience and joining after 2001-01-01; list employees with provident fund > 5000). These are typical of Cognizant’s expectation for practical, business-oriented queries.

Core SQL topics to be comfortable with

  • SELECT, WHERE with multiple conditions, aliasing columns, JOINs (inner/left), GROUP BY + HAVING, date comparisons, aggregate functions (SUM, COUNT, AVG), and basic subqueries.

Practical practice

  • Write queries on small sample schemas (employees, orders, products). Practice textually explaining your query in one sentence — that helps in interviews.

  • Practice date filtering: converting and comparing dates (e.g., join_date > '2001-01-01') and computing experience using DATEDIFF or equivalent if required.

Java coding — focus areas

The PPT indicates Java coding is part of the technical cluster. Expect medium difficulty problems on arrays, strings, and small algorithmic tasks that test logical clarity and clean OOP usage.

Skills to polish

  • Array traversal and two-pointer patterns, string manipulations, hashing for frequency problems, basic sorting and searching, and writing readable functions with clear method signatures.

  • Basic data structures (arrays, lists, maps) and solid understanding of time/space trade-offs.

Practice routine

  • For each problem, write a clean solution, then optimize. Time yourself until you can code a working solution in 25–35 minutes (including dry run). Use small, reproducible test cases to verify logic quickly.

Web UI basics

Expect conceptual questions on HTML, CSS and JavaScript fundamentals — not deep front-end frameworks. Know the DOM basics, simple event handling, and semantic HTML.

A study roadmap (8-week plan you can adapt)

Weeks 1–2: Foundation & speed

  • Daily: 45–60 minutes aptitude micro-tests (focus on percentages, ratios, simplification).

  • SQL basics: start with SELECT, WHERE, JOIN exercises for 30 minutes/day.

  • Java: solve 1 easy + 1 medium practice problem every day.

Weeks 3–4: Build depth

  • Combine topics into mixed timed tests (30 Q / 30 min).

  • Solve sample SQL business scenarios (experience filters, aggregate conditions).

  • Java: medium problems; start practicing explaining your solution in 2–3 lines.

Weeks 5–6: Mock tests & analysis

  • 2 full mocks per week that simulate test time limits; detailed error analysis after every test.

  • Focus on DI pie charts and questions that took the most time.

Weeks 7–8: Polish & interview prep

  • Revisit weak topics; memorize common SQL patterns.

  • Do pair programming or explain problems to a peer — teaching solidifies understanding.

  • Prepare concise answers for HR and technical interview questions (projects, internships, and the logic behind solutions).

Original practice set — solve these to match the exam style

Numerical (medium → hard)

  1. A shopkeeper marks up an item by 25% and then offers a discount of 20%. If the final price is ₹1,200, what was the original cost?

  2. In a pie chart, three sectors represent 30%, 45% and the remainder. If the largest sector represents 270 degrees of the circle, what is the total value represented by the chart assuming proportional distribution?

  3. Two trains start from A to B and B to A at the same time. One covers the route in 4 hours, the other in 6 hours. They cross after 1 hour. What fraction of the distance from A to B has the first train covered when they meet?

  4. From 10 men, how many committees of 3 can be formed such that at least one specific person is always included?

SQL (write the exact query or describe the logic)

  1.  Write a query to show Employee ID and Employee Name for employees with more than 5 years of experience who joined after 2001-01-01. (Hint: filter by experience > 5 and join_date > '2001-01-01', alias columns with the requested names.)

  2.  Display the names and categories of employees whose provident fund amount is greater than 5000. (Hint: WHERE provident_fund > 5000 and select required columns.)

Java (design the solution outline)

  1. Given an integer array, find the length of the longest subarray whose sum is 0. Describe the approach and time complexity.

  2. Given a string, return the first non-repeating character. Provide a short explanation of the algorithm and a code sketch.

(If you want, I can add full model solutions and runnable Java snippets for these — tell me and I’ll include them.)

Common mistakes and how to avoid them

  • Mistake: Spending too long on a single DI or algebra problem.
    Fix: Flag and move on — return only if time remains.

  • Mistake: Writing long, untested SQL in the test without running quick logic checks.
    Fix: Compose the query in parts: select + where, then add grouping/joins.

  • Mistake: Over-optimizing in interviews (trying fancy code when clear, correct code is enough).
    Fix: Start with a correct, readable solution; optimize only if time allows.

Short FAQ

Q: Is the numerical section always 30 questions in 30 minutes?
A: It’s the pattern to follow for preparation. Real drives can vary but preparing for this strict timing makes you ready for tighter windows.

Q: Which technical skill should I prioritize?
A: SQL fundamentals and Java basics (arrays, strings, simple algorithms). The PPT highlights both SQL and Java as core parts of the technical assessment.

Q: How many mock tests are enough?
A: Quality over quantity. Start with 5 full mocks for baseline, then 10+ as you refine — each mock must be followed by a focused error review.

Final advice

  1. Train under timed conditions to build speed: 30 Q in 30 minutes is a rhythm you must internalize.

  2. Keep short, clean notes for SQL query patterns and commonly used Java idioms — small notes become quick revision gold.