All companies
TCS logo
IT Services
Ninja (entry) · Digital · Prime (senior/high-package roles)
TCS iON National Qualifier Test (NQT) — Foundation + Advanced sections

TCS Interview Questions & Placement Prep (2026)

TCS hires freshers through the National Qualifier Test (NQT) on TCS iON — a single integrated test with a Foundation part (Numerical, Verbal, Reasoning) and an Advanced part (Advanced Quant/Reasoning + Coding) that together decide whether you're mapped to Ninja, Digital or Prime. This guide covers the full section-wise pattern, syllabus, role-wise interview expectations, PYQ-style questions, ready code, SQL/DBMS/OOP revision and a week-by-week roadmap.

5 sections / ~82 questions / 190 minutes: Foundation (Numerical, Verbal, Reasoning) + Advanced (Quant & Reasoning, Coding) followed by technical, managerial and HR interviews

Last updated:

Exam Pattern

5 sections / ~82 questions / 190 minutes: Foundation (Numerical, Verbal, Reasoning) + Advanced (Quant & Reasoning, Coding) followed by technical, managerial and HR interviews

SectionQuestionsTimeTypeDifficulty
Part A — Numerical Ability~2025 minMCQFoundation
Part A — Verbal Ability~2525 minMCQFoundation
Part A — Reasoning Ability~2025 minMCQFoundation
Part B — Advanced Quant & Reasoning~1525 minMCQAdvanced (Digital/Prime)
Part B — Advanced Coding2 problems90 minCodingAdvanced (Digital/Prime)

Section-Wise Syllabus

Everything that appears in the assessment, grouped by section.

1. Foundation — Numerical Ability (~20 Qs, 25 min)

Arithmetic core

  • • Number system, divisibility, remainders
  • • HCF and LCM
  • • Percentages
  • • Profit, loss and discount
  • • Ratio and proportion
  • • Averages and weighted averages

Applied topics

  • • Mixtures and allegations
  • • Time, speed and distance
  • • Time and work, pipes & cisterns
  • • Simple and compound interest
  • • Ages
  • • Algebraic equations

Advanced arithmetic

  • • Geometry, mensuration and areas
  • • Permutation and combination
  • • Probability
  • • Series and progressions
  • • Clocks and calendars
  • • Data interpretation, mean/median/mode/variance

2. Foundation — Verbal Ability (~25 Qs, 25 min)

Comprehension & correction

  • • Reading comprehension
  • • Sentence completion
  • • Error detection
  • • Sentence correction
  • • Fill in the blanks
  • • Para jumbles
  • • Sentence arrangement

Vocabulary & grammar

  • • Synonyms and antonyms
  • • Idioms and phrases
  • • Vocabulary in context
  • • Articles, prepositions, conjunctions
  • • Subject-verb agreement
  • • Tenses
  • • Active/passive, direct/indirect speech
  • • Pronouns and modifiers
  • • One-word substitution
  • • Paragraph completion

3. Foundation — Reasoning Ability (~20 Qs, 25 min)

Verbal reasoning

  • • Number and letter series
  • • Coding-decoding
  • • Blood relations
  • • Direction sense
  • • Syllogisms
  • • Statement and conclusion / assumption
  • • Data sufficiency
  • • Odd one out
  • • Logical sequence

Non-verbal / arrangement

  • • Seating arrangement
  • • Data arrangement
  • • Puzzles
  • • Venn diagrams
  • • Cubes and dice
  • • Paper folding and cutting
  • • Figure-based reasoning
  • • Data interpretation

4. Advanced Quant & Reasoning (~15 Qs, 25 min — Digital/Prime)

Harder variants

  • • Multi-step arithmetic
  • • Advanced probability
  • • Permutation and combination
  • • Complex seating arrangements
  • • Data sufficiency
  • • Caselet-based data interpretation
  • • Logical deduction
  • • Series and progressions
  • • Geometry-based reasoning
  • • Clocks and calendars
  • • Cryptarithms
  • • Optimization-style aptitude

5. Advanced Coding (2 problems, 90 min)

Programming basics

  • • Input/output
  • • Operators, conditions, loops
  • • Functions

