All companies
Infosys logo
IT Services
Systems Engineer (SE) · Digital Specialist Engineer (DSE) · Specialist Programmer (SP)
Infosys online assessment — aptitude/pseudocode (SE) or long coding assessment (DSE/SP)

Infosys Interview Questions & Placement Prep (2026)

Infosys runs two distinct hiring tracks: Systems Engineer (SE) usually starts with a 100-minute aptitude, verbal, pseudocode and puzzle assessment, while Digital Specialist Engineer (DSE) and Specialist Programmer (SP) are selected mainly through a long coding assessment (typically 3 problems in 3 hours) followed by live technical interviews. This guide covers the exact section-wise pattern, full syllabus with formulas, representative questions, ready code, SQL/DBMS/OOP revision and an 8-week roadmap. The official assessment email always overrides any public preparation resource, including this guide.

SE: 5 sections / 54 questions / 100 min (Logical, Mathematical, Verbal, Pseudocode, Puzzle). DSE/SP: usually 3 coding problems (easy/medium/hard) in ~3 hours, followed by technical and HR interviews

Last updated:

Exam Pattern

SE: 5 sections / 54 questions / 100 min (Logical, Mathematical, Verbal, Pseudocode, Puzzle). DSE/SP: usually 3 coding problems (easy/medium/hard) in ~3 hours, followed by technical and HR interviews

SectionQuestionsTimeTypeDifficulty
SE — Logical Reasoning1525 minMCQEasy–Medium
SE — Mathematical Ability1035 minMCQMedium
SE — Verbal Ability2020 minMCQEasy–Medium
SE — Pseudocode510 minMCQMedium
SE — Puzzle Solving410 minMCQMedium–Hard
DSE/SP — Coding AssessmentUsually 3 (easy, medium, hard)~3 hoursCodingMedium–Complex

Section-Wise Syllabus

Everything that appears in the assessment, grouped by section.

1. SE — Logical Reasoning (15 Qs, 25 min)

Series & coding-decoding

  • • Arithmetic/geometric/alternating series
  • • Difference-of-difference series
  • • Alphabet shifting & reverse alphabet coding
  • • Position-based coding
  • • Symbol substitution
  • • Conditional coding

Arrangements & logic

  • • Linear and circular seating
  • • Floor-based puzzles, scheduling, ranking, distribution
  • • Syllogism (set relationships)
  • • Blood relations (family tree)
  • • Data sufficiency
  • • Direction sense (coordinate method)

2. SE — Mathematical Ability (10 Qs, 35 min)

Number theory & percentages

  • • Divisibility rules, prime factorisation, HCF/LCM
  • • Remainders, unit digit, factor count, trailing zeroes, modular arithmetic
  • • Percentage change and successive percentage change formulas

Commercial & work-rate maths

  • • Profit, loss and discount formulas
  • • Ratio and proportion
  • • Averages (including removed-value formula)
  • • Time and work, combined rate
  • • Time, speed and distance (average speed formula, km/h to m/s)
  • • Simple and compound interest

Combinatorics & DI

  • • Permutation and combination (nPr, nCr)
  • • Probability (independent events)
  • • Data interpretation: tables, bar/pie/line graphs, caselets

3. SE — Verbal Ability (20 Qs, 20 min)

Grammar

  • • Subject-verb agreement
  • • Tenses, articles, prepositions, pronouns, conjunctions
  • • Modifiers
  • • Active/passive and direct/indirect speech
  • • Sentence correction

Comprehension & vocabulary

  • • Fill in the blanks
  • • Para jumbles
  • • Reading comprehension (question-first strategy)
  • • Synonyms and antonyms
  • • Vocabulary in context

4. SE — Pseudocode (5 Qs, 10 min)

Core focus areas

  • • Loops and nested loops
  • • Conditions
  • • Arrays and strings
  • • Functions and recursion
  • • Bitwise operators
  • • Operator precedence
  • • Sorting and searching
  • • Time-complexity estimation

Precedence order

  • • Parentheses
  • • Unary operators
  • • Multiplication, division, modulus
  • • Addition and subtraction
  • • Relational operators
  • • Equality operators
  • • Logical AND
  • • Logical OR
  • • Assignment

5. SE — Puzzle Solving (4 Qs, 10 min)

Types

  • • Numerical grids
  • • Missing numbers
  • • Figure completion
  • • Pattern recognition
  • • Arrangement puzzles
  • • Mathematical logic
  • • Visual sequence problems
  • • Data-based games

