The Victory Key Logo
TVK
Checked on sebi.gov.in: ·2025 advertisement

SEBI Grade A IT Phase 2 Preparation Guide

In the 2025 cycle, Phase II (often written Phase 2) was two online papers: a 60-minute descriptive English paper and a 180-minute IT paper of 100 multiple-choice questions. SEBI describes those questions as a mix of logic flow completion, debugging, syntax understanding, program dry run outputs, data analysis, etc. This is last cycle's pattern. SEBI has not published one for 2026.

  • 56.67%

    IT paper's share of final merit (2/3 × 85%)

  • 1.8 minutes

    Average per IT question (180 minutes, 100 questions)

  • 70 of 100

    Indicative IT marks on data structures and algorithms

  • 60 of 100

    Indicative Phase I marks on topics with no row in the Phase II table

Take a free SEBI IT mock test Try the worked code examples

Our full-length SEBI mock tests have the Phase I Paper 2 shape: 50 questions in 40 minutes. No SEBI test on our site has the Phase II shape of 100 questions in 180 minutes, and none covers the English paper (our test list, read on 4 November 2026). Use them for timed accuracy, and use this page for code reading. New to this exam? Start with our SEBI Grade A IT hub.

2025 cycle, last cycle's pattern

What Phase II was in the 2025 cycle

From SEBI's 2025 advertisement and Phase II handout . As of 4 November 2026, SEBI's Vacancies page lists no 2026 advertisement, so the 2026 pattern is not known.

SEBI Grade A IT Phase II papers, 2025 cycle
PaperWhat it isQuestionsMarksTimeMinimumWeight in Phase II
Paper 1English (Descriptive Test), to test drafting skills3: essay 30 marks, precis 30, comprehension 4010060 min30%1/3
Paper 2Information Technology: multiple-choice questions on a mix of logic flow completion, debugging, syntax understanding, program dry run outputs, data analysis, etc.100100180 min40%2/3
BothAggregate on the weighted score50%
  • Date and language. Both papers were set for one date, 21 February 2026. All question papers are set in Hindi and English, except the test of English.
  • Negative marking. 1/4 of the marks assigned to the question, for the multiple-choice questions of Paper 2.
  • Minimums are not the real bar. SEBI shortlists candidates equal to 3 times the vacancies, in merit order. In the 2025 cycle the unreserved IT cut-off was 77.00 out of 100 on the weighted score. Other categories are on our 2025 cut-offs and marks page.
  • Phase I does not carry forward. Phase I marks are used only for shortlisting and are not counted for final selection.

How the papers feed final merit

Weighted score (TWS) = (1/3 × English) + (2/3 × IT). Final score = (0.85 × TWS) + interview marks out of 15. The final score is out of 100.

Share of final merit for each part of the 2025 selection
PartArithmeticShare of final merit
Paper 2, IT2/3 × 85%56.67%
Paper 1, English1/3 × 85%28.33%
Interview15%15.00%
Total100.00%

SEBI gives the weights, and these percentages are our arithmetic from them. One IT mark adds 0.567 to the final score and one English mark adds 0.283. You can test the formula on SEBI's own figures: the last unreserved IT candidate selected had a TWS of 80.67 and an interview mark of 11, and 0.85 × 80.67 + 11 = 79.570, the score in SEBI's minimum marks table .

SEBI has changed this paper before

Format of Phase II Paper 2 in the Information Technology stream, by cycle
CycleFormatSizeSource
2020Online programming test5 questions, 3 hoursSEBI handout
2022Online programming test5 questions, 3 hoursSEBI handout
2024Coding test in C++, Java or Python9 questions, 210 minutesSEBI handout
2025Multiple-choice questions100 questions, 180 minutesSEBI handout

So check the next advertisement when it appears, before relying on any of this. It also means a Phase II question from 2020 to 2024 is not a sample of the 2025 format. Our previous year questions page explains what exists and where it comes from.

Phase II IT syllabus, 2025 advertisement

Marks by topic, and what to be able to do

SEBI marks these weights as indicative only, so they are a guide and not a promise. The concept names are SEBI's. The tasks under each concept are our reading of what it asks for, because SEBI does not publish that.

