Most TCS NQT candidates take mock tests. Almost none take them the right way. The typical pattern: download a mock, sit through it in a distracted environment, score 65%, feel vaguely bad about it, repeat the same mock a week later, score 72%, feel vaguely better, and do nothing differently. The score goes up by 7 points because familiarity with those specific questions increased, not because any underlying capability improved. On actual NQT day with fresh questions in an unfamiliar environment, the underlying capability is exactly what it was after the first mock. This guide is about using mock tests the way they were designed to be used - as diagnostic instruments that identify specific weaknesses, and as training environments that build real performance under real conditions.

TCS Guide

The Role of Mock Tests in NQT Preparation

What Mocks Actually Do When Used Correctly

Mock tests serve three distinct functions in NQT preparation, and conflating them produces poor preparation decisions.

Function 1: Skill Measurement A mock measures your current performance level across all NQT sections. Taken honestly (no looking things up, strict time limits, exam conditions), a mock provides a data point: “At this moment in my preparation, I can answer approximately X Numerical questions correctly in 25 minutes, Y Verbal questions correctly, and Z Reasoning questions correctly.”

This measurement function is valuable only when the measurement is accurate. Mocks taken in relaxed conditions, with phone nearby, at 1.5x time, produce inflated measurements that mislead preparation decisions.

Function 2: Weakness Identification The analysis after a mock - specifically, examining which questions you got wrong and why - tells you what to study next. A candidate who answers 18 Numerical questions correctly but gets all five Time-Speed-Distance questions wrong learns something actionable: study TSD specifically, not “Numerical” generally.

Most candidates skip this function entirely. They note the total score and move on. This is the single biggest wasted opportunity in NQT preparation.

Function 3: Exam Simulation A mock taken under exact exam conditions - the right duration, no distractions, no external help, simulated exam environment - builds the psychological and physiological readiness for the actual exam. This includes building attention span for sustained testing, managing time pressure across multiple sections, and developing the emotional resilience to move past difficult questions without losing composure.

When Mocks Are NOT the Right Tool

Mocks are the wrong preparation tool when you do not yet have the foundational knowledge to make the errors meaningful.

A candidate who does not know how to solve Time-Speed-Distance problems will get TSD questions wrong in a mock. Looking at the analysis, they will note “I got TSD questions wrong.” But they cannot learn TSD from mock analysis alone - they need to study TSD from a preparation resource. The mock just measures a gap; it does not fill it.

The preparation sequence:

  1. Learn a topic from a structured resource (formulas, examples, conceptual understanding)
  2. Practice the topic through targeted problems (15-20 problems specifically on that topic)
  3. Take a topic mini-mock (5-10 questions on that topic, timed)
  4. Take a section mock (full Numerical section, 25 questions, 25 minutes)
  5. Take a full NQT mock (all sections in sequence)

Taking full mocks before completing steps 1-3 for the major topics is building on sand. The mock will show you what you don’t know, which you already know you don’t know. What you need is to know the topics, then verify with mocks.

Phase 1: Topic-Wise Mini-Mocks

When to Start Mini-Mocks

Begin mini-mocks as soon as you have studied a topic enough to have a working method for solving problems. For Numerical Ability:

  • After studying Percentages: take a 10-question, 12-minute Percentages mini-mock
  • After studying Profit and Loss: take a 10-question Profit/Loss mini-mock
  • After studying both: take a 15-question mixed Percentages + Profit/Loss mini-mock

The mini-mock at this stage answers: “Have I learned this topic well enough to apply it under time pressure?”

The Mini-Mock Format

Duration: 1-2 minutes per question, depending on topic complexity.

  • Simple calculation topics (percentages, averages): 75-90 seconds per question
  • Complex topics (pipes and cisterns, compound interest): 90-120 seconds per question
  • Data interpretation: 3-4 minutes per question set (5-6 individual questions)

Number of questions: 8-15 per topic mini-mock. Enough to be statistically meaningful; not so many that it becomes a full mock.

Time limit enforcement: Use a stopwatch. When the time is up, stop. Do not complete the question you were working on. Mark it as unattempted. The discipline of stopping at the time limit is itself a skill that mini-mocks build.

Scoring: Record (a) total attempted, (b) total correct, (c) accuracy rate (correct/attempted), (d) time per question on correctly answered questions.

What Mini-Mock Scores Tell You

High accuracy, comfortable time: This topic is ready for full section integration. Move to the next topic.

High accuracy, uncomfortable time (finishing at or just before the time limit): You can solve correctly but slowly. Speed is the gap. Practice 20 more problems from this topic specifically focusing on calculation speed (shortcuts, mental math, direct formula application).

Low accuracy regardless of time: The concept is not learned yet. Return to the study resource, identify specifically what you are getting wrong (is it the formula? is it setting up the equation? is it the calculation?), and study that specific sub-concept.

High accuracy on easy sub-types, low accuracy on hard sub-types: Mixed topics hide internal variation. For example, in Data Interpretation: bar graph questions easy, combination charts (bar + line overlay) hard. Separate practice for the harder sub-type.

Phase 2: Section Mocks

What Section Mocks Are

A section mock is one full NQT section taken in isolation under exact exam conditions:

  • Numerical Ability: 25 questions, 25 minutes
  • Verbal Ability: 25 questions, 25 minutes
  • Reasoning Ability: 25 questions, 25 minutes
  • Foundation Coding: 1 problem, 30 minutes

Section mocks answer: “Across all topics in this section, how am I performing at exam pace?”

When to Start Section Mocks

Begin section mocks after you have completed topic-wise mini-mocks for the major topics in each section:

Numerical Ability: After mini-mocking Percentages, Profit/Loss, Time/Work, Time/Speed/Distance, and Data Interpretation - the five highest-weight topics. Remaining topics can be covered after the first section mock.

Verbal Ability: After practising RC technique (question-first approach), reviewing grammar rules for error identification, and building vocabulary with at least 100 new words studied.

Reasoning Ability: After practising seating arrangements (2-3 complete sets), blood relations, coding-decoding, and direction sense. Series and analogies can be refined after the first section mock.

Foundation Coding: After writing 20-30 complete programs in your chosen language. The coding section mock is a single problem - but the “mock” is timing yourself writing a complete, tested solution from scratch.

The Section Mock Protocol

Environment: Sit at a desk. Phone in another room. Door closed if possible. No music, no TV in background. This is not about enjoyment - it is about training your performance under the conditions of the actual exam.

Timing: Set a timer for the section duration. When it starts, you start. When it ends, you stop, regardless of completion status. Do not pause for anything - this trains you to treat time as the hard constraint it is.

Question navigation: In the actual NQT, you can navigate between questions within a section. During section mocks, allow yourself the same navigation freedom. Practice the skip-and-return strategy: mark unclear questions, move forward, return to marked questions with remaining time.

No calculator: NQT does not permit calculators. Section mocks must be done without calculators. Calculation speed without tools is itself a skill that requires practice.

Blind first attempt: Do not look at answers during the mock. Complete the section fully, then step away for 15-30 minutes before reviewing.

Section Mock Analysis Framework

After each section mock, before moving to the next section or taking a full mock, conduct a complete analysis. This is where the preparation value lives.

Step 1: Classify every wrong answer

For each incorrectly answered question, determine the failure mode:

Type A (Conceptual Error): You did not know the method to solve this type of problem, or you applied the wrong formula, or you misunderstood the concept being tested.

Example: Getting a Compound Interest question wrong because you applied Simple Interest formula.

Type B (Careless Error): You knew the method and applied it correctly, but made an arithmetic error, misread the question, or made a unit conversion mistake.

Example: Solving a Speed question correctly but getting the final answer wrong because you converted km/h to m/s incorrectly.

Type C (Time Error): You could have solved this correctly given more time, but ran out of time before reaching it or completing it.

Example: A seating arrangement question where you had the logic but ran out of the 25 minutes.

The treatment for each type:

  • Type A: Study the topic/concept from the resource. Practice 10 targeted problems.
  • Type B: Review your working for careless error patterns. Practice the specific calculation type where you made the error.
  • Type C: Do not study more content - speed is the issue. Practice solving the question type faster through repetition.

Step 2: Count error types

