Jobra
🐞Step 1 of Jobra:AI Debugging Rounds
DSA+AIPreparing you for both.
JOBRA · AI DEBUG ROUND (PREVIEW)sum.cpp
// buggy snippet
int total(vector<int>& a, int n) {
    int sum = 0;
    for (int i = 0; i <= n; i++) { // 🐞        sum += a[i];
    }
    return sum;
}
A real codebase. A real bug. You + AI.

Jobra drops you into a broken repo. Find it, fix it, ship it. AI helps you debug like on the job.

Prompt:Correct the loop condition
Tap 'Let Jobra fix it' below to simulate AI debugging...

BNY Software Engineer Interview Questions & Rounds

32 min read

How the BNY software engineer interview works: HackerRank OA, a technical round and a technical plus HR round, from real candidate experiences in India.

In this article
On this page

How to Crack BNY: The Software Engineer Interview, From Real Experiences

Last updated November 20, 2026 · 27 min read · For summer interns and full-time SDE candidates in technology, mostly campus hiring in India

Built by the Codinzhub team. This guide is built from BNY (BNY Mellon) software engineering interview experiences that candidates shared, including experiences and online assessment questions on Codinzhub. The process changes by campus, track and year, so treat this as a map, not a promise.

The 30-second version. BNY hires software engineers and interns in India mostly through campus drives. You take an online assessment, usually 4 coding questions in 2 hours on HackerRank; two 2026 tests swapped one question for a debugging task, one with an AI assistant. A small shortlist then has usually two interviews: a technical round of 30 to 70 minutes on projects, OOP, DBMS and 1 or 2 short coding questions, and a final technical plus HR round of 30 to 45 minutes. Some full-time drives added a second technical round. In some drives the result came within a day. The habit that matters most: know every project on your resume well enough to explain it, deploy it and write its code.

What this guide is, and what it is not

This guide is built from 16 candidate experiences of BNY's software engineering interviews: 3 shared on Codinzhub and 13 public write-ups. It also uses 14 online assessment questions shared on Codinzhub from five 2026 or undated test sittings, and BNY's official careers pages. Most experiences are Indian campus drives from 2023, plus 2025 and 2026 drives; 7 are internships, 4 are full-time roles and 5 do not state the level.

It is:

  • A map of the process, stage by stage, as candidates described it
  • The question patterns that keep coming back, and the follow-ups to expect
  • A six-week plan and practice problems matched to those patterns

It is not:

  • A list of leaked questions or a promise of what you will be asked
  • An official description of BNY's process
  • An offer rate. Outcomes in candidate posts are self-reported and are not a statistical sample.

Important things to know before you start

These BNY facts change how you should prepare.

The OA changed in 2026. Two 2026 campus tests replaced one coding question with a debugging task. In the IIT Indore test, candidates got a codebase and an AI assistant, and had to debug the code and run it against test cases. Practise reading and fixing unfamiliar code, not only writing your own.

Your code may be run in the interview. Interviewers used HackerRank CodePair or a shared link with test cases in 3 reports, and one intern round was on paper. Write complete, compilable code, not pseudocode; one 2026 interviewer refused pseudocode for project code.

The interviews run on your resume. Projects came up in 13 of 16 reports, often for most of a round, with questions on deployment, design choices and the tools you listed. The final round cut candidates in 4 of the 5 drives that report its numbers, so prepare it as seriously as the technical round.

Round-by-round breakdown

Candidates described five stages: an application (usually through a campus drive), an online assessment that sets the shortlist, two or three interviews, and a result that came within a day in some drives.

Stage 1: Application, where candidates applied

Most records are Indian campus drives: 13 of 16 candidate experiences. Of the rest, one came through an off-campus diversity hiring challenge, one through an employee referral, and one did not say.

ChannelWhat candidates said
On-campus driveThe main route for interns and full-time hires. Eligibility varied by drive: CSE, ECE, EEE and instrumentation branches with a 7 CGPA cut-off (a 2025 intern drive); CS and IT with 7.5 CGPA and no active backlogs (a 2023 intern drive). A civil-engineering student sat a 2023 full-time drive. One 2023 visit hired 13 interns and 3 full-time graduates.
Off-campus diversity challengeOne 2023 full-time candidate entered a coding challenge for women engineers on HackerEarth, then took two online tests before interviews.
Careers site plus referralOne off-campus candidate found the opening on BNY's careers site and asked employees for a referral.

BNY's careers site describes an application, a review, a screening interview, team interviews (with a job-related assessment for some roles) and an offer. Its early-careers page lists a short assessment, an interview and an offer.