Phase II Paper 2 IT syllabus in the 2025 advertisement, with indicative weights
TopicIndicative marksConcepts SEBI lists
Data Structure40Array, linked list, stack, queue, binary tree, indexing, binary search tree, heap, hashing, matrix, JSON objects
Algorithms30Sorting, searching, greedy algorithms, dynamic programming, backtracking, divide and conquer, pattern searching
Object Oriented Programming20Abstraction, encapsulation, polymorphism, inheritance
String Manipulation10Length, substring, regex, search

Data Structure: 40 marks (indicative)

  • Array. Trace index changes by hand and catch off-by-one errors in loop bounds.
  • Linked list. Insert, delete and reverse by redrawing the pointers on paper, without losing a node.
  • Stack. Trace push and pop, evaluate a postfix expression and check balanced brackets.
  • Queue. Trace a circular queue, including the wrap-around with the modulo operator.
  • Binary tree. Write the preorder, inorder, postorder and level-order output of a 7-node tree.
  • Indexing. SEBI does not define this term here. Cover array index arithmetic, and how an index structure speeds up a lookup.
  • Binary search tree. Insert a list of keys, delete a node with two children, and use the fact that inorder output is sorted.
  • Heap. Build a min-heap or max-heap from an array, sift up and down, and find a parent or child by index.
  • Hashing. Insert keys with h(k) = k mod m under chaining and under linear probing, and count the collisions.
  • Matrix. Trace nested loops over rows and columns: transpose, rotate, multiply.
  • JSON objects. Read nested objects and arrays, follow a key path, and spot invalid JSON such as a trailing comma.

Algorithms: 30 marks (indicative)

  • Sorting. Run one pass of bubble, selection and insertion sort, one quicksort partition and one merge by hand. Know each one's time complexity and whether it is stable.
  • Searching. Trace the bounds of binary search, find the first or last occurrence, and count comparisons.
  • Greedy algorithms. Run activity selection or fractional knapsack, and show an input where greedy fails.
  • Dynamic programming. Fill the table by hand for 0/1 knapsack, longest common subsequence and coin change.
  • Backtracking. Trace N-Queens or subset sum. Say the order states are visited in, and where a choice is undone.
  • Divide and conquer. Trace merge sort recursion, and solve T(n) = 2T(n/2) + n.
  • Pattern searching. Count comparisons in naive search, build the KMP prefix table for a short pattern, and explain the rolling hash in Rabin-Karp.

Object Oriented Programming: 20 marks (indicative)

  • Abstraction. Say what an abstract class or interface forces a subclass to do, and which lines will not compile.
  • Encapsulation. Read access modifiers and say which outside access fails.
  • Polymorphism. Tell overloading (chosen at compile time) from overriding (chosen at run time), and say which version runs.
  • Inheritance. Give the constructor order, the effect of super, and what happens when a field is hidden.

String Manipulation: 10 marks (indicative)

  • Length. Know length in each language: strlen and the terminating null in C, length() in Java, len() in Python.
  • Substring. Get the end index right. Java substring(2, 5) and Python s[2:5] both stop before index 5.
  • Regex. Read character classes, quantifiers, anchors, groups and backreferences, and predict what a pattern matches.
  • Search. Know what a failed search returns: -1 from indexOf in Java and find in Python, a null pointer from strstr in C.

What does not carry over from Phase I

Database Concepts (10), SQL Queries (10), Networking Concepts (10), Information & Cyber Security (10), Data warehousing (5), Shell Programming (5) make up 50 of Phase I's 100 indicative IT marks. None of them is named in the Phase II IT syllabus, so do not spend Phase II time on them. Python / R also has no row there, which brings the total to 60. Operating systems are not in the IT syllabus for either phase.

What continues: algorithms, object-oriented ideas from Programming Concepts, and regex, which Phase I lists under data analytics languages and Phase II lists under String Manipulation. See the full SEBI syllabus and exam pattern for both phases side by side.

Question styles

SEBI's named question styles, with worked examples

SEBI's list ends in "etc.", and its Phase II handout says the question types are only illustrative and not exhaustive, and that questions may be of a higher difficulty level. Treat these five as a floor.