After classifying all wrong answers:

  • If more than 50% are Type A: You have conceptual gaps. Content study takes priority over more mocks.
  • If more than 50% are Type B: You are solid conceptually but careless. Slowing down slightly to check arithmetic and targeting Type B error patterns helps.
  • If more than 50% are Type C: Time management is the primary issue. Practice the “skip-and-return” method more aggressively. Consider whether certain question types should be deliberately skipped rather than attempted.

Step 3: Topic accuracy table

Create a table:

Topic Questions Attempted Correct Accuracy Error Types
Percentages 5 4 80% 1 Type B (calculation error)
Profit/Loss 4 3 75% 1 Type A (marked price formula confused)
TSD 3 1 33% 1 Type A, 1 Type B
Data Interpretation 5 4 80% 1 Type C (ran out of time)

A topic with less than 60% accuracy signals either conceptual gaps (review study material) or insufficient practice (do 20 more problems).

Step 4: Time allocation review

Review how much time you spent per topic category:

Expected allocation for Numerical (25 questions, 25 minutes):

  • Simple calculation questions (Percentages, P/L, Averages): 45-60 seconds each
  • Medium complexity (TSD, Time/Work, Mixtures): 75-90 seconds each
  • Data Interpretation sets: 3-4 minutes per set (covers 5-6 questions)

If you spent 4 minutes on a simple percentage question, that is a red flag - either you did not know the direct method, or you doubted your answer repeatedly. Either problem has a specific solution.

Phase 3: Full NQT Mock Tests

The Transition to Full Mocks

Move to full NQT mock tests after:

  • Completing section mocks for Numerical, Verbal, and Reasoning
  • Completing at least 15-20 Foundation Coding problems (for the coding section simulation)
  • Achieving consistent accuracy above 65% in section mocks for at least two consecutive sections

Full mocks add two critical elements that section mocks cannot provide:

  1. The stamina challenge of sustained testing across 100 minutes of Foundation sections
  2. The mental transition challenge of switching between cognitive modes (quantitative to verbal to logical to coding)

The Full Mock Exam Conditions

Physical environment: Replicate the TCS iON test environment as closely as possible.

  • Sit at a desk (not a sofa or bed)
  • Use a desktop or laptop, not a mobile phone
  • Close all other browser tabs
  • Set the phone to silent and place it in another room
  • Have rough paper and a pen (for calculations and reasoning diagrams) - this is allowed in the actual exam
  • Tell family members you are unavailable for the next 2 hours

Timing structure:

  • Foundation Numerical: 25 questions, 25 minutes
  • Foundation Verbal: 25 questions, 25 minutes
  • Foundation Reasoning: 25 questions, 25 minutes
  • Foundation Coding: 1 problem, 30 minutes
  • (Advanced sections: if targeting Digital/Prime, add Advanced Quants 25 min, Advanced Reasoning 25 min, Advanced Coding 90 min)

Total for Foundation only: 1 hour 45 minutes. Total with all Advanced sections: approximately 4 hours.

For most candidates, start with Foundation-only full mocks (1 hour 45 minutes). Add Advanced sections after Foundation performance is stable.

How Many Full Mocks to Take

The diminishing returns problem: Mock test #1 produces the most learning (you discover your weaknesses). Mock test #2 produces significant learning (you verify whether you addressed those weaknesses). Mock test #15 produces minimal learning (you have stabilised and are seeing the same patterns). There is a point where more mocks do not improve performance.

The recommended progression:

  • Weeks 1-4 (topic and section mini-mocks): No full mocks yet
  • Week 5-6: 2 full Foundation mocks (spaced 3-4 days apart)
  • Week 7-8: 2 full Foundation mocks + analysis and targeted study
  • Week 9-10: 2 full Foundation mocks + Advanced section practice (if targeting Digital)
  • Week 11-12: 2-3 final full mocks including Advanced sections (if targeting Digital)

Total full mocks: 8-12 across the preparation period. This is enough to build stability without creating diminishing-return mock fatigue.

The quality vs quantity principle: One full mock with rigorous 2-hour post-mock analysis is worth more than three mocks with no analysis. If you are time-constrained, take fewer mocks and analyse each one more thoroughly.

Sources for Full Mocks

Several platforms provide TCS NQT-format mock tests:

TCS iON Official Practice: TCS iON provides official sample tests. These most closely replicate the actual interface, question types, and difficulty calibration. Prioritise these.

PrepInsta: Provides TCS NQT-specific mock tests that are widely used by the TCS preparation community. The difficulty calibration is reasonable and the question format is close to actual NQT.

IndiaBix and similar: General aptitude mock resources. The questions are useful for topic practice and section mocks but may not exactly replicate TCS NQT difficulty and format for full mocks.

The TCS NQT Preparation Guide provides NQT-format practice across all sections including Advanced section questions calibrated to the actual assessment difficulty. It is particularly useful for Foundation Coding and Advanced Coding practice where question format specificity matters most.

LeetCode (for Foundation Coding and Advanced Coding practice): LeetCode problem difficulty maps well to Foundation Coding (Easy level) and Advanced Coding (Medium to Hard level). Practising with timed LeetCode problems builds the skills tested in the coding sections even if the format differs slightly.

The Error Log: Your Most Valuable Preparation Asset

What an Error Log Is

An error log is a running record of every question you answer incorrectly in any mock test or practice session, along with:

  • The topic
  • The error type (A, B, or C)
  • The correct method
  • A note about what specifically went wrong

Why an Error Log Works

Without an error log, wrong answers are forgotten. You make the same conceptual error on percentage problems in Mock 3 that you made in Mock 1 because you have not systematically tracked it. An error log forces a confrontation with patterns that would otherwise remain invisible.

Pattern identification: After 2-3 mocks, your error log might show:

  • 7 Type A errors in Profit/Loss problems
  • 3 Type B errors involving unit conversions in TSD problems
  • 5 Type C errors in seating arrangement questions

This pattern is actionable information that cannot be obtained from just looking at total scores.

How to Maintain an Error Log

Format (simple, sustainable):

Date Section Topic Error Type What I Got Wrong Correct Method
(Mock date) Numerical Profit/Loss A Applied CP formula to a “marked price” problem MP = CP × (1 + markup%). Profit calculated on CP, not MP
(Mock date) Reasoning Blood Relations B Drew the family tree correctly but misread “grandfather” as “father” Slow down on reading relationship terms
(Mock date) Numerical TSD C Could not attempt the 4th TSD question due to time Practice TSD at 80 seconds per problem, not 120

Maintenance cadence: Update the error log immediately after every mock analysis session, before the next mock. The 20 minutes spent populating the error log is more valuable than the next 20 minutes of studying new content.

Weekly error log review: Once per week, scan the entire error log and look for patterns. Any topic that appears more than 3 times in 2 weeks needs a dedicated study session.

Converting Error Log Data to Study Sessions

The targeted study session (triggered by error log):

If the error log shows 5 Profit/Loss Type A errors across 2 mocks:

  1. Re-read the Profit/Loss chapter in your preparation resource
  2. Identify the specific sub-types that caused errors (marked price problems? discount + profit combined?)
  3. Solve 15 targeted problems specifically on those sub-types
  4. Take a 10-question Profit/Loss mini-mock
  5. Update the error log with whether the mini-mock showed improvement

This targeted cycle - error log → identify pattern → study specifically → mini-mock → verify → update log - is the mechanism through which mocks actually improve performance.

Simulating Exact Exam Conditions

Why Conditions Matter

Candidates who practise in relaxed conditions and then take the actual exam in a proctored test centre typically perform 10-15% below their mock average. The conditions difference is real and the gap is not just nervousness - it is also:

  • Unfamiliarity with the physical test environment (different chair, screen, keyboard)
  • The absence of the music or background noise that characterised study sessions
  • The inability to move around, check the phone, or take a break
  • The social monitoring effect (proctor present, other candidates nearby)

The Condition Simulation Protocol

Simulating the test centre environment:

  • No music (the test centre is quiet with only keyboard sounds and AC noise)
  • Sit at a desk with a straight-backed chair (not a reclining chair)
  • Use a keyboard and mouse setup if possible (not a touchpad-only laptop)
  • Dress as you would for the actual exam (comfortable but formal - training the mindset)