What helped. Candidates credited projects they could explain line by line, solid OOP, and practice on medium-to-hard DSA, especially DP and graphs.

Stage 2: Shortlisting, how candidates moved forward

On campus there was no resume screen or recruiter call in the reports: the online assessment (OA), a timed coding test, decided who was interviewed.

  1. Eligibility check. Your branch and CGPA must meet the drive's cut-off (see Stage 1).
  2. The OA cut. Shortlists were small. Reported cuts: 170 to 25 (2025 intern), 400 to 21 (2025 intern), 400 to 24 (2023 intern, two candidates from the same drive), 400+ to 26 (2023 full time), about 3,800 to 34 (a 2023 pool campus drive, where several colleges sit one test), and about 40 at a 2026 drive. In one 2023 drive, 21 were shortlisted and 5 more women were added afterwards.
  3. Off-campus extra test. The 2023 diversity-challenge candidate took a second online test (MCQs, SQL and a hard coding problem) before any interview.

How long the gap was. Interviews came the next day at the pool campus, about a week after the OA in the 2023 intern drive, and off campus each online test's result came within a week, with the first interview about five weeks after the second test.

What candidates advised. Solve as many questions as you can, quickly. In one 2025 intern drive, solving even one question fully was enough for the shortlist; in a 2023 intern drive, the candidate noticed that those who solved three in full and part of the fourth were the ones shortlisted.

Stage 3: Online assessment

All 14 reports that describe how the process began started with an online coding test. Its shape changed in 2026, so check which version your drive uses.

Online assessment

How it works. In 2023 to 2025 reports the OA was usually 4 coding questions in 2 hours on HackerRank, scored on test cases; in 3 reports, partly solved questions still helped candidates reach the shortlist. The difficulty mix was usually 1 easy, 2 medium and 1 hard. The 2026 sittings shared on Codinzhub are shorter: at IIT Indore (July) and IIT (BHU) Varanasi (November) the test had 2 coding questions plus 1 debugging question. In the IIT Indore test, candidates got a codebase and an AI assistant, asked the assistant questions to understand and debug the code, and ran it against test cases. That is the only report of an AI tool being allowed, and it applied to that debugging question in that 2026 test.

At a glance

  • Length: usually 2 hours (6 of 9 reports that give a length); 2.5 hours in 3 (two 2025 intern tests and a 2023 off-campus test)
  • Questions: usually 4 coding questions in 2023 to 2025 (9 of 12 reports that give a count), 3 in the other 3. In 2026: 2 coding + 1 debugging (two campuses), 3 coding (IIT Guwahati, November) or 2 DSA (IIT Guwahati, August)
  • Platform: HackerRank in 5 of 8 reports that name one; HackerEarth in 3 (a 2023 pool campus drive, the off-campus diversity challenge and the referral)
  • What was asked: graphs, trees, DP, greedy and arrays; 2026 pages add BFS order, intervals, scheduling and an LFU cache
  • Most common: two questions each appeared at two campuses: "Shared interest" (a graph problem) and "LFU cache"
QuestionWhat it testsLevel
Join one node of tree A to tree B to minimise the final diameterTree diameter with DFSIntern
Recursion problem like counting subarrays with sum K, with a twistRecursion, prefix sumsIntern
Count arrays matching a partial description, with tighter constraintsCounting DPIntern
Sub-grid sum problem that needs an O(n^2) solution2D prefix sumsIntern
Long story problem that reduces to 0-1 knapsack0-1 knapsack DPNew grad
Sum of all expressions made by inserting plus signs into a digit stringEnumeration or digit contributionNew grad
Minimum dollars to make all wallet denominations equalNot reportedNew grad
Debug a given codebase with an AI assistant, then run the test casesReading and debugging unfamiliar codeSDE

OA questions shared on Codinzhub.

QuestionDriveTopic
Shared interest (graph problem)IIT Guwahati and IIT (BHU) Varanasi, November 2026Graphs
LFU cacheIGDTUW and IIT GuwahatiCache design
Task scheduling on N serversIIT Guwahati, November 2026Not reported
Valid BFS order with multiple queriesIIT (BHU) Varanasi, November 2026BFS
Earliest common free intervalIIT (BHU) Varanasi, November 2026Intervals
Tree diameterIIT (BHU) Varanasi, November 2026Trees
Assign missing values to tree nodes to minimise their sumIIT (BHU) Varanasi, November 2026Trees
Minimum cost to make adjacent tree nodes validIIT (BHU) Varanasi, November 2026Trees
Get minimum sum of node valuesIIT (BHU) Varanasi, November 2026Not reported
Permutation collapseIIT (BHU) Varanasi, November 2026Not reported
Optimal request load balancingIIT (BHU) Varanasi, November 2026Not reported
Minimise operations to maximise segmentsIIT (BHU) Varanasi, November 2026Not reported
Min costIIT Guwahati, August 2026Not reported
Memory MEXIGDTUWArrays