Languages are our choice. SEBI's description of this paper names no language. The 2 IT samples in its Phase II handout are one on compile-time polymorphism in C++ and one on a regex backreference. Its Phase I syllabus names Java, C and C++ for programming, and Python and R for data analytics. So we use C, C++, Java and Python here.

These are our own questions. We wrote all 8 of them, and none comes from a SEBI paper. We compiled and ran every program and show only the output we got: C and C++ with clang 17, Java with OpenJDK 21, Python 3.13. Try each one before you open the answer.

Logic flow completion

You get code with a blank and choose what completes it.

  1. Read what the code must do for every input, not just the sample in the question.
  2. Say the rule that each loop pass must keep true. For example: small holds the index of the smallest value so far.
  3. Pick the smallest input that could break a wrong option: equal values, one element, the last position.
  4. Put each option in the blank and test it on that input. A wrong option often passes on an easy input.

TVK practice example

Data Structure: heap · C

This function must restore a min-heap when only a[i] may be out of place. Which expression belongs in the blank?

#include <stdio.h>

void sift_down(int a[], int n, int i) {
    while (1) {
        int small = i;
        int l = 2 * i + 1, r = 2 * i + 2;
        if (l < n && a[l] < a[small]) small = l;
        if (r < n && ________) small = r;
        if (small == i) break;
        int t = a[i]; a[i] = a[small]; a[small] = t;
        i = small;
    }
}

int main(void) {
    int a[] = {5, 1, 2, 9, 7, 3, 4};
    sift_down(a, 7, 0);
    for (int k = 0; k < 7; k++) printf("%d ", a[k]);
    printf("\n");
    return 0;
}
  1. A.a[r] < a[small]
  2. B.a[r] < a[i]
  3. C.a[r] > a[small]
  4. D.a[r] < a[l]
  5. E.small == l
Answer and working

Answer: A

  1. The rule for each pass: small holds the index of the smallest value seen so far among the parent and its children. The right child must be compared with that value, which is a[small].
  2. Option B compares with the parent only, so on 5 1 2 it picks 2 even though 1 is smaller. Option D ignores the parent, so it can swap a parent that was already smaller than both children.
  3. On this input option A gives 1 5 2 9 7 3 4: every parent is at most its children. The other four options leave a parent larger than a child.

Output with the right option in the blank

1 5 2 9 7 3 4
What each option did when we ran it
OptionWhat happened when we ran it
A1 5 2 9 7 3 4 (a valid min-heap)
B2 1 4 9 7 3 5 (not a heap: 2 is above 1)
C2 1 4 9 7 3 5 (not a heap: 2 is above 1)
D1 7 2 9 5 3 4 (not a heap: 7 is above 5)
E2 1 4 9 7 3 5 (not a heap: 2 is above 1)

Debugging

You get code with a wrong result and choose the fix.

  1. Run the code by hand on the smallest input that shows the bug.
  2. Find the first line where a variable stops holding what it should. The bug is at or before that line.
  3. Check the usual causes: order of updates, loop bounds, = against ==, integer division, a missing base case.
  4. Test the option you pick on the original input. A change that looks right can still fail.

TVK practice example

Data Structure: linked list · C

This program should print 3 2 1, but it prints an empty line. Which single change fixes it?

#include <stdio.h>
#include <stdlib.h>

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

struct Node *push(struct Node *head, int v) {
    struct Node *n = malloc(sizeof *n);
    n->val = v;
    n->next = head;
    return n;
}

struct Node *reverse(struct Node *head) {
    struct Node *prev = NULL, *cur = head;
    while (cur != NULL) {
        struct Node *nxt = cur->next; /* L1 */
        cur->next = prev;             /* L2 */
        cur = nxt;                    /* L3 */
        prev = cur;                   /* L4 */
    }
    return prev;
}

int main(void) {
    struct Node *head = NULL;
    for (int v = 3; v >= 1; v--) head = push(head, v);
    head = reverse(head);
    for (struct Node *p = head; p; p = p->next)
        printf("%d ", p->val);
    printf("\n");
    return 0;
}
  1. A.Swap lines L1 and L2
  2. B.Change return prev; to return cur;
  3. C.Start prev at head instead of NULL
  4. D.Change the loop test to cur->next != NULL
  5. E.Swap lines L3 and L4
Answer and working