6. DSE/SP — Coding syllabus (Easy)

Foundational topics

  • • Array traversal
  • • Frequency counting
  • • Prefix sums
  • • Sorting
  • • Binary search
  • • Two pointers
  • • String reversal
  • • Palindrome checking
  • • Anagram checking
  • • Stack-based parentheses
  • • Linked-list reversal
  • • Basic recursion
  • • Basic tree traversal

7. DSE/SP — Coding syllabus (Medium)

Core algorithms

  • • Sliding window
  • • Hashing
  • • Greedy algorithms
  • • Interval merging
  • • BFS and DFS
  • • Topological sorting
  • • Heap and priority queue
  • • Binary search on answer
  • • Subset sum
  • • 0/1 knapsack
  • • Longest common subsequence
  • • Longest increasing subsequence
  • • Grid dynamic programming
  • • Disjoint-set union

8. DSE/SP — Coding syllabus (Hard/Complex — SP level)

Advanced topics

  • • Tree DP and rerooting DP
  • • Heavy-light concepts
  • • Segment trees and Fenwick trees
  • • Dijkstra's algorithm and Bellman-Ford basics
  • • Minimum spanning tree
  • • Strongly connected components
  • • Bitmask DP
  • • Trie-based optimisation
  • • Range-query and offline queries
  • • String algorithms
  • • Meet-in-the-middle

Official sample-assessment style

  • • Easy: Tree Beauty
  • • Medium: Good Subsequence with GCD
  • • Hard: Longest Non-Decreasing Subsequence with XOR
  • • Complex: Tree Edge Flipping with Pattern Matching

Most Asked Topics

Highest-frequency areas across recent test papers.

Series & coding-decoding

First/second-difference series and alphabet-shift coding (A=1...Z=26) appear in nearly every SE slot.

Percentages & successive change

Net change = a + b + ab/100 for successive percentage changes; a recurring SE quant favourite.

Pseudocode output tracing

Operator precedence with unary increment/decrement (e.g. x++ + ++y) and nested-loop tracing.

Seating arrangement & syllogism

Linear/circular seating and set-relationship syllogisms — draw the diagram before answering.

Prefix sum & sliding window (DSE/SP)

Longest subarray with a target sum, subarray-based two-pointer and window problems.

DP ladder (DSE/SP)

0/1 knapsack, LCS, LIS, grid DP and subset sum are the medium-tier backbone; tree DP and bitmask DP for SP.

Graph algorithms (SP)

Dijkstra, MST (Kruskal/Prim with DSU), topological sort and SCC for higher-level problems.

Interview — CS fundamentals & project

DSA approach explanation, DBMS/normalisation, OS threading and a deep dive into your project's architecture.

Free Resources

Curated practice links per section.

Aptitude & Reasoning (SE)

Pseudocode & Puzzles

DSE/SP coding practice

CS fundamentals

Interview experiences

50+ DSA Practice Problems

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

Easy — SE/DSE entry level (10)

  1. Array traversal with frequency counting
  2. Prefix sum of an array
  3. Binary search (iterative)
  4. Two-pointer pair-sum check
  5. Reverse a string without built-ins
  6. Check whether a string is a palindrome
  7. Anagram check using sorting
  8. Balanced parentheses using a stack
  9. Reverse a linked list
  10. Level-order (basic) tree traversal

Medium — DSE level (12)

  1. Longest substring without repeating characters (sliding window)
  2. Two Sum / Three Sum using hashing
  3. Merge overlapping intervals
  4. BFS and DFS on a graph
  5. Topological sort of a DAG
  6. Kth largest element using a heap
  7. Binary search on the answer (minimize the maximum)
  8. Subset-sum feasibility
  9. 0/1 knapsack
  10. Longest common subsequence
  11. Longest increasing subsequence
  12. Union-Find / disjoint-set union for connectivity

Hard/Complex — SP level (10)

  1. Tree DP: maximum path sum in a binary tree
  2. Rerooting DP for all-node subtree answers
  3. Segment tree with range sum/update
  4. Fenwick tree (BIT) for prefix sums
  5. Dijkstra's algorithm with a min-heap
  6. Bellman-Ford for negative-weight edges
  7. Minimum spanning tree (Kruskal with DSU)
  8. Strongly connected components (Tarjan/Kosaraju)
  9. Bitmask DP (e.g. travelling salesman subset DP)
  10. Trie-based prefix search and optimisation