Simulating the browser environment: TCS iON’s assessment interface runs in a browser with restricted navigation - you cannot switch tabs, open new windows, or access other applications during the test. Some practice platforms have similar restrictions. If your mock platform allows free browsing during the test, impose this restriction yourself: close all other tabs before starting, and treat opening another tab as a test failure.

Simulating the calculator restriction: NQT does not permit calculators. Every full mock must be taken without any calculator tool - not your phone’s calculator, not the Windows calculator, not anything. This forces the mental calculation practice that the actual exam requires.

Simulating the rough paper usage: In the actual TCS iON exam, you get rough paper and a pen. Practice using rough paper during every mock. Sketch diagrams for reasoning problems on paper. Write calculations for Numerical on paper. The habit of using rough paper productively is itself a testable skill.

Building Exam Stamina

The full NQT exam runs for 1 hour 45 minutes (Foundation only) to 4+ hours (with Advanced sections). Most candidates have never sat a continuous, focused test for this duration.

The stamina progression:

  • Week 1-2: Section mocks (25-30 minutes sustained focus)
  • Week 3-4: Back-to-back section mocks (75 minutes sustained focus, 2 Foundation sections)
  • Week 5-6: Full Foundation mock (1 hour 45 minutes sustained focus)
  • Week 7-8: Full mock with Advanced sections attempted (3+ hours)

This progressive stamina building avoids the shock of encountering the full duration for the first time on actual exam day.

Signs of insufficient stamina:

  • Performance noticeably worse in sections 3 and 4 vs sections 1 and 2
  • Increasing careless errors as the mock progresses
  • Difficulty concentrating on the Reasoning section after completing Numerical and Verbal

Stamina building techniques:

  • Take section mocks without breaks between sections (continuous 75 minutes)
  • Avoid high-carbohydrate meals 2 hours before mock sessions (blood sugar crashes affect concentration)
  • Practice the 1-2 minute transition ritual between sections: breathe, review your notes on what to focus on in the next section, then begin

The Mental Aspect of Mock Tests

Performance Anxiety Under Timed Conditions

Many candidates find that their performance in mocks is significantly below their performance on untimed practice. The time pressure creates anxiety that impairs working memory, reduces the ability to retrieve information clearly, and induces hasty decisions that produce errors.

The anxiety-performance relationship:

Moderate test-taking anxiety can actually improve performance (the arousal curve) by increasing alertness and focus. High anxiety impairs performance by consuming working memory with worry rather than problem-solving.

The goal is not zero anxiety - it is moderate, productive alertness. Candidates who are completely calm in mocks (because they do not care about the outcome) and those who are severely anxious both underperform compared to those in the moderate alertness zone.

Building the moderate arousal state:

  • Take mocks when you are alert but not overstimulated (mid-morning, after a light breakfast)
  • Avoid taking mocks when stressed about other life events (poor performance under those conditions reflects external factors, not ability)
  • Use a brief pre-mock ritual: 5 deep breaths, review the target scores you want to achieve, then begin

The Difficult Question Response

In the actual NQT, encountering a question you cannot immediately solve creates a fork:

  • Fork A: Try to work through it, spend 3 minutes, get it wrong or still not finish
  • Fork B: Mark it, move on, return with remaining time

Candidates who have practised Fork B in every mock have trained themselves to make that choice quickly and without guilt. Candidates who have always “pushed through” difficult questions in mocks bring that same habit to the actual exam and lose time.

The 90-second rule for practice: In any aptitude section, if a question has consumed more than 90 seconds without clear progress, mark it and move on. This rule, practised consistently in mocks, becomes automatic in the actual exam.

Handling Consistently Low Mock Scores

A candidate who takes 4 full mocks and scores consistently below 60% in Numerical is facing one of two problems:

Problem A: Conceptual gaps remain. The preparation has not yet covered the material sufficiently. The next mock will not improve things - the next study session will. The signal: Type A errors dominate the error log.

Problem B: Execution issues. Concepts are known but time pressure prevents their application. The signal: the candidate can solve most questions correctly when given unlimited time, but the timed mock produces much lower scores. Type B and C errors dominate.

Response to Problem A: Stop taking full mocks. Return to topic study. Specifically study the topics where Type A errors cluster. Take mini-mocks on those topics. Only return to full mocks when the Type A error rate drops.

Response to Problem B: Continue mocks but change how you practice untimed: introduce artificial time pressure in all practice. Even for untimed practice problems, set a target time per question and track whether you hit it. Speed is built through sustained, time-pressured practice, not through relaxed study.

When to change strategy vs when to persist: Change strategy when you have been taking mocks for 3+ weeks without any improvement in accuracy or speed in the weakest sections. Persistence alone does not improve performance - persistence plus change produces improvement.

Interpreting Mock Percentiles vs Actual NQT

Why Mock Scores Are Not Direct Predictors

A candidate who scores 78th percentile on a PrepInsta mock and 72nd percentile on another PrepInsta mock might expect to score in the 70th-80th percentile range on actual NQT. This expectation is approximately right in direction but not in magnitude.

Reasons mock percentiles diverge from actual NQT:

  1. Population difference: Mock test takers on external platforms skew more prepared than the full NQT candidate pool. A 75th percentile on a platform with 10,000 dedicated preparers is not the same as 75th percentile among 500,000 NQT registrants.

  2. Difficulty calibration: External mocks are not always calibrated to TCS’s exact difficulty level. Some are harder, some easier. The official TCS iON practice materials are the most accurately calibrated.

  3. The exam environment effect: The actual exam environment produces performance adjustments - some candidates perform better (high-stakes focus), others worse (anxiety). Your mock score in relaxed conditions may be your ceiling, not your typical score under exam pressure.

A practical calibration: If you consistently score X in external mocks under exam conditions, your actual NQT performance is likely to be in the range X - 5% to X + 5% in the same sections. This range reflects natural variation, difficulty differences, and environment effects.

A consistently strong mock performer (75th+ percentile in section mocks) should be confident about Ninja threshold. Digital-range performance in Advanced Coding mocks (solving problems completely) correlates reasonably well with Digital outcome. The correlation is imperfect but meaningful.

The TCS iON Practice Test as the Benchmark

The TCS iON official practice materials, while limited in volume, are the most accurate calibration tool available. Treat official TCS iON practice performance as a 1:1 benchmark with actual NQT performance (within normal variance). Treat external platform mocks as training tools with imperfect calibration.

The recommendation: Use external mocks (PrepInsta, IndiaBix, similar) for volume and variety throughout preparation. Use TCS iON official practice tests as the benchmark measure in the final 2-3 weeks.

The Mock Test Schedule: A Complete Preparation Timeline

The 12-Week Preparation Schedule with Mock Integration

Weeks 1-2: Foundation Building (No Full Mocks)

  • Study Numerical: Percentages, Profit/Loss, Averages, Ratio/Proportion
  • Mini-mocks per topic after completion
  • Study Verbal: RC technique, grammar rules
  • Study Reasoning: Seating arrangements, blood relations
  • No full mocks yet - foundational knowledge is insufficient

Week 3: First Section Mocks

  • Numerical Section Mock 1 (analysis: 2 hours post-mock)
  • Error log started
  • Study: Address Type A errors identified in Numerical mock
  • Foundation Coding: Write 10 basic programs

Week 4: Section Mocks Continue

  • Verbal Section Mock 1 (analysis: 2 hours)
  • Reasoning Section Mock 1 (analysis: 2 hours)
  • Error log updated
  • Continue topic study based on error log

Week 5: Second Section Mocks + First Full Mock

  • Numerical Section Mock 2 (verify improvement from Week 3 error analysis)
  • First Full Foundation Mock (all 4 sections: Numerical, Verbal, Reasoning, Coding)
  • Full mock analysis: 3 hours
  • Error log updated comprehensively

Week 6: Targeted Study Based on Full Mock 1

  • Identify the 3 weakest topics from Full Mock 1 analysis
  • Dedicated study sessions for each: 2-3 hours per topic
  • Mini-mocks to verify improvement on each weak topic
  • No full mock this week (allow study to integrate)

Week 7: Advanced Section Introduction (if targeting Digital)

  • Begin Advanced Quants mini-mocks (probability, combinatorics)
  • Begin Advanced Coding practice (10 LeetCode Medium problems)
  • Full Foundation Mock 2 (assess whether Week 6 study improved weak areas)
  • Analysis and error log update