Answer: E

  1. prev should end on the last node handled. L3 moves cur forward first, and then L4 copies that new value into prev, so prev and cur are always the same. L4 is the first line where a variable stops holding what it should.
  2. When the loop ends cur is NULL, so prev is NULL too. The function returns NULL and nothing is printed.
  3. Swapping L3 and L4 saves the current node in prev before cur moves on. The program then prints 3 2 1.

Output when we ran it

(an empty line)
What each option did when we ran it
OptionWhat happened when we ran it
AEmpty line
BEmpty line
CEmpty line
D3
E3 2 1

Syntax understanding

You decide what a compiler or interpreter accepts, and what a construct means.

  1. Ask first whether the code is accepted at all. Only then ask what it does.
  2. Keep compile errors and wrong results apart. They are different answers.
  3. Read the options for small differences: a bracket, a semicolon, a type suffix, a group number.
  4. Learn the rules behind the errors: overload ranking, access rules, return types, regex groups.

TVK practice example

Object Oriented Programming: polymorphism (compile-time, function overloading) · C++

One statement goes in main where the comment is. Four of these compile and one is rejected by the compiler. Which one is rejected?

#include <iostream>
using namespace std;

void show(int x)    { cout << "int " << x << "\n"; }
void show(double x) { cout << "double " << x << "\n"; }

int main() {
    /* the statement goes here */
    return 0;
}
  1. A.show(7);
  2. B.show('A');
  3. C.show(2.5f);
  4. D.show(5L);
  5. E.show(true);
Answer and working

Answer: D

  1. The compiler picks an overload at compile time by ranking the conversion each call needs. A call that needs no conversion ranks first, then a promotion, then a plain conversion.
  2. char and bool promote to int. float promotes to double. So options B, C and E each have one clear winner.
  3. long has no promotion to int or to double. Both are plain conversions of equal rank, so the call is ambiguous and the compiler stops with an error.
What each option did when we ran it
OptionWhat happened when we ran it
ACompiles, prints: int 7
BCompiles, prints: int 65
CCompiles, prints: double 2.5
DCompile error: call to 'show' is ambiguous
ECompiles, prints: int 1

TVK practice example

String Manipulation: regex, search · Python

The program must print [True, True, False, False]: same opening and closing tag, nothing outside them. Which pattern belongs in the blank?

import re

pattern = r"________"
tests = ["<b>hi</b>", "<code>x</code>", "<b>hi</i>", "x<b>hi</b>"]
print([bool(re.search(pattern, t)) for t in tests])
  1. A.^<(\w+)>.*</\1>$
  2. B.^<\w+>.*</\w+>$
  3. C.^<(\w+)>.*</\2>$
  4. D.<(\w+)>.*</\1>
  5. E.^<(\w)>.*</\1>$
Answer and working

Answer: A

  1. (\w+) captures the tag name as group 1, and \1 must then match that same text again. That is a backreference.
  2. The anchors ^ and $ tie the match to the whole string. re.search alone would accept a match anywhere, which is why option D wrongly accepts x<b>hi</b>.
  3. Option B allows any closing tag. Option C refers to a group 2 that does not exist, so Python raises an error. Option E captures one character only, so it misses <code>.

Output with the right option in the blank

[True, True, False, False]
What each option did when we ran it
OptionWhat happened when we ran it
A[True, True, False, False]
B[True, True, True, False]
CError: invalid group reference 2
D[True, True, False, True]
E[True, False, False, False]

Program dry run outputs

You work out what a program prints. Use the method in how to dry-run code below. These two examples add a table of results and a question on object creation order.

  1. Make a trace table before reading the logic in detail.
  2. For objects, write the order of events: which constructor runs, when each field gets its value.
  3. Ask which things depend on the real object and which depend on the declared type.
  4. Copy the print line character by character: spaces, commas, order.

TVK practice example

Algorithms: dynamic programming, greedy algorithms · Java