Fundamentals to code from memory (6)

  1. Bubble, selection and insertion sort
  2. GCD using the Euclidean algorithm
  3. Prime check in O(√n)
  4. Count of divisors using prime factorisation
  5. Modular exponentiation
  6. Sieve of Eratosthenes

Previous Year Questions & Patterns

Repeat coding questions with the expected approach.

Mathematical ability PYQs

  • LCM(a,b) × HCF(a,b) = a × b — used to find one number given the other, LCM and HCF
  • Number of divisors of n = p1^a1 · p2^a2 ··· pk^ak is (a1+1)(a2+1)···(ak+1)
  • Successive percentage changes a% and b%: net change = a + b + ab/100 (negative for decreases)
  • SP = MP(1 − d/100); do not confuse discount %, profit % and markup %
  • Average removed-value formula: x = (old average × n) − (new average × (n−1))
  • Average speed for equal distances at speeds u and v: 2uv/(u+v)
  • 1 km/h = 5/18 m/s — always convert before solving train problems

Logical reasoning PYQs

  • Number series: find first differences, then second differences; check multiplication/squares/cubes if that fails
  • Coding-decoding: alphabet positions A=1 ... Z=26 for shift-based codes
  • Syllogism: 'All A are B. Some B are C.' → you cannot conclude 'some A are C'
  • Blood relations: draw a family tree and convert every statement into a relationship
  • Data sufficiency: determine if Statement I alone, Statement II alone, both together, or neither is sufficient

Pseudocode PYQs

  • int x = 5, y = 2; cout << x++ + ++y; → output is 8
  • Trace a loop with a decrementing counter and an early break
  • Predict output when a unary operator appears inside an array index
  • Nested loop output prediction with mixed increment/decrement

DSE/SP coding questions

  • Tree Beauty (easy, from the official sample assessment)
  • Good Subsequence with GCD (medium, from the official sample assessment)
  • Longest Non-Decreasing Subsequence with XOR (hard, from the official sample assessment)
  • Tree Edge Flipping with Pattern Matching (complex, from the official sample assessment)
  • Find the maximum length subarray whose sum equals K (prefix sum + hash map)
  • Minimum number of coins for a target value (DP)
  • Number of islands in a binary matrix (BFS/DFS)
  • Weighted interval scheduling for maximum profit (sort + binary search + DP)

Interview & HR questions

  • Explain your project architecture and your individual contribution
  • Explain indexing in DBMS and the difference between clustered and non-clustered index
  • Difference between a process and a thread
  • Implement BFS or DFS on the whiteboard
  • Why Infosys? Which role — SE, DSE or SP — are you targeting?
  • Are you willing to relocate and take up rotational shifts?

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, COUNT(*) AS headcount
FROM employees
GROUP BY department
HAVING COUNT(*) > 5;

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 (DSE/SP favourites)

Second-highest salary

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

Nth highest salary (N = 3)

SELECT DISTINCT salary
FROM employees
ORDER BY salary DESC
LIMIT 1 OFFSET 2;

Employees without a department

SELECT name
FROM employees
WHERE dept_id NOT IN (SELECT id FROM departments);

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 is indexing? Clustered vs non-clustered?

An index speeds up reads; clustered index stores data in index order (one per table), non-clustered uses a separate structure (multiple allowed).

What are ACID properties?

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

INNER JOIN vs LEFT JOIN?

INNER keeps only matching rows; LEFT keeps all left-table rows with NULLs where there is no match.

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.

What is a deadlock?

A cyclic wait where processes hold resources needed by each other; prevented by breaking mutual exclusion, hold & wait, no preemption or circular wait.

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 or 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 enable dynamic dispatch in C++.

Class vs object

A class is the blueprint; an object is an instance holding its own state.

Disjoint-set union (DSU)

Union-Find with path compression and union by rank — core to Kruskal's MST and connectivity problems.

Time complexity basics

Array access O(1), balanced BST/binary search O(log n), merge sort O(n log n), BFS/DFS O(V+E), Dijkstra with heap O((V+E) log V).

Bitmask DP

Represent subsets as bits of an integer to solve TSP-style or subset-assignment problems in O(2^n · n).

1. Binary search on answer (C++)

cpp

bool canAchieve(vector<int>& arr, int mid) {
    // problem-specific feasibility check
    return true;
}