Week 8: Advanced Section Development

  • Advanced Quants study and mini-mocks
  • Advanced Reasoning practice
  • Advanced Coding: 15 more LeetCode Medium problems
  • Full Foundation Mock 3 with Analysis

Week 9: First Full Mock Including Advanced Sections (Digital targeting)

  • Full NQT Mock (Foundation + Advanced sections)
  • Time approximately 4 hours including Advanced Coding
  • Analysis: 3 hours
  • First honest assessment of Digital probability based on Advanced Coding performance

Week 10: Targeted Advanced Section Improvement

  • Study sessions targeting Advanced section weaknesses from Week 9 mock
  • LeetCode Medium practice (10 more problems)
  • Advanced Quants targeted practice
  • Full Foundation Mock 4 (verify Foundation stability)

Week 11: Peak Mock Period

  • Full Mock with Advanced (second complete simulation)
  • Analysis and error log
  • Full Mock Foundation only (shorter, final check on Foundation strength)
  • One additional targeted study session based on final errors

Week 12: The Taper

  • No new mocks this week (explanation in the following section)
  • Review error log comprehensively - look for patterns across all mocks
  • Light review of formulas and methods for the 3-5 topics with most errors
  • Complete rest on the day before the exam

The Final Week Strategy: Tapering Like Athletes

Why Athletes Taper Before Competition

In athletic training, a “taper” is a period of reduced training intensity in the final days before a competition. Athletes who peak their training right up to competition day typically perform below their optimal level because muscle fatigue, accumulated stress, and overtraining impair performance. The taper allows the body to recover, consolidate the training gains, and arrive at competition day in peak condition.

The same principle applies to cognitive performance in standardised tests.

The Cognitive Taper for NQT

Final week structure:

7 days before: Last full mock. Conduct full analysis. Identify the 2-3 topics that most need attention based on the entire mock history. This is the last data collection point.

6 days before: Targeted study of the 2-3 identified topics. Not new topics - only topics you have been working on throughout preparation. The goal is consolidation and refinement, not new learning.

5 days before: Review error log entries from Mocks 4-6. Note the recurring patterns. Write out (by hand) the correct method for the 5 most-repeated error types. This writing reinforces the correct approach in memory.

4 days before: Light review of formula sheets. Numerical formulas (Percentages, TSD, P/L, Compound Interest, Mixtures). Reasoning method notes (seating arrangement approach, blood relation diagramming, direction table). Verbal: the 5 most common grammar rule violations. Nothing new. Just reinforcement.

3 days before: Take a half-length mock - just Numerical and Verbal sections (50 minutes). This maintains test-taking rhythm without the fatigue of a full mock. No analysis required - just note the score and verify you are in your expected range.

2 days before: No mock tests. Light reading of preparation notes. Normal activities. Sleep early.

Day before: No preparation at all. Complete rest. Logistics preparation: lay out required documents, confirm test centre address, plan route with buffer time, charge laptop if online test, prepare rough paper and pen if permitted. Sleep at a normal time - do not shift sleep schedule.

Exam day morning: Review only the formula sheet (15 minutes maximum). Eat a normal breakfast. Leave with buffer time. Arrive at the test centre or set up your online test environment 30 minutes before your slot.

What the Taper Accomplishes

The taper accomplishes several things simultaneously:

Memory consolidation: Information learned and practised during preparation consolidates into long-term memory during sleep and rest periods. The taper’s rest period is when learning from weeks of preparation becomes durable.

Attention restoration: Sustained intensive study depletes attentional resources. Two to three days of reduced intensity restores attention capacity, which directly translates to exam performance - you can read questions carefully, notice details in data interpretation, and work through complex reasoning chains without mental fatigue.

Anxiety calibration: A small amount of pre-exam anxiety is beneficial. The taper period, knowing preparation is complete, typically produces the right calibration of alertness. Continuing intense study right up to exam day can produce excessive anxiety.

Physical readiness: Sleep quality and quantity directly affect performance on cognitive tasks. Maintaining normal sleep schedules through the taper ensures exam day cognitive function is at baseline, not sleep-deprived.

Mock Test Analysis Worksheet Framework

The Complete Analysis Document

After every full mock, complete this worksheet before the next mock:

Mock Test Analysis Worksheet

Mock number: __ Date taken: __ Duration: ___

SECTION SCORES: | Section | Questions Attempted | Correct | % Accuracy | Time Used | |—|—|—|—|—| | Numerical Ability | /25 | | % | /25 min | | Verbal Ability | /25 | | % | /25 min | | Reasoning Ability | /25 | | % | /25 min | | Foundation Coding | 1 problem | Pass/Partial/Fail | | /30 min | | Advanced Quants | /15 | | % | /25 min | | Advanced Reasoning | /14 | | % | /25 min | | Advanced Coding | 2 problems | P1: __ P2: __ | | /90 min |

ERROR CLASSIFICATION: | Section | Type A (Conceptual) | Type B (Careless) | Type C (Time) | Total Errors | |—|—|—|—|—| | Numerical | | | | | | Verbal | | | | | | Reasoning | | | | | | Advanced Quants | | | | | | Advanced Coding | | | | |

WEAK TOPICS (3 lowest accuracy topics across all sections):

  1. ______: __% accuracy Error type dominant: A / B / C
  2. ______: __% accuracy Error type dominant: A / B / C
  3. ______: __% accuracy Error type dominant: A / B / C

TIME MANAGEMENT REVIEW:

  • Did I finish each section before time ran out? Y/N (which sections did not complete?)
  • Did I skip any questions? How many were skipped?
  • Did I return to all skipped questions? How many returned ones did I answer correctly?
  • Which question type consumed the most time relative to value?

COMPARISON WITH LAST MOCK: | Metric | Last Mock | This Mock | Change | |—|—|—|—| | Numerical accuracy | | | | | Verbal accuracy | | | | | Reasoning accuracy | | | | | Advanced Coding problems solved | | | | | Overall error count | | | |

ACTION ITEMS FOR NEXT WEEK:

ERROR LOG UPDATES TO MAKE: (List specific wrong questions to add to error log)

The Mock Test Progress Tracker

Maintain a simple tracker across all mocks:

Mock # Date Numerical % Verbal % Reasoning % Coding Adv. Coding Notes
1             First full mock
2             Post-TSD study
3             After vocabulary study
…              

Review this tracker weekly. Flat or declining lines in any section signal a strategy problem. Steadily improving lines confirm the preparation is working.

Advanced Coding Mock Strategy

The Foundation Coding Section

Foundation Coding requires solving one problem in 30 minutes. The mock strategy:

Simulate the TCS compiler environment: Practice writing programs in an environment similar to TCS iON. The TCS coding environment uses command-line arguments for input in many problems. Practice reading from argv/argc (C/C++) or sys.argv (Python) rather than from stdin in your mock coding practice.

The Foundation Coding mock sequence:

  1. Read the problem statement carefully (2 minutes)
  2. Write a pseudocode solution (3 minutes)
  3. Translate to actual code (15 minutes)
  4. Trace through with the given example (3 minutes)
  5. Handle edge cases (3 minutes)
  6. Submit (4 minutes buffer)

Total: 30 minutes. This leaves zero buffer - the discipline of pseudocode-first approach prevents the costly restart that burns 10-15 minutes.

The Advanced Coding Section (Digital/Prime targeting)

Two problems, 90 minutes. The mock protocol:

Problem 1 mock target: 30-35 minutes for complete, correct solution. Problem 2 mock target: 45-55 minutes for complete, correct solution (or maximum progress toward solution).

After each Advanced Coding mock session:

  • Review the editorial/solution for any problem you could not solve completely
  • Implement the correct solution yourself (do not just read it - code it)
  • Categorise the technique used (DP pattern, graph algorithm, greedy, etc.)
  • Add the technique to your “known approaches” catalogue

Section-Specific Mock Strategies

Numerical Ability: The Three-Pass Strategy

Pass 1 (first 15 minutes): Solve all easy questions Immediately skip any question that requires complex multi-step calculation or is of an unfamiliar type. Mark it. Solve all questions you can complete in under 75 seconds.

Pass 2 (next 7 minutes): Revisit medium-difficulty questions Return to questions that require 75-120 seconds. Solve as many as possible.