What does this program print?

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] coins = {1, 3, 4};
        int[] dp = new int[7];
        for (int amt = 1; amt <= 6; amt++) {
            dp[amt] = 99;
            for (int c : coins) {
                if (c <= amt && dp[amt - c] + 1 < dp[amt]) {
                    dp[amt] = dp[amt - c] + 1;
                }
            }
        }
        System.out.println(Arrays.toString(dp));
    }
}
  1. A.[0, 1, 2, 1, 1, 2, 3]
  2. B.[0, 1, 2, 1, 1, 2, 2]
  3. C.[0, 1, 1, 1, 1, 2, 2]
  4. D.[0, 1, 2, 1, 2, 2, 2]
  5. E.[0, 1, 2, 3, 1, 2, 3]
Answer and working

Answer: B

  1. dp[amt] holds the fewest coins that make the amount amt. For each amount, try every coin and keep the smallest dp[amt - c] + 1.
  2. Amount 6 is the one to watch. Coin 1 gives dp[5] + 1 = 3, coin 3 gives dp[3] + 1 = 2, coin 4 gives dp[2] + 1 = 3. The smallest is 2, from 3 + 3.
  3. Option A is the greedy trap. Taking the largest coin first gives 4 + 1 + 1, which is 3 coins. This is why greedy does not always work here and dynamic programming does.
Coins tried for each amount. A dash means the coin is larger than the amount.
amtc = 1c = 3c = 4dp[amt]
11--1
22--2
331-1
42211
52322
63232

Coins tried for each amount. A dash means the coin is larger than the amount.

Output when we ran it

[0, 1, 2, 1, 1, 2, 2]

TVK practice example

Object Oriented Programming: inheritance, polymorphism · Java

What does this program print?

class Account {
    int limit = 100;
    Account() { show(); }
    void show() { System.out.print("A" + limit + " "); }
    static String kind() { return "base"; }
}

class Savings extends Account {
    int limit = 200;
    Savings() { super(); show(); }
    @Override void show() { System.out.print("S" + limit + " "); }
    static String kind() { return "savings"; }
}

public class Main {
    public static void main(String[] args) {
        Account a = new Savings();
        System.out.println(a.limit + " " + a.kind());
    }
}
  1. A.A100 S200 200 savings
  2. B.S200 S200 100 base
  3. C.A100 S200 100 base
  4. D.S0 S200 100 base
  5. E.S0 S200 200 savings
Answer and working

Answer: D

  1. new Savings() runs the Account constructor first. That constructor calls show(), and an overriding method is chosen by the real object, so Savings.show runs.
  2. At that moment the Savings field limit has not been given its value of 200 yet, so it still holds the default, 0. This prints S0.
  3. Back in the Savings constructor, limit is now 200 and show() prints S200.
  4. The variable a is declared as Account. Fields and static methods are chosen by the declared type, not the real object, so a.limit is 100 and a.kind() is base.

Output when we ran it

S0 S200 100 base

Data analysis

SEBI does not define this style. We read it as working out a result from a small set of data through code, which also fits JSON Objects in the syllabus. That reading is ours.

  1. Write down the shape of the data: a list of objects, which keys, which types.
  2. Apply the filter first and strike out the rows that drop.
  3. Group on paper, with one line per key.
  4. Then compute, and check the output order and number format. In Python, / gives a float, so 65 prints as 65.0.

TVK practice example

Data Structure: JSON objects, hashing · Python

What does this program print? In the options, "then" marks a new line.

import json

rows = json.loads("""[
  {"dept": "IT",  "score": 72, "done": true},
  {"dept": "Law", "score": 65, "done": true},
  {"dept": "IT",  "score": 90, "done": false},
  {"dept": "IT",  "score": 81, "done": true},
  {"dept": "Law", "score": 70, "done": false}
]""")

totals = {}
for r in rows:
    if r["done"]:
        t = totals.setdefault(r["dept"], [0, 0])
        t[0] += r["score"]
        t[1] += 1

for dept in sorted(totals):
    total, n = totals[dept]
    print(dept, total / n)
  1. A.IT 81.0, then Law 67.5
  2. B.IT 76.5, then Law 67.5
  3. C.IT 76.5, then Law 65.0
  4. D.Law 65.0, then IT 76.5
  5. E.IT 153, then Law 65
Answer and working