The IIT (BHU) pages come from several question sets on one date. See all BNY OA questions in the question bank.

Stage 4: The interview loop

Most drives had two interviews (11 of 15 reports): a technical interview, then a final round that mixed technical and HR questions. Four reports had a second technical round in between: three 2023 full-time or off-campus processes and the referral. Interviews were in person in the 2023 intern drive, and some second rounds ran online. Each interview round in the reported funnels cut candidates.

Technical interview 1

At a glance

  • Length: 30 to 70 minutes (all 10 reports that give a length)
  • Questions: a project deep dive, OOP theory, DBMS, SQL or OS questions, then 1 or 2 short coding questions
  • What was asked: projects came up in 11 of 16 reports and OOP in 9 of 16
  • Most common: walk through your projects; explain the OOP pillars with code

What you get depends on the interviewer. In one 2025 intern drive, four interviewers ran rounds in four rooms: some asked only DSA, some only the resume. One candidate had no DSA and spent 40 to 45 minutes on projects, down to writing a snippet of code. Coding happened on HackerRank CodePair or a shared HackerRank or HackerEarth link with test cases in 3 reports, and on paper in one 2023 intern round. The 2026 campus rounds at IIT Indore went into backend depth: JWT and sessions, scaling across servers, B+ tree indexes, red-black trees, a trie autocomplete and LRU or LFU caches.

QuestionFollow-upLevel
Walk through your projects: stack, your part, how it works and deploysWrite a code snippet from it; why this stack, and what alternatives?Intern, New grad, SDE
Explain the OOP pillars by implementing polymorphism, inheritance, abstraction and virtual functionsOperator overloading; early vs late binding; disadvantages of OOPIntern, New grad, SDE
Write and compare sorting algorithms: insertion, quick and merge sortSort a given set by hand with quicksortNew grad, Intern
SQL vs NoSQL, and why MongoDB instead of SQL in your projectWhat is sharding?New grad
Choose a data structure for a scenario; traversal uses; DijkstraReal-life examples of tree and graph traversalsIntern
Smallest subarray with K distinct numbers, then greedy job scheduling with a heapJob scheduling with a priority queueNew grad
Sessions across horizontally scaled servers, then a server crash, then a load-balancer crashHow would servers share sessions?SDE
Autocomplete with a trie: suggest complete words for a typed prefixRewrite and explain the code in the next roundSDE

Technical interview 2 (three-round drives)

At a glance

  • Length: 45 minutes (3 of 3 reports that give a length); one ran to 90 minutes
  • Questions: more resume technology, one coding question, deeper OOP and DBMS
  • What was asked: 4 of 16 reports had this round: three 2023 full-time or off-campus processes and the referral
  • Most common: no single repeated question

This round went deeper into whatever your resume claims. One interviewer spent 15 to 20 minutes on Docker and cloud because they were listed. Another stretched a 45-minute slot to 90 minutes, and when C++ code hit a runtime error, suggested finishing in Python.

QuestionWhat it testsLevel
Largest sub-grid of a square grid meeting a conditionBinary search on answer, 2D prefix sumsNew grad
How is a hashmap implemented? Hashing techniquesHashingNew grad
Static vs dynamic polymorphism, then the diamond problem in C++ and PythonOOP, multiple inheritanceNew grad
Partition a website URL string into its partsString parsingNew grad
What is sharding, and how does a DBMS store data?DatabasesNew grad
Docker, containerisation and cloud, from your resumeDevOps basicsNew grad

Final round: technical plus HR or managerial

At a glance

  • Length: 30 to 45 minutes (all 8 reports that give a length)
  • Questions: HR questions, with technical questions mixed in for 8 of 15 reports
  • Themes: why BNY, career goals, teamwork, projects in depth; sometimes code, deployment or design
  • Who: a director, BNY's India head or a manager in some reports

Treat this as a real interview. In a 2023 full-time drive, BNY's India head turned the final round into web development, MongoDB queries and how to build a large-scale application, and the candidate was rejected. In a 2026 drive the interviewer refused pseudocode and asked for the actual project code. One off-campus managerial round had no technical questions at all, and the interviewer talked about his work in trading and mutual funds. A 2023 intern director round ended by asking whether the candidate would join in Pune or Chennai.