Pass 3 (remaining 3 minutes): Attempt skipped hard questions Use remaining time on the hardest or most time-consuming skipped questions. If not enough time, guess (no negative marking in most TCS NQT drives - verify per current drive notification).

Verbal Ability: The Time-Weighted Strategy

RC passages: Read question-first. Each RC set (passage + 4-5 questions) should take 5-6 minutes total. This is the highest time-value investment in Verbal.

Vocabulary/Sentence completion: These are fast questions (30-45 seconds each if you know the answer). Complete them quickly at the start to bank time for RC.

Para-jumbles: These are medium-time questions (60-90 seconds). If the structure is not immediately clear after 60 seconds, mark and return.

Error identification: Grammar-rule-based. If you know the rule, this is fast (30-45 seconds). If you are uncertain, mark and return - guessing without a clear rule is low-probability.

Reasoning Ability: Diagrams First

The most effective Reasoning mock technique: draw the diagram before reading the questions.

For seating arrangement problems:

  1. Read the condition statements
  2. Draw the arrangement diagram (circular or linear)
  3. Fill in all definite positions
  4. Note ambiguous positions separately
  5. Only then read and answer questions

This approach, practised in every mock, builds the systematic speed that Reasoning questions reward.

For blood relation problems: Always draw the family tree. Never solve blood relation questions mentally - the visual representation eliminates the errors that come from holding a complex hierarchy in working memory.

Frequently Asked Questions: Mock Tests

“How early should I start taking mocks?” Not before you have completed topic study for at least the major topics in each section. Taking mocks without the foundational knowledge produces scores that measure what you don’t know, not how well you can perform under exam conditions. The right time: after 3-4 weeks of topic study and topic mini-mocks.

“Should I retake the same mock?” No. Retaking a mock you have already seen produces inflated scores because question familiarity (not capability improvement) drives the increase. Use different mocks for different sessions. The benefit of retaking is near zero once you have seen the questions.

“My mock scores are declining rather than improving. What is happening?” This can happen when: (a) you are taking mocks when fatigued, (b) you are taking mocks too frequently without allowing study to intervene, or (c) you are taking harder mocks as you progress (appropriate difficulty escalation). Check which of these applies and adjust.

“I score well in section mocks but poorly in full mocks. Why?” Stamina is the likely cause. The mental fatigue of 100 minutes of continuous testing reduces performance in later sections compared to fresh section mocks. Build stamina through progressive back-to-back section practice.

“How do I know if my Advanced Coding performance is Digital-competitive?” In mock Advanced Coding sessions: if you consistently solve Problem 1 completely and correctly in 30-35 minutes and make meaningful progress (50%+ test cases) on Problem 2 in the remaining time, you are in Digital-competitive territory. If you regularly solve both completely, you are in Prime territory.

“The mock platform shows me the answers after I submit. Should I look at all of them?” Review every incorrect answer, yes. Reviewing correct answers is optional - focus time on understanding why wrong answers were wrong. For correct answers you were uncertain about, note the reasoning that led to the correct answer for reinforcement.

“Should I time my analysis or spend as long as needed?” Spend as long as needed, up to a point. For Foundation mocks, 2-3 hours of analysis is appropriate. Beyond 3 hours, the marginal analysis value drops significantly. The principle: analyse until you have clearly identified the top 3 action items for the next week. After that, execute the action items rather than continuing to analyse.

“Is there a way to predict my actual NQT score from mock scores?” The most reliable prediction model: take your median performance across your last 3 section mocks (not your best, your median) and subtract 5% to account for the exam environment effect. This range is your honest expected performance zone. Planning study around the lower end of this range (not the upper end) produces the right preparation intensity.

“I am scoring well in mocks. Should I keep taking them or shift to other preparation?” If mock scores are consistently strong (70%+ accuracy in all Foundation sections, Advanced Coding problems solved regularly), the marginal benefit of additional mocks is low. Shift time to: Advanced Coding practice for Digital targeting, system design study for Prime targeting, or consolidation of weak topic areas. Mocks should not be taken for comfort - they should be taken when they will produce actionable diagnostic information.

The Mock Test Mindset

The most important shift in mock preparation is from “taking mocks to feel prepared” to “taking mocks to find and fix specific weaknesses.” The first mindset produces comfort. The second mindset produces improvement.

A candidate who finishes a mock, looks at 72% accuracy, and thinks “that was pretty good” has completed a mock. A candidate who finishes the same mock, notes that 4 of 5 TSD questions were wrong (Type A errors), schedules a 2-hour TSD targeted study session for tomorrow, takes a TSD mini-mock the day after, and logs whether the accuracy improved - that candidate has used a mock.

The difference in NQT performance between these two candidates, after the same number of mocks, is the difference between the candidates, not the difference in the mocks they took. The preparation strategy is the same. The preparation quality is completely different.

Approach every mock as both a measurement instrument and a learning opportunity. Take the measurement seriously enough to simulate real conditions. Extract the learning thoroughly enough to act on every identified weakness. The NQT score that results from this approach is the most honest reflection of what you can achieve.

Use the TCS NQT Preparation Guide as your primary resource for NQT-format practice questions across all sections - Foundation and Advanced - that complement mock test analysis with targeted topic practice at the right difficulty level. The combination of structured topic practice and systematic mock analysis is the preparation formula that consistently produces strong NQT outcomes.

Deep Dive: Numerical Ability Mock Mastery

The Eight Topic Groups and Their Mock Weight

Not all Numerical topics deserve equal mock preparation attention. Understanding the weight distribution helps allocate study and mini-mock time efficiently.

Tier 1 topics (highest weight, 5-7 questions each in a 25-question section):

Percentages and Profit/Loss (combined ~20% of Numerical): These two topics are deeply intertwined. A “cost price, marked price, discount, and profit percentage” problem touches all of them simultaneously. Mock performance on these two topics is the strongest single predictor of Numerical section performance.

Key sub-types to practise in mini-mocks:

  • Successive discount problems (two discounts applied one after another)
  • Marked price + profit percentage combined
  • Percentage change and its reverse calculation
  • Population percentage problems (increase/decrease over periods)

Data Interpretation (combined ~20% of Numerical): DI appears as question sets (one chart, 4-5 questions about it). DI is high time-cost but also high question-yield. A correct DI set gives 4-5 correct answers.

Mini-mock strategy: practice one DI set per day for 2 weeks. Include bar charts, pie charts, line graphs, and tables. The multi-chart type (bar + line on same graph) is the hardest and most time-consuming - practice it specifically.

Time/Speed/Distance (15% of Numerical): TSD appears in 3-4 questions per section. The sub-types:

  • Trains crossing each other or a stationary object
  • Boats and streams (upstream/downstream)
  • Average speed calculations
  • Relative speed for two moving objects

Each sub-type has a standard method. Mini-mocks should cover all four sub-types.

Time and Work (15% of Numerical): Work problems including:

  • Combined work rate (A and B together can complete in X days)
  • Pipe filling problems (2-3 pipes, fill/drain)
  • Efficiency-based variations

Tier 2 topics (medium weight, 2-3 questions each):

  • Simple and Compound Interest
  • Ratios and Proportions (including mixtures and alligation)
  • Number System and divisibility
  • Averages and weighted averages

Tier 3 topics (low weight, 1-2 questions each):

  • Probability at basic level
  • Permutations and Combinations
  • Geometry (area, perimeter)

Mock preparation allocation: 70% of Numerical mini-mock time on Tier 1 topics. 25% on Tier 2 topics. 5% on Tier 3 topics (only after Tier 1 and 2 are solid).

The Calculation Speed Problem

Many candidates can solve Numerical questions correctly but too slowly. The bottleneck is arithmetic - addition, multiplication, division, and percentage calculations done manually.

The speed benchmarks:

  • 2-digit multiplication (23 × 47): 8-12 seconds
  • 3-digit addition (347 + 589): 5-8 seconds
  • Percentage of a number (37% of 850): 15-20 seconds
  • Fraction operations (3/7 + 5/8): 15-20 seconds

If any of these takes longer than the benchmark, calculation speed is the limiting factor.

Speed practice integrated with mock preparation:

Before each Numerical mini-mock, complete a 5-minute calculation drill:

  • 10 two-digit multiplications (set a 90-second target)
  • 10 percentage calculations (set a 3-minute target)
  • 5 fraction additions (set a 2-minute target)