Answer: C

  1. Filter first. Only rows with done set to true count, so the scores of 90 and 70 drop out.
  2. Group next. The dictionary maps each department to [total, count]: IT becomes [153, 2] and Law becomes [65, 1].
  3. Then read the print line. sorted gives IT before Law, and / in Python always gives a float, so the last value prints as 65.0, not 65.
  4. Option A is what you get if you skip the filter. Option E forgets to divide.
The dictionary after each row
Rowdeptscoredonetotals after this row
1IT72trueIT [72, 1]
2Law65trueIT [72, 1], Law [65, 1]
3IT90falseIT [72, 1], Law [65, 1]
4IT81trueIT [153, 2], Law [65, 1]
5Law70falseIT [153, 2], Law [65, 1]

The dictionary after each row

Output when we ran it

IT 76.5
Law 65.0

Core skill

How to dry-run code: a method you can repeat

A dry run means working out what a program does without running it. The method is the same in every language. Here it is on one step of quicksort, with the table filled in.

  1. Read the print statement first, so you know which variables matter and in what format.
  2. Make one column for each variable that changes. Give an array one column and write the whole array.
  3. Write the starting values in the first row, before any loop runs.
  4. Add one row for each loop pass. Test the condition with the real numbers and write the result.
  5. Take each value from the row above, never from memory.
  6. At a function call, ask whether it gets a copy or can change the original. In C, an array passed to a function is changed in place.
  7. When the loop test fails, stop. Write the printed output character by character, then look at the options.

TVK practice example

Algorithms: sorting, divide and conquer · C

What does this program print?

#include <stdio.h>

int partition(int a[], int n) {
    int pivot = a[n - 1];
    int i = -1;
    for (int j = 0; j < n - 1; j++) {
        if (a[j] <= pivot) {
            i++;
            int t = a[i]; a[i] = a[j]; a[j] = t;
        }
    }
    int t = a[i + 1]; a[i + 1] = a[n - 1]; a[n - 1] = t;
    return i + 1;
}

int main(void) {
    int a[] = {6, 2, 8, 1, 5};
    int p = partition(a, 5);
    printf("%d:", p);
    for (int k = 0; k < 5; k++) printf(" %d", a[k]);
    printf("\n");
    return 0;
}
  1. A.2: 1 2 5 6 8
  2. B.3: 2 1 6 5 8
  3. C.2: 2 1 5 6 8
  4. D.2: 2 1 5 8 6
  5. E.1: 2 5 1 6 8
Answer and working

Answer: C

  1. The pivot is the last element, 5. The variable i marks the end of the part of the array holding values that are at most 5.
  2. Only 2 and 1 pass the test, so i ends at 1. The last swap puts the pivot at index i + 1, which is index 2.
  3. The function returns 2 and the array is 2 1 5 6 8. Option A is the trap: partition is one step of quicksort, so the left part (2 1) is not sorted yet.
Variable trace of partition on the array 6 2 8 1 5
Stepja[j]a[j] <= 5?iArray after this step
Start----16 2 8 1 5
Loop06no-16 2 8 1 5
Loop12yes02 6 8 1 5
Loop28no02 6 8 1 5
Loop31yes12 1 8 6 5
Final swap---12 1 5 6 8

Variable trace of partition on the array 6 2 8 1 5

Output when we ran it

2: 2 1 5 6 8

Time management

A time plan for the 180-minute IT paper

SEBI gives one total time and no time per question. The averages below are arithmetic. The plan is our suggestion, so adjust it after timed practice.

1.8 minutes a question. 180 minutes for 100 questions is 108 seconds each on average, or about 33 questions an hour.
A different pace from Phase I. Phase I Paper 2 gave 0.8 minutes a question (50 questions, 40 minutes). Phase II gives 2.25 times as long per question.
When to guess. The penalty is 1/4 of the marks for the question, so one right answer cancels four wrong ones. A guess breaks even at a 1 in 5 chance of being right. SEBI describes the penalty as being for wrong answers marked by you, so a blank should cost nothing.
Suggested three-pass plan for the 180-minute IT paper. This is our suggestion, not SEBI's.
Our suggestionTimeWhat to do
First pass0 to 90 minutesAnswer everything you can settle at first reading. If a trace looks long, mark the question and move on.
Second pass90 to 150 minutesDo the long traces, on paper, with a table for each.
Last pass150 to 180 minutesRe-check the marked questions. Answer a doubtful one only if your chance of being right is better than 1 in 5.