Reported questions.

  • Where do you see yourself in 5 years? Career goals and future plans (5 reports)
  • Why do you want to join BNY? (4 reports)
  • Tell me about yourself and walk me through your resume (3 reports)
  • What do you know about BNY? (2 reports, once in round 1)
  • A teamwork or leadership example: how did you divide work?
  • Project challenges: bugs, failures and what you learned
  • Why software from a non-circuit branch, and how will you balance core subjects?
  • Write your project's actual code, not pseudocode
  • How and where did you deploy your project?
  • Explain your internship data models, then write MongoDB queries for a new feature
  • Why should we hire you? What sets you apart?

See all behavioral questions in the question bank.

Stage 5: Result and offer

Result. Each round in the reported funnels cut candidates. Reported funnels: 400 to 21 to 11 to 6 interns (2025); 400 to 24 to 14 to 13 interns (2023); 400+ to 26 to 19 to 14 to 3 full-time hires (2023); 25 interviewed to 4 selected and 2 waitlisted (2025 intern). Results came the same evening at a 2023 pool campus drive, the next day at a 2023 intern drive, and a week after the final round at another 2023 drive. The off-campus candidate had an offer 6 days after the final round.

Offer. One 2023 intern drive offered a 2-month summer internship, and the last round asked about the office (Pune or Chennai). Hiring committees, team matching and pay were not reported.

BNY experiences shared on Codinzhub

This is the BNY Mellon interview experience on Codinzhub that we could match to its full text. More BNY experiences and OA questions are listed on Codinzhub's company pages.

CollegeRole and resultWhat was asked
MNNIT AllahabadSDE intern, not selected after round 2R1: 2 easy-medium DSA questions with intuition and complexity; design a library management system; OOP, networks and DBMS basics. R2: OOP, OS and networks basics; a 2-minute project pitch; deployment questions.

The Codinzhub Next-Round Playbook

Candidates who moved forward solved fast in the OA, then showed they understood their own work and the basics behind it.

To get past the OA

  • Read all four questions first and bank the easy and medium ones. In one 2025 intern drive, solving even one question fully reached the shortlist, while one candidate spent 20 to 25 minutes on a hard first question and never solved it.
  • Submit partial solutions. Candidates who passed only some test cases on the last question were still shortlisted in 3 reports.
  • If your 2026 test has a debugging question, read the code before you ask the AI assistant anything, and run every given test case before you submit.

To get past technical interview 1

  • Open with a tight two-minute introduction, then expect a project deep dive: it came up in 11 of 16 reports.
  • Answer OOP questions with code. Interns were asked to implement polymorphism, inheritance and virtual functions, not just define them.
  • For coding, give the brute force and its complexity, then optimise, then dry-run one example. One selected intern did exactly this on a hashing question.
  • Write clean, complete code: interviewers ran test cases on CodePair or a shared link in 3 reports.

To get past technical interview 2

  • Know everything listed on your resume. One interviewer spent 15 to 20 minutes on Docker and cloud because they appeared there.
  • If you are stuck on a language error, say so and offer a fix or a switch. One interviewer suggested moving from C++ to Python, and the candidate finished.

To get past the final round

  • Do not treat it as a formality. It cut candidates in 4 of the 5 drives that report its numbers, and one turned into MongoDB queries and system design.
  • Prepare "why BNY" and "what do you know about BNY" with specifics about what the bank does.
  • Be ready to write real code from your project. A 2026 interviewer did not accept pseudocode.
  • Have two or three questions ready for the interviewer.

How the loop differs by level

The shape is the same at every level in the data, an OA and then two or three interviews, but full-time drives more often added a second technical round, and interns had no design questions.

LevelWhat candidates describe
Intern (summer or software intern)Based on 7 reports (2023 and 2025). OA of 4 questions in 2 to 2.5 hours, one technical interview of 40 to 70 minutes, then a technical plus HR (or HR-only) round. Examples: join two trees to minimise the diameter (OA); delete a linked-list node given only that node; duplicates and the missing number on paper. No system design.
New grad (SDE or software engineer, full time)Based on 4 reports, all 2023. Three had two technical rounds before the final round. Examples: smallest subarray with K distinct numbers; a Comparator class showing runtime polymorphism; the diamond problem. Design came up twice: how WhatsApp works, and how to build a large-scale application.
Level not stated (campus and referral)Based on 5 reports. Two 2026 IIT Indore candidates had a technical round, then an HR plus technical round; one described an OA with a debugging question and a technical round on JWT, sessions, B+ trees, tries and LRU or LFU caches. An MNNIT candidate designed a library management system. The referral candidate had an OA, coding, technical and managerial rounds.

There are no 2023 to 2026 reports from experienced (lateral) engineers, so this guide does not cover that loop.