Arrays & strings

  • • Prefix sums
  • • Two pointers
  • • Sliding window
  • • Frequency counting
  • • Palindromes, anagrams, substring processing

Sorting, searching & hashing

  • • Binary search
  • • Custom sorting
  • • Frequency maps
  • • Pair-sum patterns

Recursion & linked structures

  • • Subsequences, permutations, combinations
  • • Linked list reversal, cycle detection, merging

Trees, graphs & DP

  • • Traversals, height, diameter, BST operations
  • • BFS, DFS, connected components, shortest paths
  • • Greedy scheduling/intervals
  • • 1D/grid/subsequence DP, knapsack-style problems

Math & bit manipulation

  • • GCD, primes, factors, modular arithmetic, digit problems
  • • XOR, masks, set bits, powers of two

6. Role-wise expectations & process

Selection stages

  • • Online assessment (NQT)
  • • Technical interview
  • • Managerial / management discussion (where applicable)
  • • HR interview and document verification

Role mapping

  • • Ninja: application development & maintenance — strong Foundation, basic-to-moderate technical fundamentals
  • • Digital: development, integration, modern tech — strong Foundation + good Advanced section + solid DSA/OOP/DBMS
  • • Prime: complex projects, advanced algorithms, system design — very strong Advanced section, deep DSA and CS fundamentals

Most Asked Topics

Highest-frequency areas across recent test papers.

Speed-time-distance & time-work

Train crossing pole/platform, average speed for equal distances, combined work rate — these repeat every drive.

Series & progressions

Find the next number in a sequence using first/second differences, multiplication or alternating patterns.

Blood relations & coding-decoding

Family-tree diagrams and letter-shift codes (e.g. CAT → DBU pattern) are near-guaranteed in reasoning.

Reading comprehension & sentence correction

Subject-verb agreement, tenses and 'neither...nor' style single-correct-option questions.

Pseudo code / output tracing

Loop tracing, operator precedence and unary increment/decrement inside expressions.

Advanced coding — arrays & DP

Longest subarray with sum K, minimum coins, number of islands, longest increasing subsequence, shortest path in a grid.

DBMS & OOP for interviews

Normalisation (1NF/2NF/3NF), vector vs list vs deque, virtual functions and runtime polymorphism.

Project & HR round

Explain your project architecture, your individual contribution, willingness to relocate and 'why TCS'.

Free Resources

Curated practice links per section.

Aptitude & Reasoning

Verbal & Pseudo Code

Coding practice

CS fundamentals

Interview experiences

50+ DSA Practice Problems

Solve in order — arrays and strings first, then sorting and recursion.

Ninja level (10)

  1. Second-largest distinct element in an array
  2. First character in a string that occurs exactly once
  3. Rotate an array to the right by k positions in O(1) extra space
  4. Balanced parentheses check for (), {}, []
  5. Remove duplicate characters preserving first occurrence
  6. Reverse a linked list
  7. Detect a cycle in a linked list
  8. Sum of digits and digit reversal
  9. Check Armstrong number
  10. Pattern printing — pyramid, diamond

Digital level (10)

  1. Longest subarray with sum K (prefix sum + hash map)
  2. Minimum number of coins for a target value (DP)
  3. Number of islands in a binary matrix (BFS/DFS)
  4. Longest increasing subsequence (O(n²) DP or O(n log n) tails)
  5. Shortest path in a grid avoiding blocked cells (BFS)
  6. Merge two sorted linked lists
  7. Level-order traversal of a binary tree
  8. Topological sort of a DAG
  9. Sliding window maximum
  10. Subset sum feasibility