int binarySearchOnAnswer(vector<int>& arr, int lo, int hi) {
    while (lo < hi) {
        int mid = lo + (hi - lo) / 2;
        if (canAchieve(arr, mid)) hi = mid;
        else lo = mid + 1;
    }
    return lo;
}

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. Longest common subsequence (C++)

cpp

int lcs(string& a, string& b) {
    int n = a.size(), m = b.size();
    vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (a[i - 1] == b[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
            else dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
        }
    }
    return dp[n][m];
}

4. Disjoint-set union with path compression (C++)

cpp

struct DSU {
    vector<int> parent, rank_;
    DSU(int n) : parent(n), rank_(n, 0) {
        for (int i = 0; i < n; i++) parent[i] = i;
    }
    int find(int x) {
        if (parent[x] != x) parent[x] = find(parent[x]);
        return parent[x];
    }
    void unite(int a, int b) {
        int ra = find(a), rb = find(b);
        if (ra == rb) return;
        if (rank_[ra] < rank_[rb]) swap(ra, rb);
        parent[rb] = ra;
        if (rank_[ra] == rank_[rb]) rank_[ra]++;
    }
};

5. Kruskal's minimum spanning tree (C++)

cpp

int kruskalMST(int n, vector<array<int,3>>& edges) {
    // edges: {weight, u, v}
    sort(edges.begin(), edges.end());
    DSU dsu(n);
    int cost = 0;
    for (auto& [w, u, v] : edges) {
        if (dsu.find(u) != dsu.find(v)) {
            dsu.unite(u, v);
            cost += w;
        }
    }
    return cost;
}

6. Fenwick tree / Binary Indexed Tree (C++)

cpp

struct Fenwick {
    vector<int> tree;
    int n;
    Fenwick(int n) : n(n), tree(n + 1, 0) {}
    void update(int i, int delta) {
        for (++i; i <= n; i += i & (-i)) tree[i] += delta;
    }
    int query(int i) {
        int sum = 0;
        for (++i; i > 0; i -= i & (-i)) sum += tree[i];
        return sum;
    }
};