Most-asked topics

Across 16 candidate reports, interviews leaned on projects and OOP; hard DSA showed up mainly in the OA.

TopicWhat it meansSeen inReported examples
Projects and resumeExplaining, defending and coding parts of what you built13 of 16 reportsWalk through your projects; write your project's actual code; how and where did you deploy it?
Arrays, strings, hashing, linked lists and sortingCore data-structure questions, often short12 of 16 reportsFind duplicates in an array; delete a linked-list node given only that node; compare quick and merge sort
OOP and class designThe four pillars, polymorphism, and small classes in code11 of 16 reportsOOP pillars with code; a Comparator class showing runtime polymorphism; the diamond problem
Trees, graphs and DPTraversals, shortest paths, tree diameters, knapsack-style DP7 of 16 reportsJoin two trees to minimise the diameter; Dijkstra; 0-1 knapsack in disguise
DBMS and SQLIndexes, normalisation, SQL vs NoSQL, writing queries7 of 16 reportsSort a SELECT result without ORDER BY; why MongoDB over SQL; write SQL queries for scenarios
Backend and system design basicsSessions, scaling, caches and simple designs4 of 16 reportsSessions across scaled servers; design a library management system; build a large-scale application
Operating systemsDeadlocks, memory allocation, stack and heap3 of 16 reportsDeadlock prevention; malloc vs calloc; stack vs heap

The 14 distinct OA questions shared on Codinzhub, most from 2026, lean towards trees (3 questions) and graphs (2 questions); they are not counted in the report totals above.

The question patterns that keep coming back

Most BNY questions fall into a few patterns. The interviews test whether you understand what you built and the basics behind it; the OA tests harder DSA.

1. Projects and resume deep dives

The most common pattern: 13 of 16 reports. The interviewer picks a project and keeps asking how and why: the stack, your part, deployment, what you would add next. Some asked for real code from it. Rule: for every project, prepare why you chose each technology, one alternative, how it is deployed, and one piece of code you can write from memory.

Reported examples. Walk through your projects; write your project's actual code, not pseudocode; how and where did you deploy it?; Docker, containerisation and cloud, from your resume.

2. Arrays, strings, hashing, linked lists and sorting

12 of 16 reports had short questions on core data structures, sometimes on paper. Rule: for duplicates, a missing value or "seen before", use a hash set or index marking; for the smallest window with a property, use a sliding window; for in-place linked-list changes, draw the pointers first.

Reported examples. Find duplicates in an array; smallest subarray with K distinct numbers; delete a linked-list node given only that node; 3Sum, from brute force to optimal.

3. OOP theory and class design

11 of 16 reports. Interviewers asked for OOP with code, not just definitions. Rule: answer each "what is X" with a 5-line code example and a real-world use, and know how your language handles multiple inheritance.

Reported examples. Implement the OOP pillars; a Comparator class showing runtime polymorphism in C++; Singleton and Abstract Factory; the diamond problem in C++ and Python.

4. Trees, graphs and dynamic programming

7 of 16 reports, mostly in the OA, plus most of the 2026 OA questions on Codinzhub. Rule: for the longest path in a tree, use two DFS or BFS passes; for weighted shortest paths, Dijkstra; for choosing items under a budget, 0-1 knapsack; for counting arrays under adjacent-value rules, DP over position and last value.

Reported examples. Join two trees to minimise the final diameter; a story problem that reduces to 0-1 knapsack; largest sub-grid meeting a condition; Dijkstra.

5. DBMS theory and SQL queries

7 of 16 reports: theory (indexes, normalisation, keys, SQL vs NoSQL) plus one or two live queries. Rule: for "top N" without ORDER BY, think of a correlated subquery that counts rows, and say what an index would change.

Reported examples. Sort a SELECT result without ORDER BY; write SQL queries for scenarios; how B+ trees implement an index; why MongoDB instead of SQL.

6. Backend and system design basics

4 of 16 reports, none from interns. Small, practical designs tied to the resume. Rule: start with users and data, then say where state lives; for sessions across many servers, share them in a store or make them stateless with tokens.

Reported examples. JWT, then session-based auth; sessions across scaled servers, then server and load-balancer crashes; design a library management system; build a large-scale application.

Preparing for the final technical plus HR round

The final round decides the offer, and it cut candidates in 4 of the 5 drives that report final-round numbers (see Stage 5). It mixes HR questions with project and technical follow-ups. BNY's careers site asks candidates to know its principles: Be Client-Obsessed, Own It, Thrive Together, Spark Progress and Stay Curious.

Build your story bank. Prepare five or six real stories, each under two minutes. Cover the themes candidates were asked about:

ThemeReported prompt (paraphrased)Follow-up to expect
MotivationWhy do you want to join BNY?What do you know about BNY?
Career goalsWhere do you see yourself in 5 years?What progress have you made in the past 6 months?
Teamwork and leadershipA teamwork or leadership exampleHow did you divide the work?
Failure and challengesProject challenges, bugs and failuresWhat did you learn?
Branch switchWhy software from a non-circuit branch?How will you balance core subjects?
Self-presentationWhy should we hire you?What sets you apart?
Resume extrasPositions of responsibility and achievementsNot reported

Structure each story. Give the situation in one line, then what you did (say "I", not "we"), the result, and what you would do differently. Use real experiences only.

Expect depth. Several final rounds went back to your projects, and one asked for the full project code. Research BNY before the day: one 2023 candidate advised knowing its leaders, values and recent awards. Prepare two or three questions of your own, because interviewers in 2 reports asked whether you had any.

A six-week plan

This plan follows the patterns above, most common first, and ends with timed mocks that feel like the real OA and interviews. Plan on two to three focused hours a day. Spend 20 minutes a day on your projects from week 1, because they came up in 13 of 16 reports.

  1. Week 1: Arrays, strings, hashing, linked lists and sorting. Duplicates and missing numbers, sliding windows, 3Sum, linked-list edits, quick sort and merge sort by hand. Habit: write the time and space complexity next to every solution.
  2. Week 2: OOP and class design. The four pillars in your language, virtual functions, overloading vs overriding, the diamond problem, Singleton and Factory, and cache classes (LRU and LFU). Habit: answer every OOP question with a short code example.
  3. Week 3: Trees and graphs. Traversals, tree diameter, BFS order, Dijkstra, tries for autocomplete. Habit: draw the tree or graph before writing code.
  4. Week 4: Dynamic programming and timed OA sets. Knapsack, grid DP, counting DP, 2D prefix sums. Twice this week, do 4 problems in 2 hours. Habit: move on after 20 minutes stuck, and come back later.
  5. Week 5: DBMS, SQL, OS and backend basics. Indexes and B+ trees, normalisation, SQL vs NoSQL, writing queries without ORDER BY, deadlocks, stack vs heap, sessions and scaling, deployment of your own project. Basics only if you are applying as an intern.
  6. Week 6: Mocks. Two timed OAs (4 questions, 2 hours) and three 45-minute mock interviews that start with a project deep dive, then OOP, then one coding question with a follow-up. Rehearse your final-round stories and "why BNY" out loud.

Interns can go lighter on week 5's backend topics; full-time candidates should expect a second technical round and possibly a design question.

Only two weeks? Four days on arrays, hashing, linked lists and sorting; three on OOP with code; three on trees, graphs and DP; two on DBMS and SQL; two on a timed OA and a mock interview with your project stories.

Practice problems that match these experiences

These are well-known practice problems that match the patterns above. They are not claims about BNY's question bank unless a row says the problem was asked as-is. The projects pattern has no practice problem: prepare it from your own resume.

#Practice problemPatternSeen in these experiences as
1Find Minimum Diameter After Merging Two TreesTree diameter with DFSAsked as-is in one 2025 intern OA
23SumSorting, two pointersAsked as-is in one technical round
3Delete Node in a Linked ListLinked listsAsked as-is in one intern round
4Duplicates in Limited Range ArrayHashing or index markingAsked as-is, on paper, in one intern round
5Minimum Window SubstringSliding windowSmallest subarray with K distinct numbers
6Network Delay TimeDijkstraDijkstra in an intern technical round
70 - 1 Knapsack ProblemKnapsack DPA long OA story that reduced to 0-1 knapsack
8Range Sum Query 2D - Immutable2D prefix sumsSub-grid sum OA problem
9Search Suggestions SystemTriesAutocomplete with a trie
10LFU CacheClass design, hashingLFU cache OA question at two campuses
11LRU CacheHash map plus linked listHow would you implement LRU or LFU behaviour?
12Second Highest SalarySQLWrite SQL queries; sort without ORDER BY

How to handle a question you have never seen

BNY interviews mix short DSA problems with follow-ups on your own code, so a repeatable method matters more than memorised solutions.

  1. Repeat the problem and one example. On paper or a shared link, write the example down so you and the interviewer agree on it.
  2. Say the brute force and its complexity. Selected candidates advised starting with brute force and then optimising; one candidate walked 3Sum from brute force to better to optimal.
  3. Name the bottleneck. Repeated lookups suggest a hash map; repeated range sums suggest prefix sums; repeatedly taking the best item suggests a heap; a prefix search suggests a trie.
  4. Say when you are stuck. Interviewers gave hints in some reports: one director's hint unlocked the feature he was looking for, and another interviewer suggested switching language when C++ failed.
  5. Code in small pieces while talking. On CodePair or a HackerRank link, your code may be run against test cases, so compile-ready code matters more than pseudocode.
  6. Dry-run one case and fix the wrong line. Trace your example by hand before saying you are done, and state the final time and space complexity.