Build up to it. Practise 60-minute blocks first, then 120, then a full 180 once a week. Three hours of careful tracing is a skill of its own, and you only find your real pace by doing it against a clock.

Paper 1

The descriptive English paper: why it matters, and how to practise

English carries 28.33% of final merit, half the weight of the IT paper, and it has its own 30% minimum. A candidate below that is out, whatever the IT score.

Marks of the 22 candidates SEBI selected in the IT stream, 2025 cycle
Selected IT candidates, 2025 cycle (22)LowestMedianMeanHighest
Paper 1, English (out of 100)47.0058.0058.4571.00
Paper 2, IT (out of 100)71.5085.8885.0692.75

We worked these figures out from SEBI's table of marks of selected candidates . The lowest and highest in a row can belong to different candidates. In English the median was 58.00 and nobody selected scored above 71.00, while the IT median was 85.88.

Each English mark saves half an IT mark

The weighted score counts one English mark as half of one IT mark. Here is the IT mark needed to reach the 2025 unreserved cut-off of 77.00, at three English marks from the table above. Moving from 47.00 to 71.00 in English lowers the IT mark you need by 12.00.

IT mark needed for a weighted score of 77.00, at different English marks
English markWhere that mark comes fromIT mark needed for 77.00
47.00lowest among those selected92.00
58.00median among those selected86.50
71.00highest among those selected80.00

Arithmetic from the 1/3 and 2/3 weights: IT needed = (3 × 77.00 - English) / 2. Other categories had lower cut-offs.

How to practise it

The 2025 paper had 3 questions in 60 minutes: essay 30 marks, precis 30 and comprehension 40. Our suggestion is to split your time by marks: 18 minutes, 18 minutes and 24 minutes. Phase II is an online examination, so practise on a keyboard as well as on paper.

Essay

Choose a topic where you have three concrete points. State your position in the first two lines. Give each point its own paragraph. End by answering the question that was asked.

Precis

Read the passage twice. Write its main claim in one line. Keep the reasoning and drop examples and repetition. Use your own words, and keep to any word limit the question sets.

Comprehension

Read the questions first, then find the lines that answer them. Answer in your own words. Copied sentences do not show that you understood the passage.

Time your typing too. At 25 words a minute, 18 minutes is 450 words at most, and that is before any planning. Read each piece again the next day, mark every sentence that says nothing, and rewrite the weakest paragraph. A piece you write and never review teaches you very little.

SEBI Phase 2 Descriptive English Strategy

40 min · Watch on YouTube

A full-length interview on one paper: the descriptive English test in Phase II. The video's own description says the guest cracked the RBI exam and scored 70+ in English, and that it covers the structure of an essay, time management in the paper, mistakes to avoid in précis and comprehension answers, vocabulary and grammar, and how to set up a practice routine. Watch it after your first timed attempt, so you can compare your own answer with the structure it describes.

Avoid these

Common Phase II mistakes

  • Revising Phase I topics for Phase II. Database, SQL, networking, security, data warehousing and shell programming are not named in the Phase II IT syllabus.
  • Reading the weights as promises. SEBI marks them indicative only, and its handout warns of higher difficulty.
  • Using an old coding paper as a sample. Before 2025 this paper was a coding test, so those papers do not show the 2025 multiple-choice format.
  • Carrying the Phase I pace. Phase I gave 0.8 minutes a question. Phase II gives 1.8. Use the extra time to trace on paper.
  • Tracing in your head. A long trace needs a table. It is easy to lose a value after a few loop passes.
  • Ignoring the print line. A missing space, the order of values, or 65 against 65.0 can each be a wrong option.
  • Mixing up binding rules. Overloading is chosen at compile time and overriding at run time. In Java, fields and static methods follow the declared type.
  • Off-by-one errors. Check loop bounds, substring end indexes and heap child indexes on every question.
  • Taking the first option that looks right. Test it on the input in the question, then test the option you would pick second.
  • Leaving English to the last week. It carries 28.33% of final merit and has its own 30% minimum.

Our suggestion

A 7-day revision loop

This is our own suggestion, not SEBI's. The first five days follow the indicative weights: three days of data structures, then two of algorithms. Repeat the loop as many times as you have weeks.