7. Topological sort (Kahn's algorithm, C++)

cpp

vector<int> topoSort(int n, vector<vector<int>>& adj) {
    vector<int> indegree(n, 0), order;
    for (int u = 0; u < n; u++)
        for (int v : adj[u]) indegree[v]++;
    queue<int> q;
    for (int i = 0; i < n; i++) if (indegree[i] == 0) q.push(i);
    while (!q.empty()) {
        int u = q.front(); q.pop();
        order.push_back(u);
        for (int v : adj[u]) if (--indegree[v] == 0) q.push(v);
    }
    return order;
}

8. Bitmask DP — subset sum count (C++)

cpp

int countSubsetsWithSum(vector<int>& arr, int target) {
    int n = arr.size();
    vector<vector<int>> dp(n + 1, vector<int>(target + 1, 0));
    for (int i = 0; i <= n; i++) dp[i][0] = 1;
    for (int i = 1; i <= n; i++) {
        for (int s = 0; s <= target; s++) {
            dp[i][s] = dp[i - 1][s];
            if (arr[i - 1] <= s) dp[i][s] += dp[i - 1][s - arr[i - 1]];
        }
    }
    return dp[n][target];
}

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. Trie insert and search (Python)

cpp

class TrieNode:
    def __init__(self):
        self.children = {}
        self.is_end = False

class Trie:
    def __init__(self):
        self.root = TrieNode()

    def insert(self, word):
        node = self.root
        for ch in word:
            node = node.children.setdefault(ch, TrieNode())
        node.is_end = True

    def search(self, word):
        node = self.root
        for ch in word:
            if ch not in node.children:
                return False
            node = node.children[ch]
        return node.is_end

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.
  • • Paging, segmentation and virtual memory.
  • • Scheduling: FCFS, SJF, SRTF, Round Robin, Priority.
  • • Mutex versus semaphore; race conditions — common DSE/SP interview questions.

DBMS & Transactions

  • • Normalisation up to BCNF; keys (primary, unique, foreign).
  • • Indexing (clustered vs non-clustered) and query optimisation.
  • • ACID guarantees and isolation levels.
  • • SQL joins, subqueries and aggregate functions with GROUP BY/HAVING.

Complexity cheat sheet

  • • Array access O(1); hash-table average lookup O(1).
  • • Balanced BST lookup and binary search O(log n).
  • • Merge sort O(n log n); heap insertion/deletion O(log n).
  • • BFS/DFS O(V+E); Dijkstra with heap O((V+E) log V).
  • • Segment-tree query/update O(log n).

Role-wise expectations

  • • SE: aptitude, reasoning, verbal, puzzle and pseudocode strength; basic CS fundamentals in the technical interview.
  • • DSE: solid coding assessment performance plus DSA and CS fundamentals in the technical interview.
  • • SP: advanced coding assessment, live coding rounds and a deep technical interview covering graph algorithms, DP and system design awareness.
  • • The strongest preparation target is SP level — it automatically covers DSE and SE requirements.

4-Week Preparation Roadmap

From zero to test-ready in 28 days.

Week 1

C++ STL & fundamentals

  • C++ STL: vector, string, map, set, stack, queue
  • Complexity analysis basics
  • Arrays and strings practice
  • Number system revision

Goal: Be comfortable with STL containers and basic array/string manipulation.

Week 2

Sorting & searching

  • Sorting algorithms and custom comparators
  • Binary search and binary search on answer
  • Hashing patterns
  • Two pointers and sliding window

Goal: Solve 15+ easy-medium array/string problems using these techniques.

Week 3

Linked lists, stacks, recursion

  • Linked list operations and reversal
  • Stack/queue-based problems
  • Recursion and backtracking
  • Basic tree traversal

Goal: Code linked-list and recursive problems from memory without hints.

Week 4

Trees, heaps, graphs (part 1)

  • BST operations
  • Heap and priority queue
  • BFS and DFS
  • Tree height/diameter problems

Goal: Implement BFS/DFS and heap-based problems confidently.

Week 5

Greedy, DSU, topological sort

  • Greedy algorithms and interval merging
  • Disjoint-set union
  • Topological sorting
  • Mixed graph practice

Goal: Solve 10+ medium graph/greedy problems.

Week 6

Dynamic programming

  • 1D DP and grid DP
  • 0/1 knapsack
  • Longest increasing subsequence
  • Longest common subsequence

Goal: Build a mental DP recognition checklist (choose/not choose, capacity, prefix).

Week 7

Advanced graphs & data structures (SP)

  • Dijkstra and Bellman-Ford
  • Segment tree and Fenwick tree
  • Tries
  • Bitmask DP basics

Goal: Attempt 5+ SP-level problems combining two concepts, as in the official sample assessment.

Week 8

Full mocks & interview revision

  • One full mock (SE pattern or DSE/SP coding assessment)
  • Previous-year-style coding sets
  • DBMS/OOP/OS revision
  • Project and resume walkthrough

Goal: Complete at least three full mocks and revise the one-page cheat sheet cold.

Exam Day Strategy

Score targets and time allocation.

Section targets

  • SE — Logical Reasoning (25 min): Complete easy series/coding-decoding questions first; return to puzzles later.
  • SE — Mathematical Ability (35 min): Reserve enough time here since it is the longest section; don't rush DI sets.
  • SE — Verbal Ability (20 min): Answer grammar/vocabulary questions fast; read RC questions before the passage.
  • SE — Pseudocode (10 min): Trace every variable on paper; never guess output without tracing.
  • SE — Puzzle Solving (10 min): Skip lengthy puzzles and return later — they can consume disproportionate time.
  • DSE/SP — Coding (≈3 hrs): Read all problems first; solve and submit the easy one early, then medium, then attempt hard/complex last.

Coding time split (50 min)

  • Read all problems and identify difficulty — ~10 min
  • Solve the easy problem completely and submit early — ~30–40 min
  • Medium problem — brute-force to optimised approach — ~50–60 min
  • Hard/complex problem after securing easy + medium test cases — ~60–70 min
  • Test edge cases: min/max n, duplicates, all-equal values, sorted/reverse-sorted, negatives, disconnected graphs, deep trees, overflow

Interview Process

What follows the online test.

Technical Interview — Systems Engineer

  • • Basic CS fundamentals: OOP, DBMS, OS.
  • • Simple coding: array/string manipulation, sorting.
  • • SQL basics: joins, GROUP BY, simple subqueries.
  • • Explain your academic project — role, stack, outcome.
  • • General aptitude follow-up if the written score was borderline.

Technical Interview — Digital Specialist Engineer

  • • Explain your approach for the coding assessment problems in detail.
  • • DSA fundamentals: hashing, sliding window, trees, graphs, DP.
  • • SQL joins, subqueries, normalization and transactions.
  • • OS: processes, threads, deadlocks, memory management.
  • • Project deep dive with technology choices justified.

Technical Interview — Specialist Programmer

  • • Live coding round covering graph algorithms and advanced DP.
  • • Discuss complexity trade-offs for your submitted solutions.
  • • System design basics: scalability, caching, database indexing.
  • • Concurrency and security fundamentals.
  • • Deep architecture discussion of your most complex project.

HR round — all roles

  • • Why Infosys? What do you know about the organisation?
  • • Which role — SE, DSE or SP — are you targeting and why?
  • • Are you willing to relocate and take up rotational shifts?
  • • Strengths, weaknesses and a time you faced team conflict.
  • • Where do you see yourself in five years?

Mock Test Plan

Four simulations to run before the real test.

Mock 1 — Full SE Assessment

  • • 54 questions across 5 sections in 100 minutes, exact section split
  • • Target 75%+ overall with no section left blank

Mock 2 — Pseudocode & Puzzle Sprint

  • • 20 pseudocode + puzzle questions in 25 minutes
  • • Trace every variable on paper; log every mistake

Mock 3 — DSE Coding Round

  • • 2 problems (easy + medium) in 90 minutes
  • • Test with empty, single-element, duplicate and large inputs

Mock 4 — SP Coding Round

  • • 3 problems (easy, medium, hard) in 3 hours, official-sample-assessment style
  • • Aim to fully solve easy + medium and secure partial hard test cases

Mock 5 — Interview Simulation

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

Final Checklist

Tick all of these before test day.

Must-do (SE): all logical reasoning, mathematical ability and verbal ability topics revised with formulas
Must-do (SE): 20+ pseudocode output-tracing questions solved correctly under time
Must-do (DSE/SP): array, string, sorting, searching, hashing and recursion coded from memory
Must-do (DSE/SP): sliding window, 0/1 knapsack, LCS, LIS and grid DP solved without hints
Should-do (SP): Dijkstra, DSU/Kruskal, segment tree, Fenwick tree and bitmask DP practised
Should-do: complexity cheat sheet and DSA-recognition table (keyword → technique) memorised
Project story, DBMS normalisation and OOP pillars ready for the technical interview
Confirm your specific assessment's exact pattern from the official Infosys email — it overrides all public prep resources

Recent Interview Experiences

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

Be the first to share a Infosys interview experience.

Frequently Asked Questions

What is the Infosys Systems Engineer (SE) exam pattern in 2026?

The commonly reported structure is 5 sections in 100 minutes: Logical Reasoning (15 Qs/25 min), Mathematical Ability (10 Qs/35 min), Verbal Ability (20 Qs/20 min), Pseudocode (5 Qs/10 min) and Puzzle Solving (4 Qs/10 min) — 54 questions total. Some drives use an older/different 120-minute variant with extra sections, so always check your specific test invitation.

What is the DSE/SP coding assessment pattern?

Recent reports commonly describe 3 coding problems (one easy, one medium, one hard) in about 3 hours, evaluated with hidden test cases and partial scoring. The official Infosys sample assessment shows an even broader difficulty ladder including a 'complex' fourth problem, so treat both patterns as possible.

What is the difference between SE, DSE and SP?

SE is the standard entry role selected mainly via the aptitude/pseudocode assessment. DSE is selected primarily through a coding assessment followed by a technical interview covering DSA and CS fundamentals. SP is the most advanced coding-focused track with live coding rounds and a deep technical interview on graph algorithms, DP and system design.

Which languages can I use in the Infosys coding round?

Usually C++, Java or Python, but always confirm the allowed languages from your specific test instructions since it can vary by drive.

How hard are the DSE/SP problems really?

The official sample assessment includes problems like 'Tree Beauty' (easy), 'Good Subsequence with GCD' (medium), 'Longest Non-Decreasing Subsequence with XOR' (hard) and 'Tree Edge Flipping with Pattern Matching' (complex) — a useful difficulty and topic reference, though your live test may not match exactly.

Should I prepare for SP even if I'm targeting DSE or SE?

Yes — SP-level preparation covers the DSE coding requirement and gives you the best chance across all three tracks, since it builds the deepest DSA and CS-fundamentals foundation.

Want the full structured prep for Infosys?

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

Explore Premium VaultInfosys Company Sheet

Related Prep

Next steps chosen from the Infosys 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 Infosys coding section.