Why candidates were rejected

Six reports ended in rejection, and only two give a reason, both the candidates' own view. Read these as signals, not rules.

  • Shallow project or deployment knowledge. One MNNIT candidate felt the final round was lost on deployment questions with specific expected answers. Another, rejected after round 1 in a 2025 intern drive, had spent the whole round on every detail of one project.
  • A final round outside your comfort zone. A 2023 full-time candidate with three internships was rejected after a final round on web development, MongoDB queries and large-scale design. The candidate felt it came down to interviewer fit and luck. A peer with less experience was selected.
  • No reason given after a full loop. Two 2026 IIT Indore candidates were rejected after a technical round and an HR plus technical round. One had covered JWT, scaling, B+ trees, tries and LRU or LFU caches.
  • No reason given after DSA and HR. One candidate explained 3Sum at three levels and wrote pseudocode for a tree problem, then was not selected after HR.

Funnels were tight after the OA (for example 26 to 19 to 14 to 3), so a solid performance in one round did not secure the next.

Selected vs. rejected: do this, not that

No selected candidate described a perfect interview. What repeated were a few habits, and the rejected reports show where skipping them hurt.

Do thisNot thatWhat the reports show
Own every project: know the stack, the reasons, the deployment, and code you can writeListing tools you can't defend: Docker, MongoDB or deployment you only touchedProjects came up in 13 of 16 reports; one candidate felt deployment answers cost the offer
Show OOP with code: a short example per pillarDefinitions onlyOOP came up in 11 of 16 reports, often as "implement it"
Start brute force, then optimise, out loudJumping to code silentlyThree selected candidates advised explaining the approach before coding
Solve fast in the OA: bank easy questions firstSinking 25 minutes into one hard questionShortlists were 21 to 34 from pools of 170 to 3,800
Research BNY and prepare for "why BNY"A generic answer"Why BNY" came up in 4 reports and "what do you know about BNY" in 2

If you remember only five things

  1. The process is short. An online assessment, then usually two interviews: a technical round and a final technical plus HR round. Some full-time drives added a second technical round.
  2. The OA is where the DSA is hard. Usually 4 questions in 2 hours on HackerRank in 2023 to 2025; 2026 tests added a debugging question with an AI assistant.
  3. Your projects are the interview. Expect to explain, defend and code parts of what you built, including deployment.
  4. OOP is asked with code. Know the pillars, polymorphism and virtual functions well enough to write them.
  5. The final round is scored. Prepare "why BNY", career goals and teamwork stories, and expect technical follow-ups.

FAQ

Is there an online assessment?

Yes, in all 14 reports that describe how the process began. The off-campus diversity drive had two online tests.

Do I need dynamic programming?

For the OA, yes: DP showed up in OA questions such as a disguised 0-1 knapsack and an array-counting problem. In the interviews, DP was rare in the data, and short array, linked-list and OOP questions were more common.

Is system design asked?

Not for interns in the data. Two of 4 full-time reports had a design question (how WhatsApp works; building a large-scale application), and campus rounds with no level stated asked about sessions across servers (2026) and a library management system.

How long does it take?

On campus it is fast: one 2023 intern drive took 14 days from the drive notice to the selection mail, and a pool campus drive interviewed the day after the OA and announced results that evening. The off-campus diversity drive took about 3 months from the first test to the final round.

Will the interviewer help me?

Sometimes. In some reports interviewers gave hints, and one suggested switching from C++ to Python when the code would not run.

Which language should I use?

Candidates in the data used C++, Java and Python. One off-campus second test allowed only Java 8+ or Python, so check the test instructions.

About this guide

The Codinzhub team researched and wrote this BNY Software Engineer interview guide from 16 candidate experiences, mostly from 2023 to 2026, including experiences and OA questions shared on Codinzhub. We kept only what candidates described. The questions are our own short summaries, and the practice links are similar problems, not the exact interview questions unless marked. If you interviewed recently, share your experience on Codinzhub and we will update this guide.

Disclaimer. BNY's process changes by campus, track and year. Use this guide to build a foundation, and confirm the current format with your placement cell or recruiter.

Search the question bank

The questions from each round above, with practice links for similar problems. Log in to search every question we collected for this role, including questions shared on Codinzhub.