Done daily for 4 weeks, this drill builds the automatic calculation speed that replaces slow deliberate calculation.

Approximation in Numerical:

Many Numerical questions do not require exact calculation - the answer choices are spread widely enough that approximation is sufficient. Example: “What is 37% of 8,142?” The answer options might be: (A) 2,992 (B) 3,012 (C) 3,112 (D) 3,214.

Approximate: 37% ≈ 40%, 40% of 8,000 = 3,200. Closest option: (D) 3,214. This took 3 seconds vs 15 seconds for exact calculation. Over 25 questions, approximation saves 3-4 minutes.

When approximation is risky: When answer options are close together (3,010 vs 3,020 vs 3,030). In these cases, more precise calculation is required. Develop the judgment to identify which questions allow approximation and which require precision.

Deep Dive: Verbal Ability Mock Mastery

The Reading Comprehension Strategy in Depth

RC passages are the highest-value Verbal questions (typically 8-10 questions from 1-2 passages in a 25-question section). They are also the most time-consuming.

The question-first technique in practice:

Before reading the passage:

  1. Read the question stems only (not the options): 45 seconds
  2. Note what each question is asking:
    • “What is the main idea?” (Read the full passage for this one)
    • “According to the passage, what does the author say about X?” (Look for X specifically)
    • “Which of the following can be inferred?” (Look for the overall tone and direction of the argument)
    • “What does the word ‘X’ most nearly mean in the context of the passage?” (Read the sentence around the word)

This pre-reading tells you what to watch for before you read, making the passage reading more targeted and faster.

Passage reading pace: The goal is approximately 150-180 words per minute for RC passages. At this pace, a 300-word passage takes 1.5-2 minutes to read, leaving 3-4 minutes for 5 questions.

Build reading pace through:

  • Daily reading of editorial articles (natural reading speed building)
  • Timed RC practice (track words-per-minute on each passage)

Question type strategies:

Main idea questions: The main idea is usually stated in the first or last paragraph. If not explicitly stated, it is implied by what the passage spends the most time discussing.

Inference questions: Inference questions test what logically follows from what the passage says, not what is stated directly. The answer is implied but not explicit. Beware of options that are true in general but not specifically supported by the passage.

Vocabulary-in-context questions: Read two sentences around the word in question. The context determines which meaning is intended. Do not select the dictionary definition of the word - select the meaning that fits the specific context.

Tone questions: The author’s tone is conveyed through word choice (positive/negative connotation), the perspective emphasised, and what aspects the author approves or criticises. RC tones in NQT are usually: neutral/informative, cautiously optimistic, concerned, critical (of something specific), or analytical.

Para-Jumbles Strategy

Para-jumbles present 4-5 sentences in scrambled order. The task is to arrange them into a coherent paragraph.

The link-finding approach:

Step 1: Find the opening sentence. It typically introduces a topic without referring to anything introduced previously. It never starts with a pronoun (this, that, these, those) unless the antecedent has been established.

Step 2: Find the closing sentence. It typically provides a conclusion, result, or final comment on the topic. It often uses transitional words like “therefore,” “thus,” “in conclusion,” or “finally.”

Step 3: Find pronoun-antecedent links. If sentence B starts with “he” and sentence A introduces a man, B follows A.

Step 4: Find logical sequence. Cause before effect. General statement before specific example. Problem before solution.

Para-jumble mock pattern: Practice 3 para-jumble problems per week during the preparation period. The skill is genuinely learnable through exposure to the link-finding patterns.

Deep Dive: Reasoning Ability Mock Mastery

Seating Arrangement: The Systematic Method

Seating arrangement questions are the highest-complexity Reasoning question type. A single arrangement set can have 5-6 questions, making it the highest-value question type in Reasoning - and the highest time-risk if approached incorrectly.

The systematic method (applies to all arrangement types):

Circular arrangements:

  1. Draw the circle with the correct number of positions
  2. Place any person/element whose position is given absolutely or definitively
  3. For “adjacent to” or “next to” conditions, create a mini-chain: if A is adjacent to B and B is adjacent to C, then the chain A-B-C or C-B-A must appear somewhere in the arrangement
  4. Place chains at any open position that fits
  5. For remaining conditions, test possibilities

Linear arrangements:

  1. Draw the row/table with numbered positions (1 through N)
  2. Apply the same chain-building approach
  3. Use “not adjacent” conditions to eliminate positions

The common traps in arrangement questions:

  • “Immediate left” vs “second to the left”: Read carefully. Immediate left is one position left; second to the left is two positions left.
  • “Opposite” in circular arrangements: diametrically opposite, which in a 6-person circle means 3 positions away.
  • “Facing” direction: In circular seating, “facing the centre” means the person faces inward. “Not facing the centre” means facing outward. This affects “left” and “right” because direction reverses when facing opposite directions.

Mock timing for arrangements:

A single complex arrangement set (5 questions) should take 7-9 minutes. If it takes longer, the systematic method is not yet automatic and needs more practice.

The decision to skip: If after 3 minutes of systematic diagramming, a reasonable number of positions are not determined, mark all arrangement questions from that set and move on. An unsolved arrangement blocks 5 questions for 10+ minutes. That time is better spent on the other 20 Reasoning questions.

Coding-Decoding: Pattern Categories

Coding-decoding appears as 2-4 questions in Reasoning sections. The four patterns:

Pattern 1: Letter shift coding “In a code, APPLE is written as BQQMF.” Decode GRAPE. Method: Each letter is shifted by +1. G→H, R→S, A→B, P→Q, E→F. GRAPE = HSBQF.

Pattern 2: Number coding “If BOOK = 2665, what is DESK?” Method: B=2, O=6, O=6, K=11 (wait - 11 is two digits). Look at positional value: B is the 2nd letter, O is the 15th, O is the 15th, K is the 11th. That’s 2-15-15-11. But the code is 2665. 2 matches, but 15 doesn’t match 6. Try reverse alphabetical: B is 25th from end (26-1=25… no). Try B→2 (position), O→6 (somehow). 15→6: maybe only the units digit? 15→5, not 6. Maybe sum of digits: 15→1+5=6. Yes! O is 15th letter, 1+5=6. Check K: 11th letter, 1+1=2… but K in BOOK is coded as 5? Wait: 2-6-6-5: B=2, O=6, O=6, K=5. B is 2nd, code is 2. O is 15th, 1+5=6. K is 11th, 1+1=2, not 5. Alternative: K=11, reverse position from Z? Z=1, Y=2… K from end = 16th from end? 1+6=7, not 5. This particular example may be using a different rule. The point: approach each coding-decoding question by testing the rule on the given example until it produces the given code.

Pattern 3: Symbol coding Letters replaced by symbols according to a given key. Method: direct lookup from the key table provided. Fast if organised.

Pattern 4: Word coding “In a code language, ‘cat eats fish’ means ‘137’, ‘fish swim water’ means ‘358’, ‘cat swim fast’ means ‘162’. What code stands for ‘swim’?” Method: Find the word that appears in two sentences and identify the code that appears in both encoded versions. ‘fish’ appears in sentences 1 and 2: codes 137 and 358. Common code digit between 137 and 358: 3. So fish=3. ‘cat’ appears in sentences 1 and 3: codes 137 and 162. Common: 1. So cat=1. Remaining in sentence 1: 7 = ‘eats’. In sentence 2: 5 and 8 remain for ‘swim’ and ‘water’. ‘swim’ also appears in sentence 3 (162) with cat=1, leaving 6 and 2 for ‘swim’ and ‘fast’. Common between {5, 8} and {6, 2}: none. Wait, that means the code for ‘swim’ is not in sentence 3 - this example has an error. The technique is correct: find the word appearing in multiple sentences, find the common code.

Mock timing for coding-decoding: 45-75 seconds per question when the pattern is identified quickly. If pattern identification takes more than 60 seconds, mark and return.

The Advanced Section Mock Approach

Advanced Quants: Probability Deep-Dive in Mocks

Advanced Quants is significantly harder than Foundation Numerical. Mock strategy for Advanced Quants differs from Foundation Numerical mock strategy in an important way: selective completion is the right approach.

The selective completion strategy:

In Foundation Numerical, attempting all 25 questions is the goal. In Advanced Quants with 15 questions in 25 minutes, attempting 10-12 correctly is often better than attempting all 15 with lower accuracy.

