Interview experience
Citi Interview Questions and Answers (2026)
Overview
Section titled “Overview”Citi’s Technology Analyst campus process runs a HackerEarth-based online test (coding plus CS-fundamentals MCQs) into one or two discussion-heavy technical interviews and a closing HR round.
Citi interview process at a glance
Section titled “Citi interview process at a glance”| Round | Duration | What they test |
|---|---|---|
| Online Test (HackerEarth) | ~90 min | 3 coding questions + aptitude + CS fundamentals MCQs |
| Technical Interview 1 | 30-45 min | Projects, DSA, C++/Java, DBMS fundamentals |
| Technical Interview 2 | 30-45 min | Deeper technical / hiring-manager discussion |
| HR Round | 20-30 min | Motivation, culture fit |
Online Test
Section titled “Online Test”Run on HackerEarth, roughly 90 minutes: 3 coding questions (typically Easy, Medium, Medium) plus MCQ sections covering CS fundamentals (stacks, queues, trees, sorting, OOPs), SQL/PL-SQL, data interpretation, and logical reasoning. This is Citi’s steepest filter - shortlisting rates reported by candidates are low.
Common questions
- 3 coding problems across arrays, strings, and basic data structures
- MCQs on stacks, queues, trees, and sorting algorithms
- SQL and PL-SQL query MCQs
- Data-interpretation and logical-reasoning questions
Technical Interview 1
Section titled “Technical Interview 1”Often run with two panel members at once. Opens with “tell me about yourself,” then shifts into a genuinely detailed walkthrough of your best and most difficult projects, followed by C++/Java and DBMS fundamentals.
Common questions
- Tell me about yourself, and walk through your most difficult project
- C++/Java fundamentals - OOP concepts, memory management basics
- DBMS concepts - normalization, joins, transactions
- A coding question tied to a data structure discussed in your project
Technical Interview 2
Section titled “Technical Interview 2”When present, this round goes deeper technically or shifts to a hiring-manager-style conversation, revisiting project depth and fit for the specific team.
Common questions
- Follow-up questions on trade-offs from your Round 1 project discussion
- A harder DSA or design question than Round 1
- Why this specific team/technology track at Citi?
- Comfort with ambiguity or changing requirements
Full round-by-round narratives are on the Citi interview experience page.
HR Round
Section titled “HR Round”A short closing conversation on motivation and culture fit.
Common questions
- Tell me about yourself?
- Why Citi?
- Tell me about your most difficult project and how you handled it?
- How would you work with a team spread across different countries and time zones?
Sample answer frameworks for each of these are on the Citi HR interview questions page.
Citi Solutions Centers in India
Section titled “Citi Solutions Centers in India”Citi’s India technology hiring runs through Citi Solutions Centers (CSC) spread across five cities - Bengaluru, Chennai, Gurugram, Mumbai, and Pune - supporting Global Consumer Banking, Markets & Securities, Risk & Capital Management, Cash Management, Trade & Treasury Services, and other lines of business. Citi also runs a recurring Campus Innovation Challenge hackathon on HackerEarth open to technology and analytics campuses, with top performers sometimes fast-tracked to pre-placement interviews outside the standard drive.
Common technical interview questions and answers
Section titled “Common technical interview questions and answers”Q: Compare quicksort, mergesort and heapsort
Quicksort partitions around a pivot and recurses, averaging O(n log n) with O(log n) stack space and excellent cache locality, but it degrades to O(n^2) when the pivot is consistently poor - randomised or median-of-three pivot selection avoids that. Mergesort splits, sorts and merges, guaranteeing O(n log n) in every case and being stable, at the cost of O(n) auxiliary space, which is why it is the standard choice for sorting linked lists and for external sorts over data that does not fit in memory. Heapsort builds a max-heap and repeatedly extracts the root, giving guaranteed O(n log n) with O(1) space, but it is not stable and its scattered memory access makes it slower in practice than quicksort. Java’s Arrays.sort uses dual-pivot quicksort for primitives and Timsort - a mergesort variant - for objects precisely because objects need stability.
Q: How do you evaluate a postfix expression using a stack?
Scan the expression left to right: push every operand onto the stack, and on hitting an operator pop the top two values, apply the operator with the second-popped value as the left operand, and push the result. At the end the stack holds exactly one value, the answer. It is O(n) time and O(n) space, and it needs no parentheses or precedence rules, which is why compilers convert infix to postfix first using the shunting-yard algorithm. The order trap is the one interviewers check - for subtraction and division, popping in the wrong order silently gives the wrong answer.
Q: Explain the four pillars of OOP with C++ or Java examples
Encapsulation keeps data private and exposes controlled accessors, so a Trade class validates quantity inside setQuantity instead of trusting callers. Abstraction hides implementation behind an interface or abstract class - an abstract PricingModel declaring price() lets BlackScholes and MonteCarlo implementations vary independently of callers. Inheritance derives a specialised class from a general one, so EquityTrade extends Trade rather than duplicating fields. Polymorphism resolves a call by actual type at runtime through virtual functions in C++ or overridden methods in Java, letting one loop price a heterogeneous portfolio. The follow-up Citi panels like is overloading versus overriding: overloading is compile-time, same name with different parameter lists; overriding is runtime, same signature in a subclass.
Q: How does memory management differ between C++ and Java?
In C++ you allocate with new and must free with delete (or delete[] for arrays), and any leak or double-free is yours to debug; the idiomatic fix is RAII, where an object frees its resource in its destructor, with unique_ptr and shared_ptr in the standard library. Java allocates on the heap with new and never frees explicitly - a generational garbage collector reclaims unreachable objects, splitting the heap into young and old generations because most objects die young. That means Java trades deterministic destruction for safety: you cannot leak in the C++ sense, but you can still hold unintended references, for example in a static collection that grows forever, which is the Java flavour of a memory leak. C++ gives determinism and control; Java gives safety with GC pause overhead.
Q: Explain normalization and the difference between joins
Normalization removes redundancy: 1NF requires atomic values, 2NF removes partial dependency on part of a composite key, and 3NF removes transitive dependency of one non-key column on another. Joins then recombine what normalization split apart. INNER JOIN returns only matching rows; LEFT JOIN returns all left-side rows padding with NULLs; RIGHT JOIN mirrors that; FULL OUTER JOIN returns both sides; and CROSS JOIN gives the Cartesian product. The subtle point is that a WHERE filter on the right table after a LEFT JOIN silently converts it into an inner join, because NULL fails the predicate - the fix is moving that condition into the ON clause.
Q: What are ACID properties and what do isolation levels control?
Atomicity means all-or-nothing, Consistency means constraints hold across the transaction boundary, Isolation means concurrent transactions do not see each other’s uncommitted work, and Durability means a commit survives a crash because the log was flushed first. Isolation levels trade correctness against concurrency, each permitting specific anomalies: READ UNCOMMITTED allows dirty reads, READ COMMITTED prevents those but allows non-repeatable reads, REPEATABLE READ prevents those but allows phantom rows, and SERIALIZABLE prevents all three at the highest locking cost. Banking systems generally default to READ COMMITTED and escalate to SERIALIZABLE or explicit SELECT FOR UPDATE only on balance-critical paths, since a phantom row in a settlement report is far cheaper than a lost update on an account balance.
Q: Write a SQL query to find the second-highest salary, and explain PL/SQL versus SQL
One clean form is SELECT MAX(salary) FROM employees WHERE salary < (SELECT MAX(salary) FROM employees); which correctly returns NULL rather than erroring when every salary is identical. The window-function form is SELECT DISTINCT salary FROM (SELECT salary, DENSE_RANK() OVER (ORDER BY salary DESC) AS r FROM employees) t WHERE r = 2; - use DENSE_RANK rather than ROW_NUMBER so tied top salaries still share rank 1. On the language difference: SQL is declarative and set-based, one statement at a time, while PL/SQL is Oracle’s procedural extension adding variables, loops, conditionals, cursors, exception blocks and stored procedures. PL/SQL matters at Citi because batch and reconciliation logic often lives in stored procedures, and running work inside the database avoids round-trip network cost on millions of rows.
Q: Explain a binary search tree and how you would validate one
A BST keeps every key in a node’s left subtree smaller than the node and every key in its right subtree larger, giving O(log n) search, insert and delete when balanced and O(n) when it degenerates into a chain. The common wrong validation is checking only that each node is greater than its left child and less than its right child - that passes trees that are locally correct but globally invalid. The correct check passes a permitted range down the recursion: validate each node against a low and high bound, tightening the high bound when you descend left and the low bound when you descend right. Equivalently, an inorder traversal of a valid BST is strictly increasing, so tracking the previous visited value during inorder is an O(n) time, O(h) space alternative.
Frequently asked questions about Citi interviews
Section titled “Frequently asked questions about Citi interviews”What is the Citi interview process for freshers?
Citi’s Technology Analyst campus process typically starts with an Online Test (around 90 minutes on HackerEarth: 3 coding questions - Easy, Medium, Medium - plus aptitude and CS-fundamentals MCQs on stacks, queues, trees, sorting, and OOPs), followed by one or two Technical Interviews (often on a two-panel-member format, sometimes via a platform like Aspiring Minds) and an HR round. Results are usually declared quickly, often within a week of the final round.
What questions are asked in Citi interviews?
Technical interviews open with ‘Tell me about yourself’ and then dig into your best and most difficult projects, C++/Java fundamentals, DBMS concepts, and coding questions. The MCQ section of the online test also covers data interpretation, logical reasoning, SQL/PL-SQL, and basic programming.
How many rounds are there in the Citi interview?
Most Citi campus drives run 3-4 stages: Online Test, one or two Technical Interviews, and an HR round. Eligibility generally requires 6+ CGPA with no active backlogs, and shortlisting is competitive - one reported drive shortlisted 129 of 654 test-takers for interviews, with 52 eventually moving forward.
How should I prepare for Citi interviews?
Practice coding on HackerEarth-style platforms and revise core CS subjects (DSA, OOPs, DBMS) for the online test. For interviews, prepare a clear, detailed narrative about your most challenging project - Citi interviewers tend to probe deeply into project specifics - and be comfortable writing SQL/PL-SQL queries live.
Is the Citi technical interview live-coding or discussion-based?
It’s mostly discussion-based rather than a whiteboard-coding grind: interviewers ask you to explain your projects in depth (why a given tech stack, what broke, what you’d change) and probe C++/Java and DBMS fundamentals conversationally, with lighter coding than the online test’s HackerEarth round. Some panels run with two interviewers at once.
Where is Citi’s technology hiring based in India?
Citi runs Citi Solutions Centers (CSC) across five India cities - Bengaluru, Chennai, Gurugram, Mumbai, and Pune - covering technology work for Global Consumer Banking, Markets & Securities, Risk & Capital Management, Cash Management, and other lines of business. Citi also runs an annual Campus Innovation Challenge hackathon on HackerEarth that can lead to pre-placement interview opportunities.