Showing 20 of 110 questions

  • Shared interest (graph problem)

    A Bny online assessment question shared on Codinzhub (IIT Guwahati and IIT (BHU) Varanasi, November 2026).

    On CodinzhubIIT Guwahati and IIT (BHU) Varanasi, November 2026GraphsCodingOnline assessment
  • LFU cache

    A Bny online assessment question shared on Codinzhub (IGDTUW and IIT Guwahati).

    On CodinzhubIGDTUW and IIT GuwahatiCache designCodingOnline assessment
  • Task scheduling on N servers

    A Bny online assessment question shared on Codinzhub (IIT Guwahati, November 2026).

    On CodinzhubIIT Guwahati, November 2026Not reportedCodingOnline assessment
  • Valid BFS order with multiple queries

    A Bny online assessment question shared on Codinzhub (IIT (BHU) Varanasi, November 2026).

    On CodinzhubIIT (BHU) Varanasi, November 2026BFSCodingOnline assessment
  • Earliest common free interval

    A Bny online assessment question shared on Codinzhub (IIT (BHU) Varanasi, November 2026).

    On CodinzhubIIT (BHU) Varanasi, November 2026IntervalsCodingOnline assessment
  • Tree diameter

    A Bny online assessment question shared on Codinzhub (IIT (BHU) Varanasi, November 2026).

    On CodinzhubIIT (BHU) Varanasi, November 2026TreesCodingOnline assessment
  • Assign missing values to tree nodes to minimise their sum

    A Bny online assessment question shared on Codinzhub (IIT (BHU) Varanasi, November 2026).

    On CodinzhubIIT (BHU) Varanasi, November 2026TreesCodingOnline assessment
  • Minimum cost to make adjacent tree nodes valid

    A Bny online assessment question shared on Codinzhub (IIT (BHU) Varanasi, November 2026).

    On CodinzhubIIT (BHU) Varanasi, November 2026TreesCodingOnline assessment
  • Get minimum sum of node values

    A Bny online assessment question shared on Codinzhub (IIT (BHU) Varanasi, November 2026).

    On CodinzhubIIT (BHU) Varanasi, November 2026Not reportedCodingOnline assessment
  • Permutation collapse

    A Bny online assessment question shared on Codinzhub (IIT (BHU) Varanasi, November 2026).

    On CodinzhubIIT (BHU) Varanasi, November 2026Not reportedCodingOnline assessment
  • Optimal request load balancing

    A Bny online assessment question shared on Codinzhub (IIT (BHU) Varanasi, November 2026).

    On CodinzhubIIT (BHU) Varanasi, November 2026Not reportedCodingOnline assessment
  • Minimise operations to maximise segments

    A Bny online assessment question shared on Codinzhub (IIT (BHU) Varanasi, November 2026).

    On CodinzhubIIT (BHU) Varanasi, November 2026Not reportedCodingOnline assessment
  • Min cost

    A Bny online assessment question shared on Codinzhub (IIT Guwahati, August 2026).

    On CodinzhubIIT Guwahati, August 2026Not reportedCodingOnline assessment
  • Memory MEX

    A Bny online assessment question shared on Codinzhub (IGDTUW).

    On CodinzhubIGDTUWArraysCodingOnline assessment
  • 13

    A Bny online assessment question shared on Codinzhub.

    On CodinzhubValid BFS order with multiple queries: On-campus OA (2 coding + 1 debugging), 11 November 2026; the statement is about the BFS algorithmCodingOnline assessment
  • 14

    A Bny online assessment question shared on Codinzhub.

    On CodinzhubMinimise operations to maximise segments: On-campus OA (2 coding + 1 debugging), 11 November 2026CodingOnline assessment
  • 15

    A Bny online assessment question shared on Codinzhub.

    On CodinzhubPermutation collapse: On-campus OA (2 coding + 1 debugging), 11 November 2026; you are given a permutationCodingOnline assessment
  • 16

    A Bny online assessment question shared on Codinzhub.

    On CodinzhubOptimal request load balancing: On-campus OA (2 coding + 1 debugging), 11 November 2026CodingOnline assessment
  • 17

    A Bny online assessment question shared on Codinzhub.

    On CodinzhubTree diameter: On-campus OA (2 coding + 1 debugging), November 2026CodingOnline assessment
  • 18

    A Bny online assessment question shared on Codinzhub.

    On CodinzhubGet minimum sum of node values: On-campus OA (2 coding + 1 debugging), 11 November 2026CodingOnline assessment
Page 1 of 6

Keep preparing on Codinzhub

Ready for the next topic?

Keep track of what you’ve learned.