Prime level (8)

  1. Weighted interval scheduling (sort + binary search + DP)
  2. Shortest path with weighted edges (Dijkstra)
  3. Minimum spanning network (Kruskal with DSU or Prim's)
  4. Diameter of a binary tree (DFS/tree DP)
  5. Partition array into two equal-sum subsets (subset-sum DP)
  6. 0/1 knapsack
  7. Longest common subsequence
  8. Cycle detection in a directed graph

Fundamentals to code from memory (8)

  1. Bubble, selection and insertion sort
  2. Binary search (iterative and recursive)
  3. GCD using the Euclidean algorithm
  4. Prime check in O(√n)
  5. Reverse a string / check palindrome
  6. Anagram check using sorting and hashing
  7. Find the missing number using n(n+1)/2
  8. Print all subsequences of a string

Previous Year Questions & Patterns

Repeat coding questions with the expected approach.

Numerical ability PYQs

  • A train 180 m long crosses a pole in 9 seconds → speed = 20 m/s = 72 km/h
  • Marked 40% above cost, 10% discount given → profit % = 26%
  • Average of 5 numbers is 28; after removing one it becomes 25 → removed number = 40
  • A finishes in 12 days, B in 18 days → together = 36/5 = 7.2 days
  • Bag has 5 red, 3 blue balls; draw 2 without replacement → P(both red) = 5/8 × 4/7 = 5/14
  • Series 3, 8, 15, 24, 35, ? → 48 (differences 5, 7, 9, 11, 13)
  • Distinct arrangements of the letters of LEVEL → 5!/(2!2!) = 30

Reasoning ability PYQs

  • Walk 5 km north, turn right 3 km, turn right 5 km → 3 km east of start
  • If CAT is coded as DBU, how is DOG coded? → EPH
  • All programmers are logical; some logical people are gamers → conclusion 'some programmers are gamers' does NOT necessarily follow
  • 5 people in a row with partial position clues → identify what extra information is still needed
  • A is brother of B, C is mother of B, D is father of C → D is maternal grandfather of A

Verbal ability PYQs

  • Choose the correct sentence: 'Neither of the answers is correct' (singular verb with 'neither')
  • Arrange logically: requirements analysed → code written → algorithm tested → software deployed
  • Closest meaning of 'mitigate' → to reduce the severity

Pseudo code / output tracing

  • int x = 5, y = 2; cout << x++ + ++y; → output is 8 (original x used first, y incremented before use)
  • Trace nested loops with increment operators inside array indices
  • Operator precedence order: parentheses → unary → * / % → + − → relational → equality → && → || → assignment

Interview questions

  • Explain the difference between a process and a thread
  • What is normalization? Explain 1NF, 2NF and 3NF
  • Difference between vector, list and deque in C++
  • Explain virtual functions and runtime polymorphism
  • What happens when a URL is entered into a browser?
  • Explain your project architecture and your individual contribution
  • Why TCS? Are you willing to relocate?
  • Which role — Ninja, Digital or Prime — are you targeting?

20+ SQL Query Bank

Write these out by hand — joins and subqueries are asked in both the test and the interview.

Basics & aggregation

Filter and sort

SELECT name, department
FROM employees
WHERE salary > 50000
ORDER BY salary DESC;

Aggregates

SELECT COUNT(*) AS total,
       AVG(salary) AS avg_salary,
       MAX(salary) AS max_salary
FROM employees;

GROUP BY with HAVING

SELECT department, AVG(salary) AS avg_salary
FROM employees
GROUP BY department
HAVING AVG(salary) > 60000;

Joins

INNER JOIN

SELECT e.name, d.department_name
FROM employees e
INNER JOIN departments d
  ON e.dept_id = d.dept_id;

LEFT JOIN

SELECT e.name, d.department_name
FROM employees e
LEFT JOIN departments d
  ON e.dept_id = d.dept_id;

SELF JOIN — employee and manager

SELECT e1.name AS employee, e2.name AS manager
FROM employees e1
JOIN employees e2
  ON e1.manager_id = e2.emp_id;

Subqueries & transactions (Digital/Prime)

Second-highest salary

SELECT MAX(salary) AS second_highest
FROM employees
WHERE salary < (SELECT MAX(salary) FROM employees);

Employees above department average

SELECT e.name, e.salary
FROM employees e
WHERE e.salary > (
  SELECT AVG(salary) FROM employees WHERE dept_id = e.dept_id
);

DBMS & Core Interview Q&A

Short answers you should be able to say out loud.

What is normalization?

Structuring tables through 1NF, 2NF, 3NF and BCNF to remove redundancy and update anomalies.

Primary key vs unique key?

Primary key: one per table, never NULL. Unique key: several allowed and may hold one NULL.

What are ACID properties?

Atomicity, Consistency, Isolation and Durability — the guarantees of a reliable transaction.

What is indexing?

A lookup structure that speeds reads at the cost of storage and slower writes; used heavily in Digital/Prime interviews.

DELETE vs TRUNCATE vs DROP?

DELETE removes selected rows (rollback-able); TRUNCATE clears all rows fast; DROP removes the table itself.

Process vs thread?

A process has its own memory space; threads share the memory of their parent process — a classic TCS interview question.

What is a deadlock and its four conditions?

Mutual exclusion, hold and wait, no preemption, circular wait — all four must hold simultaneously.

Explain paging vs segmentation.

Paging divides memory into fixed-size frames; segmentation divides it into variable-size logical segments.

OOPs Concepts + 10 Code Snippets

Theory plus the exact snippets asked in the technical round.

Encapsulation

Keep fields private and expose controlled accessors — bundling data with the methods that operate on it.

Abstraction

Expose only relevant behaviour through interfaces/abstract classes, hiding implementation detail.

Inheritance

Derive a Child class from a Parent to reuse and extend behaviour.

Polymorphism

Compile-time overloading vs runtime overriding — virtual functions in C++ enable dynamic dispatch.

Virtual functions

Declared with `virtual` in the base class and marked `override` in derived classes for runtime polymorphism.

vector vs list vs deque

vector: contiguous, fast random access; list: doubly linked, fast insert/delete; deque: fast insert/delete at both ends.

Constructor & destructor

Constructor initialises an object (can be overloaded); destructor releases resources when the object goes out of scope.

Time complexity basics

Linear search O(n), binary search O(log n), bubble/selection/insertion O(n²), merge/quicksort O(n log n) average.

1. Binary search (C++)

cpp

int binarySearch(int arr[], int n, int target) {
    int left = 0, right = n - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) return mid;
        else if (arr[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

2. Longest subarray with sum K (C++)

cpp

int longestSubarraySumK(vector<int>& arr, int k) {
    unordered_map<int, int> firstIndex;
    int sum = 0, maxLen = 0;
    for (int i = 0; i < (int)arr.size(); i++) {
        sum += arr[i];
        if (sum == k) maxLen = i + 1;
        if (firstIndex.count(sum - k))
            maxLen = max(maxLen, i - firstIndex[sum - k]);
        if (!firstIndex.count(sum)) firstIndex[sum] = i;
    }
    return maxLen;
}

3. Number of islands — BFS (C++)

cpp

int numIslands(vector<vector<char>>& grid) {
    int rows = grid.size(), cols = grid[0].size(), count = 0;
    vector<vector<bool>> visited(rows, vector<bool>(cols, false));
    int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
    for (int r = 0; r < rows; r++) {
        for (int c = 0; c < cols; c++) {
            if (grid[r][c] == '1' && !visited[r][c]) {
                count++;
                queue<pair<int,int>> q;
                q.push({r, c});
                visited[r][c] = true;
                while (!q.empty()) {
                    auto [cr, cc] = q.front(); q.pop();
                    for (int d = 0; d < 4; d++) {
                        int nr = cr + dx[d], nc = cc + dy[d];
                        if (nr >= 0 && nr < rows && nc >= 0 && nc < cols &&
                            grid[nr][nc] == '1' && !visited[nr][nc]) {
                            visited[nr][nc] = true;
                            q.push({nr, nc});
                        }
                    }
                }
            }
        }
    }
    return count;
}

4. Longest increasing subsequence — O(n log n) (C++)

cpp

int lengthOfLIS(vector<int>& nums) {
    vector<int> tails;
    for (int x : nums) {
        auto it = lower_bound(tails.begin(), tails.end(), x);
        if (it == tails.end()) tails.push_back(x);
        else *it = x;
    }
    return tails.size();
}

5. Minimum coins — DP (C++)

cpp

int minCoins(vector<int>& coins, int amount) {
    vector<int> dp(amount + 1, INT_MAX);
    dp[0] = 0;
    for (int i = 1; i <= amount; i++) {
        for (int c : coins) {
            if (c <= i && dp[i - c] != INT_MAX)
                dp[i] = min(dp[i], dp[i - c] + 1);
        }
    }
    return dp[amount] == INT_MAX ? -1 : dp[amount];
}

6. Reverse a linked list (C++)

cpp

struct Node { int val; Node* next; };

Node* reverseList(Node* head) {
    Node* prev = nullptr;
    while (head) {
        Node* next = head->next;
        head->next = prev;
        prev = head;
        head = next;
    }
    return prev;
}

7. Dijkstra's shortest path (C++)

cpp

vector<int> dijkstra(int n, vector<vector<pair<int,int>>>& adj, int src) {
    vector<int> dist(n, INT_MAX);
    priority_queue<pair<int,int>, vector<pair<int,int>>, greater<>> pq;
    dist[src] = 0;
    pq.push({0, src});
    while (!pq.empty()) {
        auto [d, u] = pq.top(); pq.pop();
        if (d > dist[u]) continue;
        for (auto& [v, w] : adj[u]) {
            if (dist[u] + w < dist[v]) {
                dist[v] = dist[u] + w;
                pq.push({dist[v], v});
            }
        }
    }
    return dist;
}

8. 0/1 Knapsack (C++)

cpp

int knapsack(vector<int>& wt, vector<int>& val, int W) {
    int n = wt.size();
    vector<vector<int>> dp(n + 1, vector<int>(W + 1, 0));
    for (int i = 1; i <= n; i++) {
        for (int w = 0; w <= W; w++) {
            dp[i][w] = dp[i - 1][w];
            if (wt[i - 1] <= w)
                dp[i][w] = max(dp[i][w], dp[i - 1][w - wt[i - 1]] + val[i - 1]);
        }
    }
    return dp[n][W];
}

9. Bank class — encapsulation (Python)

cpp

class Bank:
    def __init__(self):
        self.__balance = 0        # private

    def deposit(self, amount):
        self.__balance += amount

    def get_balance(self):
        return self.__balance

10. Animal / Dog — inheritance & polymorphism (Python)

cpp

class Animal:
    def sound(self):
        print('Some sound')

class Dog(Animal):
    def sound(self):
        print('Bark')

a = Dog()
a.sound()  # runtime polymorphism -> 'Bark'

Operating System Basics

Scheduling, deadlock and memory management essentials.

Operating Systems

  • • Process versus thread and the cost of context switching.
  • • Deadlock and its four necessary conditions: mutual exclusion, hold & wait, no preemption, circular wait.
  • • Paging, segmentation and virtual memory.
  • • Scheduling: FCFS, SJF, SRTF, Round Robin, Priority.
  • • Mutex versus semaphore; race conditions.

DBMS & Networking

  • • Normalisation up to BCNF and why redundancy causes update anomalies.
  • • Indexing (clustered vs non-clustered) and transaction ACID guarantees.
  • • REST APIs and what happens when a URL is entered into a browser.
  • • Git basics: commit, branch, merge, pull request workflow.
  • • OSI layers and TCP vs UDP for general awareness.

C++ / language pitfalls

  • • vector, string, map, unordered_map, set, stack, queue, priority_queue usage.
  • • Sorting with custom comparators and lambda functions.
  • • Pass-by-reference to avoid unnecessary copies.
  • • Watch integer overflow; use long long for large sums/products.
  • • Fast I/O: ios::sync_with_stdio(false); cin.tie(nullptr);

Role-wise expectations

  • • Ninja: C++ fundamentals, OOP, arrays/strings/basic DSA, SQL, DBMS/OS basics, project and resume.
  • • Digital: medium DSA, recursion/backtracking, trees/graphs, DP, SQL joins/grouping/subqueries, normalization, OS processes/threads, REST APIs, Git.
  • • Prime: harder DSA/optimization, graph algorithms/advanced DP, design principles, scalability/caching, indexing/transactions, concurrency, security fundamentals.
  • • Target Prime-level preparation even if your minimum goal is Ninja — it automatically covers Digital and Ninja requirements.

4-Week Preparation Roadmap

From zero to test-ready in 28 days.

Week 1

Foundation basics

  • Number system, percentages, ratios, averages
  • Grammar fundamentals and vocabulary
  • Series, coding-decoding, directions, blood relations
  • C++ syntax, loops, functions, arrays and strings

Goal: Solve 20–30 timed questions daily and be comfortable with every Foundation topic area.

Week 2

Arithmetic and core DSA

  • Profit/loss, mixtures, time-work, speed-distance
  • Reading comprehension and sentence correction
  • Syllogisms, seating arrangements, data sufficiency
  • Sorting, binary search, hashing, two pointers

Goal: Solve at least 10 easy-to-medium coding problems and clear Foundation mocks above 80%.

Week 3

Intermediate DSA

  • Probability, permutation-combination, geometry, DI
  • Para jumbles and vocabulary revision
  • Puzzles and arrangements
  • Linked lists, stacks, queues, recursion, backtracking

Goal: Complete two coding problems in 90 minutes every alternate day.

Week 4

Advanced coding

  • Trees and BSTs
  • Graph BFS/DFS
  • Greedy algorithms
  • Basic dynamic programming
  • Prefix sums, sliding window, monotonic stack

Goal: Solve previous-year-style coding sets confidently within time.

Week 5

Prime/Digital upgrade

  • Dijkstra, DSU, minimum spanning trees
  • Knapsack, LIS, LCS, grid DP, partition DP
  • Complexity analysis
  • OOP, DBMS, SQL, OS and computer networks

Goal: Begin interview preparation for your project and be fluent explaining its architecture.

Week 6

Mock-test phase

  • One full 190-minute mock every alternate day
  • Maintain an error notebook: concept, calculation, misread, time-management, edge-case errors
  • Revise formulas and frequently used C++ templates
  • One peer or recorded mock interview

Goal: Take at least four complete 190-minute mocks and analyse every wrong answer.

Exam Day Strategy

Score targets and time allocation.

Section targets

  • Numerical Ability (25 min): Attempt direct-calculation questions first; skip lengthy DI sets on the first pass.
  • Verbal Ability (25 min): Answer grammar/vocabulary MCQs fast; read RC passages' questions before the passage.
  • Reasoning Ability (25 min): Bank series and blood-relation questions quickly; save time for puzzles.
  • Advanced Quant & Reasoning (25 min): Attempt only if targeting Digital/Prime; prioritise questions you can solve in under 90 seconds.
  • Advanced Coding (90 min): Read both problems first (~3 min); solve the easier one completely, then the harder one; leave 5 min for edge-case testing.
  • Buffer: Finish Foundation sections quickly but accurately since coding separates Digital/Prime performance.

Coding time split (50 min)

  • Read both problems and note constraints — ~5 min
  • Solve the easier problem first, complete with I/O — ~35 min
  • Second (harder) problem — brute-force first, then optimise — ~40 min
  • Edge cases: empty input, single element, duplicates, large n — ~8 min
  • Final review and re-run — ~2 min

Interview Process

What follows the online test.

Technical Interview — Ninja

  • • C++ fundamentals: STL containers, pointers, memory layout.
  • • OOP concepts: inheritance, polymorphism, encapsulation with examples.
  • • Arrays, strings and basic DSA — simple whiteboard coding.
  • • SQL queries and DBMS basics (keys, normalisation).
  • • Your project and resume — role, tech stack, challenges.

Technical Interview — Digital

  • • Medium-level DSA: recursion, backtracking, trees, graphs, dynamic programming.
  • • SQL joins, grouping and subqueries; normalization and transactions.
  • • OS: processes, threads, deadlocks and memory management.
  • • REST APIs, Git workflow and your technology stack.
  • • Project deep dive with design decisions explained.

Technical Interview — Prime

  • • Harder DSA and optimization; graph algorithms and advanced DP.
  • • Design principles, scalability and caching strategies.
  • • Database indexing and transaction isolation levels.
  • • Concurrency basics and security fundamentals.
  • • Detailed architecture discussion of your most complex project.

Managerial & HR round — all roles

  • • Why TCS? What do you know about the organisation?
  • • Are you willing to relocate and work flexible shifts?
  • • Which role — Ninja, Digital or Prime — are you targeting and why?
  • • Explain your project architecture and individual contribution.
  • • Strengths, weaknesses and a time you handled team conflict.

Mock Test Plan

Four simulations to run before the real test.

Mock 1 — Full Foundation

  • • Numerical + Verbal + Reasoning, 75 min, exact section split
  • • Target 80%+ to comfortably clear Foundation cutoffs

Mock 2 — Advanced Quant & Reasoning Sprint

  • • 15 questions in 25 minutes at Digital/Prime difficulty
  • • Log every question that took over 90 seconds

Mock 3 — Coding Round

  • • 2 problems in 90 minutes at your target role's difficulty
  • • Test with empty, single-element, duplicate and large inputs

Mock 4 — Full 190-minute Simulation

  • • All 5 sections back-to-back with breaks as per the real drive
  • • Review sectional cutoffs and time overruns afterward

Mock 5 — Interview Simulation

  • • 20 min technical (role-specific) + project deep dive
  • • 10 min HR covering relocation, shifts and motivation

Final Checklist

Tick all of these before test day.

Must-do: percentages, profit & loss, SI/CI, time & work, speed-time-distance formulas memorised
Must-do: 20+ pseudo-code/output-tracing questions solved correctly under time
Must-do: arrays, strings, sorting, searching, hashing and recursion coded from memory
Must-do: project story, OOP pillars and DBMS normalisation ready for the interview
Should-do (Digital/Prime): trees, graphs, DP, SQL joins/subqueries, Dijkstra, DSU
Should-do: complexity cheat sheet — O(1), O(log n), O(n log n), O(V+E) for common operations
Take at least four full 190-minute mocks and maintain an error notebook
Verify your specific drive's instructions from TCS/TCS iON before the exam — patterns and role mapping can change

Recent Interview Experiences

First-hand write-ups from students who actually sat the TCS process.

Be the first to share a TCS interview experience.

Frequently Asked Questions

What is the TCS NQT exam pattern in 2026?

An integrated test on TCS iON with a Foundation part (Numerical, Verbal, Reasoning — about 75 minutes) and an Advanced part (Advanced Quant & Reasoning plus Coding — about 115 minutes), totalling roughly 190 minutes and 82 questions, followed by technical, managerial and HR interviews.

What is the difference between Ninja, Digital and Prime?

Ninja is the standard entry role focused on application development and maintenance. Digital expects strong Advanced-section performance plus solid DSA/OOP/DBMS for development and integration work. Prime targets complex projects, advanced algorithms and system design, requiring the strongest Advanced-section and coding performance. Role mapping depends on test score, coding performance, interview and academic profile.

Is there negative marking in the TCS NQT?

TCS has not officially confirmed a universal negative-marking scheme in recent announcements; treat older claims as outdated and always verify your specific drive's instructions.

Should everyone attempt the Advanced section?

Yes — candidates aspiring to Digital or Prime should attempt the Advanced Quant/Reasoning and Coding sections, since Ninja-only aspirants can focus primarily on Foundation but attempting Advanced never hurts.

Which languages can I use in the coding round?

TCS NQT typically supports C, C++, Java and Python for the Advanced Coding section; always confirm allowed languages from your specific test instructions.

How many coding problems are there and how difficult are they?

Usually 2 problems in 90 minutes. Ninja-level problems are easy (arrays, strings, basic recursion); Digital-level problems involve prefix sums, DP and graphs; Prime-level problems include weighted scheduling, Dijkstra, MST and tree DP.

Want the full structured prep for TCS?

The Premium Vault covers Aptitude, Core CS, DSA, SQL and HR rounds with module-wise courses and drill sheets.

Explore Premium VaultTCS Company Sheet

Related Prep

Next steps chosen from the TCS pattern and other IT Services (Mass Hiring) recruiters.

Other IT Services (Mass Hiring) companies

Virtusa Interview Prep Guide

Virtusa exam pattern, syllabus and previous year questions · ₹3.5–7 LPA.

Cognizant Technology Solutions Interview Prep Guide

Cognizant Technology Solutions exam pattern, syllabus and previous year questions · ₹4–9 LPA.

Accenture Interview Prep Guide

Accenture exam pattern, syllabus and previous year questions · ₹4.5–11 LPA.

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.

Recommended practice path

DSA 101 Practice Sheet

Beginner-friendly problem set that matches the TCS coding section.