Suggested 7-day revision loop for Phase II
DayIT workEnglish
Day 1Arrays, matrices and linked lists. Trace 10 short programs.Essay, 18 minutes
Day 2Stacks, queues, hashing and JSON objects. Trace 10 short programs.Rewrite the weakest paragraph of your essay
Day 3Binary trees, binary search trees, heaps and indexing. Redraw the structure after every operation.Precis, 18 minutes
Day 4Sorting, searching, divide and conquer. One trace table per algorithm.Check your precis against the passage: what did you miss?
Day 5Greedy, dynamic programming, backtracking and pattern searching. Fill one table by hand for each.Comprehension, 24 minutes
Day 6OOP and strings. For each program, say first whether it compiles, then what it prints. Finish with one free SEBI IT mock test for timed accuracy.Read back your comprehension answers: did you copy sentences?
Day 7One timed sitting of code questions at 1.8 minutes each: 100 questions in 180 minutes if you have them, or 50 in 90. Review every miss.One full English paper, 60 minutes
  • Write your answer before you run anything. Then run the code and compare.
  • Put every miss in an error log with its cause: loop bound, update order, integer division, binding, output format.
  • Start each day with three entries from the log. Start each new loop with the topic that has the most entries.
  • We have no test in the Phase II shape, so collect code questions through the week for Day 7 and time them yourself.

Next steps

Where to practise next

Our SEBI Grade A IT preparation hub covers the whole exam. For Phase II, these are the pages to use.

Take a free SEBI IT mock test

SEBI IT mock tests

IT Mock Test 1 and IT Mock Test 2 are free. Phase I Paper 2 shape: 50 questions, 40 minutes (read on 4 November 2026).

SEBI previous year questions

What exists, and where it comes from.

SEBI notes and study material

The subject guide and our PDF library.

SEBI study plan

Fit this 7-day loop into a longer week-by-week plan.

2025 cut-offs and marks

SEBI's published results, by category.

SEBI syllabus and exam pattern

Phase I and Phase II marks, topic by topic.

Questions

SEBI Grade A IT Phase 2: frequently asked questions

What is in SEBI Grade A IT Phase 2?

In the 2025 cycle, Phase II had two online papers of 100 marks each. Paper 1 was descriptive English: 3 questions, 60 minutes, a 30% minimum and a weight of 1/3. Paper 2 was IT: 100 multiple-choice questions, 180 minutes, a 40% minimum and a weight of 2/3. Candidates also needed 50% on the weighted total. SEBI has not published a 2026 pattern.

How much does the IT paper count towards final merit?

56.67%. Paper 2 carries 2/3 of Phase II, and Phase II carries 85% of final merit, so 2/3 × 85% = 56.67%. English carries 28.33% and the interview 15%. SEBI gives the weights and the percentages are our arithmetic. Phase I marks do not count towards final selection.

Are database, networking and security in SEBI Phase 2?

They are not named in the Phase II IT syllabus in the 2025 advertisement. It lists Data Structure (40), Algorithms (30), Object Oriented Programming (20), String Manipulation (10), all marked indicative only. Database, SQL, networking, security, data warehousing and shell programming are Phase I topics.

Which programming language does SEBI Phase 2 use?

SEBI's description of the Phase II IT paper names no language. One of the 2 IT samples in its 2025 handout is about C++, and its Phase I syllabus names Java, C and C++, plus Python and R for data analytics. The languages in our examples are our own choice.

Is there negative marking in SEBI Phase 2?

Yes, for the multiple-choice questions of Paper 2. The 2025 advertisement sets it at 1/4 of the marks assigned to the question. So one right answer cancels four wrong ones, and a guess breaks even at a 1 in 5 chance of being right.

Has the SEBI Phase 2 IT paper always been multiple choice?

No. In 2020 and 2022 it was an online programming test of 5 questions in 3 hours. In 2024 it was a coding test of 9 questions in 210 minutes. In 2025 it was 100 multiple-choice questions in 180 minutes. The next advertisement could change it again, so read that first.

The Victory Key is an independent exam-preparation platform and is not connected to SEBI. Facts on this page were last checked against sebi.gov.in on 4 November 2026.