Why: Some Advanced Quants questions require 3-4 minutes of complex calculation. Spending 4 minutes for uncertain accuracy when a 1-minute question elsewhere could give certain accuracy is a poor allocation.

The Advanced Quants question triage:

For each Advanced Quants question, make a 20-second assessment:

  • Is this a recognisable type I can solve? → Attempt immediately
  • Is this a recognisable type but complex calculation? → Attempt after easier ones
  • Is this an unfamiliar type? → Skip entirely (20-second triage cost is worth saving 3 minutes on an unsolvable question)

Advanced Coding: The Mock Approach

Advanced Coding in mocks requires a specific discipline that differs from Foundation Coding mocks.

The two-problem mock protocol:

Before submitting any solution, verify:

  1. Algorithm correctness on the sample test case (trace through manually)
  2. Edge case handling (empty input? single element? maximum constraint?)
  3. Time complexity assessment (will this TLE on large inputs given the constraints?)

The common Advanced Coding mock mistake: Submitting an O(N²) solution to a problem with N=10^5 and wondering why it fails 30% of test cases. N=10^5 with O(N²) = 10^10 operations, which exceeds the typical 10^8 operations per second - TLE is certain.

Reading constraints in Advanced Coding problems:

N value Maximum acceptable complexity Data structure hint
N ≤ 10 Any, including O(N!) Brute force, permutation
N ≤ 100 O(N³) Cubic DP, Floyd-Warshall
N ≤ 1,000 O(N²) Nested loops DP, brute-force optimization
N ≤ 10,000 O(N² log N) or O(N²) carefully DP with optimization
N ≤ 100,000 O(N log N) Sorting, binary search, segment tree
N ≤ 1,000,000 O(N) or O(N log N) Linear scan, hash table

Practice reading the constraints in every coding problem and immediately inferring the target time complexity. This skill, built through mock practice, guides algorithm selection in the actual exam.

Managing Multiple Mock Platforms

Most candidates use 2-3 mock platforms during preparation. Managing these effectively prevents duplication of effort and maximises diagnostic value.

The Platform Allocation Strategy

Platform 1: TCS iON Official Practice Use: Benchmark calibration, final week assessment Frequency: 1-2 times (official materials are limited in volume) Value: Highest accuracy calibration of actual NQT performance

Platform 2: PrepInsta Use: Volume mock practice, section mocks, Foundation section preparation Frequency: Weekly (one full mock, two section mocks) Value: TCS-specific question format, reasonably calibrated difficulty

Platform 3: LeetCode Use: Foundation Coding and Advanced Coding practice Frequency: Daily (2-3 problems per day) Value: Best quality coding problems with editorial solutions, runtime benchmarking

Platform 4: IndiaBix / AptitudeQuestions.com / similar Use: Topic mini-mocks, supplementary Verbal and Reasoning practice Frequency: As needed for targeted topic practice Value: High volume of varied questions, useful for exhausting a topic’s variations

The switching cost: Changing platforms for full mocks introduces calibration noise. When assessing performance trajectory, compare scores from the same platform. Do not compare PrepInsta Mock 3 with an IndiaBix Mock 4 to measure improvement.

Mock Performance Plateaus: Diagnosing and Breaking Them

A performance plateau is when mock scores stop improving across 3+ consecutive mocks despite continued preparation. This is common and has specific causes.

Cause 1: The Familiarity Ceiling

You have practised specific question types enough that you recognise them instantly, but you have not practised enough question variety to generalise. Your accuracy on practised types is 90%+, but novel questions in the same category trip you.

Diagnosis: Your accuracy is high on repeat topics but you consistently miss questions that are slight variations of familiar types.

Fix: Deliberately seek out unfamiliar variations. If you have practised “boats and streams” problems with two-way trips, find “boats and streams” problems with different constraint structures (three boats, time comparison problems). Variation exposure breaks the familiarity ceiling.

Cause 2: The Time Compression Ceiling

You can solve all question types correctly with unlimited time, but your timed accuracy plateaus because calculation speed is still the bottleneck.

Diagnosis: Untimed accuracy is significantly higher than timed accuracy (more than 15% difference).

Fix: Speed drills on calculation (described in the Numerical section above). The calculation speed ceiling requires dedicated speed practice, not more conceptual study.

Cause 3: The Stamina Degradation Pattern

Accuracy is high in early sections and degrades noticeably in later sections.

Diagnosis: Numerical accuracy 78%, Verbal accuracy 72%, Reasoning accuracy 65%. The declining pattern suggests stamina rather than content knowledge as the limiting factor.

Fix: Back-to-back section mocks without breaks to build sustained concentration span. Increase to full mock format immediately.

Cause 4: The Anxiety Amplification Problem

Scores in high-stakes mock simulations (carefully timed, documented, with real consequences) are significantly lower than in low-stakes practice.

Diagnosis: You score well in relaxed conditions but poorly in mock conditions that simulate the real exam.

Fix: Increase the frequency of high-stakes simulation conditions. Take more mocks under exam-condition seriousness. Each time the conditions feel high-stakes, the physiological response becomes more manageable through familiarity.

Building the Complete Mock Preparation System

The Weekly Rhythm

A sustainable mock preparation system that produces consistent improvement:

Monday: Error log review from last week’s mocks. Identify top 3 weaknesses. Plan the week’s targeted study.

Tuesday-Wednesday: Targeted study sessions on identified weak topics. Mini-mocks on each topic immediately after study.

Thursday: Section mock (alternate which section each week). Analysis and error log update.

Friday: Targeted study on any new errors from Thursday’s section mock.

Saturday: Full mock (every other week). Analysis and error log update. Rest from mocks on alternating Saturdays.

Sunday: Light review of formula sheet and error log. Plan next week’s targets. Rest - do not study Sunday evening.

This rhythm alternates intensive study with measurement, ensures rest, and prevents the burnout that comes from daily full mocks without strategic structure.

Tracking Your Progress Visually

Create a simple graph with mock number on the X-axis and accuracy percentage on the Y-axis. Plot separate lines for Numerical, Verbal, and Reasoning.

A well-executed preparation programme produces lines that: start variable (early mocks are inconsistent), stabilise (middle mocks converge to a range), and plateau slightly (late mocks approach the ceiling). If any section line is flat from Mock 3 through Mock 8 without any study intervention, that section needs a targeted strategy change.

The Confidence Calibration

One underappreciated function of mock tests is calibrating your confidence - building accurate beliefs about your own performance level that neither overestimate nor underestimate.

Overconfidence (scores higher than reality suggests): Manifests as Ninja when you expected Digital, or poor Advanced Coding performance when mock practice suggested otherwise. Often caused by using easy mocks as benchmarks or practising in relaxed conditions.

Underconfidence (scores lower than reality suggests): Manifests as unnecessary anxiety about a section where your actual capability is adequate. Often caused by one or two poor mock performances being treated as representative rather than as outliers.

The calibration tool: Keep a running average of your mock scores across the last 4-5 mocks for each section. This smooths out the noise of individual mock variation and gives a more accurate picture of your typical performance level.

Candidates who arrive at NQT with accurate self-knowledge - neither over nor underestimating their section performance - make better in-exam decisions about time allocation, guessing strategy, and Advanced section attempt level. That calibration, built through systematic mock practice and honest analysis, is one of the most valuable things mock tests produce.

The mocks are not the preparation. The analysis is the preparation. The mocks are the measurement instrument. Use them that way, and what you build from that measurement will carry you to the NQT outcome your preparation deserves.

The Foundation Coding Mock in Detail

What the Foundation Coding Mock Tests

Foundation Coding is deceptively simple in description (one problem, 30 minutes) but rich in what it actually tests:

  1. Problem comprehension: Can you read an English-language problem statement and convert it into an algorithm?
  2. Algorithm selection: Can you choose the right approach (loop vs recursion vs sorting)?
  3. Implementation speed: Can you write syntactically correct code in 15-20 minutes?
  4. Edge case thinking: Do you handle empty inputs, zero values, large inputs, and boundary cases?
  5. Testing: Do you trace through your code with the given example before submitting?

Most Foundation Coding problems are solvable with 30-50 lines of clean code. The challenge is doing all five of the above within 30 minutes.

Building the Foundation Coding Mock Habit

The problem set for Foundation Coding mocks:

Rotate through these categories for your Foundation Coding mock problems:

  • Number properties (prime check, Armstrong, palindrome number)
  • Sequence generation (Fibonacci, factorial, geometric series)
  • String operations (reversal, palindrome string, vowel count, anagram)
  • Array operations (max/min, sort, unique elements, frequency count)
  • Pattern printing (triangles, pyramids, diamond patterns)
  • Mathematical computation (GCD/LCM, digit operations, base conversion)

For each mock, select one problem from a category you have not practised in the last 3 days. This rotation ensures you are building breadth rather than deep specialisation in one type.

The 30-minute Foundation Coding session:

Minute 1-3: Read the problem. Read it twice. Identify: What is the input? What is the output? What is the boundary condition?

Minute 4-6: Write pseudocode on paper. Do not open the code editor yet. The pseudocode should answer: what is the main loop structure? what are the base cases?

Minute 7-22: Code the solution. Reference your pseudocode. Name variables meaningfully. Write in clean, indented code.

Minute 23-26: Trace through the provided example manually. Check each line of your code produces the expected intermediate values.

Minute 27-29: Handle edge cases: What if the input is 0? What if the array is empty? What if N=1?

Minute 30: Final review and submit.

After each Foundation Coding mock: Note how many minutes each step took. If pseudocode took 8 minutes (too long), practise pseudocode speed. If implementation took 18 minutes (too long), practise writing code faster through repetition.

The Pre-Exam Day Protocol: Final Preparation Checklist

Three Days Before

Documents to prepare:

  • Admit card printed (or saved to phone/downloaded)
  • Government ID (Aadhaar/PAN/Passport matching registration name)
  • Photographs in required quantity and specification (check the invite)
  • Any other documents specified in the exam invite

Technical preparation (for online exam):

  • TCS iON secure browser downloaded and installed
  • System test completed (as per TCS iON instructions)
  • Webcam and microphone tested
  • Stable internet connection confirmed (run a speed test)
  • Backup internet option identified (mobile hotspot as backup)
  • Room prepared for proctoring (well-lit, quiet, no other people in frame)

Location preparation (for offline exam):

  • Test centre address confirmed and located on maps
  • Route planned with travel time estimated
  • Buffer time calculated (add 30-45 minutes to travel time)

One Day Before

Preparation activity:

  • Light formula review (15-20 minutes): Numerical formulas, Reasoning method notes
  • Error log scan (10 minutes): Note the 5 most common error types you want to avoid
  • No new study, no new topics
  • No full mocks

Physical preparation:

  • Normal sleep time (do not try to sleep unusually early - your body will not cooperate)
  • Normal dinner (not an unusually heavy meal)
  • Lay out everything needed for tomorrow

Exam Morning

Timeline for a 9:00 AM exam:

  • 6:30 AM: Wake up
  • 6:30-7:00 AM: Morning routine
  • 7:00-7:15 AM: Formula sheet review (just the sheet, nothing else)
  • 7:15-7:45 AM: Breakfast (moderate, not heavy)
  • 7:45 AM: Leave for test centre
  • 8:30 AM: Arrive at test centre (30 minutes early)
  • 8:30-9:00 AM: Document verification, seating

The mental state at exam time: You have prepared. The preparation is done. The exam is the opportunity to demonstrate what the preparation built. The questions will be new, but the skills are yours. Focus on executing the methods you have practised, not on hoping the problems are familiar.

Summary: The Mock Test System in Twelve Principles

Principle 1: Mocks measure; they do not teach. Content learning must precede mock taking.

Principle 2: Begin with topic mini-mocks, progress to section mocks, then progress to full mocks. The sequence matters.

Principle 3: Every mock must be taken under exam conditions - no calculator, no distractions, strict time limits.

Principle 4: The analysis after a mock is more valuable than the mock itself. Two hours of rigorous analysis is not excessive.

Principle 5: Classify every wrong answer by type (A: conceptual, B: careless, C: time). The distribution determines your next action.

Principle 6: An error log is the compounding asset of mock preparation. Maintain it rigorously from the first mock.

Principle 7: Retaking the same mock inflates scores without improving capability. Always use fresh mocks.

Principle 8: 8-12 full mocks over a 12-week period is adequate. More than 15 full mocks enters diminishing returns territory.

Principle 9: Taper in the final week. The last full mock should be 7 days before the actual exam.

Principle 10: Foundation stability (70%+ accuracy in all Foundation sections) must be achieved before adding Advanced section mocks for Digital targeting.

Principle 11: Performance plateaus indicate a specific problem (familiarity ceiling, speed ceiling, stamina ceiling, anxiety amplification). Diagnose the specific cause and address it specifically.

Principle 12: The goal of every mock is to be slightly better prepared for the next mock - not to perform well, but to learn. Performance on the actual NQT is the only score that matters.

These twelve principles constitute the complete mock test strategy. The candidates who execute all twelve throughout their preparation period consistently outperform those who take mocks casually. The preparation gap between casual mock-takers and systematic mock users is often 10-15 percentage points in section accuracy - the difference between Ninja-range performance and Digital-range performance. Systematic mock analysis is that valuable.

The Complete Mock Test Resource Guide

Where to Find the Best TCS NQT Practice Material

For Foundation Section Mocks:

The most effective sources in order of NQT-calibration accuracy:

  1. TCS iON official sample tests (highest calibration, limited volume)
  2. PrepInsta TCS NQT mock series (reasonable calibration, high volume)
  3. IndiaBix Quantitative Aptitude (useful for Numerical topic practice)
  4. Verbal aptitude resources (RC practice from newspaper editorials)

For Foundation Coding Mocks:

  1. LeetCode Easy problems (best quality and quantity for Foundation Coding practice)
  2. HackerRank Easy problems
  3. TCS iON coding practice (when available)
  4. The C/C++/Python coding articles in this series provide TCS-specific coding problem practice

For Advanced Section Mocks:

  1. LeetCode Medium and Hard (best quality for Advanced Coding calibration)
  2. Codeforces Div.2 problems (competitive programming contest format)
  3. Advanced Quants resources: probability and combinatorics textbook problems
  4. The TCS NQT Preparation Guide covers Foundation and Advanced section questions calibrated to the actual NQT assessment difficulty

Building Your Custom Mock Schedule Document

Create a simple spreadsheet with these columns:

Week Mock Type Platform Sections Target Date Completed Score Analysis Done
3 Section - Numerical PrepInsta Numerical only Week 3, Thu      
3 Section - Verbal PrepInsta Verbal only Week 3, Sat      
4 Section - Reasoning PrepInsta Reasoning only Week 4, Thu      
5 Full - Foundation TCS iON All Foundation Week 5, Sat      
…              

Fill in each row after completion. Review the spreadsheet weekly to ensure you are on schedule and to track improvement trends.

The mock test schedule is your preparation commitment made concrete. A completed row with analysis noted means you have done the work. An empty row means preparation is falling behind. The schedule holds you accountable in a way that vague intentions to “take more mocks” cannot.

Why Mock Analysis Produces Better Results Than More Mocks

A closing perspective on the central argument of this guide: why the analysis matters more than the volume.

Consider two candidates. Candidate A takes 20 full mocks over 10 weeks. After each mock, they note their score and start the next one. Candidate B takes 10 full mocks over 10 weeks. After each mock, they spend 3 hours in rigorous analysis - classifying every error, updating the error log, identifying top 3 weak areas, and executing targeted study before the next mock.

On exam day:

  • Candidate A has more mock experience but has practised the same patterns 20 times without systematic improvement to the underlying weaknesses.
  • Candidate B has fewer mock experiences but has systematically addressed every identifiable weakness through the analytical cycle.

The research on deliberate practice - the systematic study of how people improve at cognitive skills - consistently shows that improvement comes from identifying specific weaknesses, targeting them specifically, and measuring whether the targeting worked. Not from volume of experience alone.

Mocks are the measurement instrument. Analysis is the identification. Targeted study is the treatment. The next mock is the verification. This diagnostic-treatment cycle, repeated across every session of preparation, is deliberate practice applied to NQT preparation.

Run the cycle consciously and consistently. The NQT score it produces is the most accurate reflection of your capability that structured preparation can achieve.