Interview Experiences
Interview Experiences
Explore candidate-reported interview journeys across companies, roles and hiring routes. Read what was discussed, when the report was published, what the candidate faced, and the practical preparation lessons that can be taken from each experience.
How These Reports Are Prepared
Candidate experiences are based on publicly available interview reports. We organize the reported information into a practical format and add independent GetYourFirstJob analysis so readers can understand what to prepare rather than simply reading a copied interview account.
Important Information
These are candidate-reported experiences, not official company question papers. Interview rounds and questions can change according to role, hiring cycle, location, interviewer and candidate profile.
Share Your Interview Experience
Recently attended an interview? Tell other candidates what happened, which rounds you faced, what topics were discussed and what you learned from the process. Your experience can help someone prepare better for their next opportunity.
Candidate Interview Experiences
Read the candidate account • check the date • use the preparation takeaway
The candidate described an online assessment covering aptitude, reasoning, verbal ability and coding, followed by a technical discussion. The technical conversation moved through projects, Java, OOP, linked lists and trees before a separate HR discussion around motivation, relocation and work pressure.
- Explain your project and your individual contribution.
- What are the key OOP concepts in Java?
- How would you reverse or manipulate a linked list?
- What tree concepts or traversals are you comfortable with?
- Why do you want this role, and are you open to relocation?
The useful preparation signal is breadth: a fresher should not prepare DSA in isolation. Resume projects, OOP and communication can all become part of the same interview.
This report described a four-stage process beginning with coding, followed by a technical interview, managerial discussion and HR formalities. The technical conversation included project discussion, linked-list reasoning, missing-number logic and a puzzle, while later rounds focused more on motivation, campus life and availability.
- Explain your project and the technologies you used.
- How would you find a missing number in an array?
- What linked-list logic/problem did you solve?
- How did you approach the interview puzzle?
- Why this company, and are you available for the role?
The report is a good reminder that a technical interview may test reasoning rather than only memorised DSA solutions. Prepare a short explanation for every project on your resume.
The candidate shared a particularly relatable scheduling problem around an interview invitation arriving during internal examinations. The experience then moved into the technical stage after the candidate cleared the initial placement screening.
- The report does not publish the exact technical questions asked.
- The account mainly covers the interview invitation, examination clash and progression to the technical stage.
For campus candidates, keep checking official communication even during busy academic periods. Preparation is only one part of placement readiness; responding to scheduling information matters too.
The reported journey began with a TCS iON assessment containing aptitude, logical and verbal sections plus coding. The technical round then moved into programming fundamentals, OOP, DBMS and the candidate's final-year project, followed by a short HR and managerial discussion.
- Explain OOP concepts with examples.
- Which DBMS concepts have you used in your project?
- Explain your final-year project architecture and your contribution.
- Solve a coding/problem-solving question using your preferred language.
- Why do you want to join TCS and are you comfortable with the role/location?
The report strongly supports preparing fundamentals alongside coding. Be ready to explain your project and basic Java/Python/C++ concepts without relying on memorised definitions.
The candidate described a TCS NQT route with numerical, aptitude, verbal and coding sections. The account highlights the importance of speed in the non-coding sections and separates the easier and advanced coding portions.
- How do you manage time across numerical, aptitude, verbal and coding sections?
- What is your approach to the easier coding section?
- How would you approach an advanced coding problem under time pressure?
- Which NQT section do you find most challenging and how do you prepare for it?
For NQT-style preparation, do timed mixed practice rather than solving coding questions for the entire session. Speed in aptitude can affect how much mental energy remains for coding.
The interview panel included technical, HR and managerial representation. The candidate described pen-and-paper coding around matrices, primes and strings, followed by SQL, HTML and other technical discussion.
- Write logic for matrix multiplication/related matrix processing.
- How would you generate or identify the nth prime?
- How would you reverse a string without relying on a built-in shortcut?
- Write or explain an SQL query.
- What HTML concepts do you know?
The report suggests that basic coding exercises can still matter in service-company interviews. Practise writing logic without depending entirely on an IDE.
The candidate reported an assessment covering aptitude, coding and written communication before a technical interview. The technical discussion focused heavily on the final-year project and the candidate's understanding of the architecture and personal contribution.
- Explain your final-year project architecture end to end.
- Which modules did you personally implement?
- What technical decision did you make in the project and why?
- How did you approach the coding assessment?
- Why do you want to work at Wipro?
A strong project explanation should cover architecture and your own contribution. Do not describe a team feature as your individual work if you did not implement it.
The candidate reported an online test with logical reasoning, C/C++ output questions and operating-system topics. The technical round then moved to projects and sorting, including a quicksort implementation, followed by HR questions around aspirations and relocation.
- Predict the output of a C/C++ program.
- Explain important operating-system concepts.
- Implement or explain quicksort.
- Which sorting algorithm would you choose for a given input and why?
- Explain your project and your contribution.
For service-company campus interviews, revise output-based programming questions and core CS along with DSA. Also prepare simple behavioural answers that are specific rather than generic.
The candidate reported a coding assessment followed by technical interviews. One technical round involved two coding problems using hashing and a priority queue, then shifted to leadership-style questions about decision making under pressure.
- Solve a coding problem using hashing.
- When would you choose a priority queue and how would you use it?
- Explain the time and space complexity of your solution.
- Describe a time you made a decision under pressure.
- How do you handle disagreement or ownership in a team?
Amazon-style preparation benefits from combining algorithmic practice with concrete behavioural stories. Prepare examples where you made a decision, handled pressure and explained the result.
The candidate found the SDE1 opening through the careers route and later received a referral. The coding round contained two problems, while the interview expectations included explaining the solution, optimising it and discussing time and space complexity.
- Solve the two coding problems from the assessment.
- How would you optimise your initial solution?
- What is the time complexity of your approach?
- What is the space complexity and can it be reduced?
- Explain your reasoning before writing the final code.
A useful takeaway is to practise the complete explanation cycle: brute force, better approach, code, complexity and edge cases. For experienced roles, prepare professional examples for behavioural questions too.
The campus process included an online coding round and three virtual interviews. The candidate initially passed only some test cases in the assessment but was still shortlisted, which made the experience a useful lesson in not assuming that partial performance automatically means rejection.
- The report does not publish the exact questions from the virtual interviews.
- The account focuses on the online coding result, three virtual interviews and the fact that partial test-case performance did not automatically end the process.
Do not abandon an assessment mentally after one imperfect question. Submit the strongest implementation you can, then prepare for the interview until an official result says otherwise.
The assessment combined debugging, coding, work-style and logical-ability sections. The coding portion included two problems, one easier and another involving two-pointer and greedy reasoning, before a sizeable interview shortlist.
- Debug a program and identify the source of the issue.
- Solve a two-pointer problem.
- Explain a greedy approach and why it works.
- How do you choose between alternative solutions?
- Explain the complexity of your coding solution.
The experience shows why timed debugging and reasoning practice can complement pure DSA. Practise identifying a bug quickly instead of always starting with a blank editor.
The candidate reported an assessment followed by several interviews. The technical discussions included a circular gas-station problem, binary-tree views and additional problem-solving and CS fundamentals.
- Solve the gas-station/circular-route problem.
- How would you find or display the right view of a binary tree?
- Explain your DSA approach before coding.
- What edge cases would you test?
- Which core CS fundamentals are you strongest in?
For multi-round product-company interviews, revise both common DSA patterns and the ability to explain different ways of solving a tree problem.
The internship route included coding and computer-basics questions, later followed by another assessment and a project presentation. The final discussion focused on what the candidate learned during the project and how they contributed.
- Solve coding problems in an internship assessment.
- Answer computer-science basics used in software development.
- Explain your internship/project implementation.
- What did you personally learn from the project?
- What was your contribution and what would you improve?
Internship candidates should prepare to discuss what they actually learned and built. A project review can test understanding more deeply than a polished project title.
The reported process combined an online test with technical, managerial/HLD and later technical/LLD discussions. The candidate described DSA, a Java internals project, leadership discussion and a URL-shortener style system-design problem.
- Design a URL-shortening system at a high level.
- Explain an LLD approach for a software component.
- Discuss a Java internals concept from your project.
- Explain DSA choices and complexity for a coding problem.
- Describe a leadership decision or trade-off you handled.
Experienced candidates should expect the interview to move beyond coding. Prepare system design, project depth and examples of difficult engineering decisions.
The candidate described applying through Microsoft Careers with a referral, completing an OA with two coding questions and later preparing by revising DSA, projects and CS fundamentals before interviews.
- Solve a heap-based coding problem.
- How can binary search be combined with another data structure/approach?
- Explain your DSA solution and its complexity.
- Walk through your projects and technical contributions.
- Revise OOP, OS and DBMS concepts for the technical rounds.
The preparation pattern is valuable: revise coding and your own projects together. A project that you can explain line by line is stronger than a project that only looks impressive on a resume.
The candidate first went through an HR screening before technical rounds. The account emphasises keeping LinkedIn and the resume accurate, then preparing for technical interviews around DSA, projects and the candidate's professional background.
- Explain the DSA problem-solving approach you use.
- Walk through the projects listed on your resume.
- Which technologies and responsibilities are genuinely yours?
- Why is accuracy important on a LinkedIn profile and resume?
- How would your professional experience prepare you for the role?
The strongest resume strategy is accuracy. Every technology and experience claim should be something you can defend when an interviewer asks a follow-up.
The candidate reported a Codility screen followed by technical questions around OOP, arrays versus linked lists, reversing a linked list, queues and priority queues. The interviewer also tested modular class design and appropriate data-structure selection.
- When would you choose an array over a linked list?
- Reverse a linked list.
- What is the difference between a queue and a priority queue?
- How do OOP principles influence class design?
- How would you design classes to keep a module modular and maintainable?
This report shows that coding questions can be used to evaluate design quality too. Practise clean naming, modular methods and choosing a data structure for a stated requirement.
The candidate described a structured process moving from aptitude into technical assessment and then a combined technical and HR discussion. Quantitative reasoning and time management were important early in the process.
- How do you approach quantitative-aptitude questions under time pressure?
- What strategy do you use for logical reasoning?
- How do you manage section-wise time in an assessment?
- What technical areas did you revise before the combined technical/HR round?
For fresher hiring, practise speed and accuracy together. A candidate who knows the concepts but spends too long on early questions can still lose valuable time.
The candidate described a difficult coding assessment followed by two technical rounds and HR. The technical discussions concentrated on DSA and optimisation, with interviewers paying attention to the reasoning and trade-offs behind the code.
- Solve a difficult DSA problem and explain your reasoning.
- How would you optimise the first solution you write?
- What are the time and space trade-offs of your approach?
- How do you handle a hard problem when the first idea does not work?
- Explain the project or technical work on your resume.
Product-company interviews may go deep into a small number of problems. Practise explaining why your approach works rather than only trying to finish quickly.
The assessment included Unix-related questions and DSA. In the interview rounds, the candidate discussed array deduplication, a resume project, SQL, DBMS keys, OOP, sorting and a Singleton design pattern.
- Explain a Unix/Linux concept relevant to software development.
- How would you remove duplicate elements from an array?
- What are primary and foreign keys in DBMS?
- Explain OOP concepts with examples.
- What is the Singleton design pattern and when would you use it?
- Explain a sorting algorithm and its complexity.
The report is a good example of how a coding interview can branch into databases and design. Revise these topics together if your target role expects broad fundamentals.
The candidate described an aptitude, data-interpretation, reasoning and verbal assessment followed by essay writing. The experience highlighted section-wise cutoffs and the importance of moving on rather than spending too long on one area.
- How do you approach data-interpretation questions quickly?
- How do you divide time between aptitude, reasoning and verbal sections?
- What is your strategy for the essay-writing section?
- What do you do when one section is taking too much time?
For sectional assessments, practise switching between question types. A strong score in one section cannot always compensate for ignoring another section.
The recruitment process included an online test through the college process and later stages for software-oriented roles. English, technical MCQs and verbal areas were part of the reported assessment.
- What type of English/verbal questions were included in the assessment?
- How do you approach technical MCQs?
- What is your strategy for verbal reasoning under a section cutoff?
- What software-engineering fundamentals did you revise for the role?
Candidates should prepare the assessment format as well as the technical syllabus. Pseudocode practice can help when questions test logic without requiring full programs.
The candidate described a changing assessment pattern involving technical MCQs and pseudocode, essay writing, gamified aptitude, coding, English and an interview.
- Solve or explain pseudocode questions.
- Answer technical MCQs from core programming concepts.
- How do you approach gamified aptitude tasks?
- Solve the coding section under time pressure.
- Prepare for the English and final interview stages.
Because hiring formats can change, prepare the underlying skills instead of relying on an old exact section order. Keep technical fundamentals and communication ready.
The internship process started with resume screening and moved through multiple technical discussions covering DSA basics, problem solving, coding, OOP and broader technical topics. The candidate was not selected but found the process useful for understanding expectations.
- Explain a basic DSA problem and your approach.
- How do you analyse a problem before coding?
- Write or explain a coding solution and its complexity.
- Explain OOP concepts with practical examples.
- What did you personally learn from your project?
A non-selection report can be valuable because it shows what the candidate experienced without presenting hiring as guaranteed. Candidates can use it to build a broader preparation plan.
The candidate reported a telephonic discussion followed by technical and HR rounds. Technical topics included linked-list coding, bit manipulation, strings, smart pointers, dangling pointers and memory leaks.
- Reverse or manipulate a linked list.
- Explain bit-manipulation techniques and common use cases.
- How are strings handled in C++?
- What are smart pointers and why are they useful?
- What is a dangling pointer and how can it occur?
- What causes memory leaks and how can you prevent them?
For C++ roles, preparation should go beyond DSA. Pointer safety, memory management and language-specific behaviour can be central to the technical discussion.
The candidate described an aptitude test followed by a technical test involving C++, Java, arrays, linked lists, sorting and SQL basics.
- Solve array-based problems.
- Explain linked-list operations.
- Compare common sorting algorithms and their complexity.
- Answer C++ and Java fundamentals.
- Write or explain basic SQL queries.
This is a useful fresher combination: practise coding in your chosen language while keeping SQL and basic CS fundamentals active.
The off-campus assessment covered aptitude, verbal and logical sections plus two coding problems. The report also mentions SQL and DBMS topics including keys, ER diagrams, normalization, joins and transaction-related concepts.
- What are primary, candidate and foreign keys?
- Explain ER diagrams and database relationships.
- What is normalization and why is it used?
- Explain SQL joins with examples.
- Discuss transaction-related DBMS concepts.
- Solve the coding problems from the assessment.
The assessment illustrates why database fundamentals should not be postponed until after coding preparation. Practise writing simple SQL as well as understanding the underlying DBMS concepts.
The candidate reported a resume and project discussion followed by coding questions around validating a binary-search-tree representation and decoding a numeric string. The interviewer checked edge cases and complexity as well as the code.
- How do you validate whether a binary tree is a valid BST?
- How would you decode a numeric string using dynamic programming/recursion-style reasoning?
- What edge cases would you test?
- What is the time and space complexity of your solution?
- Explain the project listed on your resume.
The experience reinforces a strong interview habit: explain the approach before coding, then test edge cases and be ready to discuss the complexity of the straightforward alternative.
The reported process contained screening, multiple technical rounds, system-design discussion, behavioural conversation and a hiring-manager stage. Topics ranged from Java internals and coding to Docker, Kubernetes, LLD and HLD.
- Explain a Java-internals concept from your experience.
- How would you design a URL-shortening service?
- What would you cover in a high-level system design?
- What would you model in low-level design?
- How are Docker and Kubernetes used in modern deployments?
- Describe a behavioural or leadership situation you handled.
For experienced roles, preparation needs layers: coding, technical depth, architecture and behavioural evidence. Practising only LeetCode would leave important parts uncovered.
The candidate described an extensive online assessment with aptitude, logical reasoning, coding MCQs, technical MCQs and verbal ability. The later technical discussion connected a networking project with security concepts.
- Solve aptitude and logical-reasoning questions under time pressure.
- Answer coding and technical MCQs.
- Explain your networking project.
- What security concepts are relevant to a networking system?
- How do you communicate a technical project to an interviewer?
A project can pull an interviewer into adjacent subjects. If networking or security appears on your resume, understand the practical concepts rather than preparing only a project pitch.
The candidate described technical rounds, a written technical/coding test and HR, with strong emphasis on C programming, operating systems, pointers, bit manipulation, linked lists and low-level system concepts.
- Explain pointers and pointer-related pitfalls in C.
- What happens in memory when a C program runs?
- Explain operating-system concepts relevant to low-level software.
- Solve a linked-list problem.
- Use bit manipulation to solve a programming problem.
- Explain low-level/kernel or system concepts discussed in the interview.
Systems-oriented roles can require much deeper C and OS fundamentals than a generic fresher interview. Match preparation depth to the job description and team.
The reported process included a HackerRank assessment followed by three technical rounds and HR. Technical discussion covered projects, memory leaks, C memory layout, linked lists, CPU scheduling and real-time systems.
- What causes memory leaks in C/C++?
- Explain C memory layout.
- Solve a linked-list problem and discuss complexity.
- Explain CPU scheduling concepts.
- What are real-time operating-system considerations?
- Explain your project and technical contribution.
The experience is especially useful for systems candidates. Revise memory, pointers and scheduling through small examples rather than only reading definitions.
The candidate described an assessment with DSA and CS fundamentals followed by multiple technical rounds. The first technical discussion included array, binary-string and anagram-style problems.
- Solve an array problem.
- Solve or explain a binary-string problem.
- How would you detect or compare anagrams efficiently?
- Explain the complexity of your DSA solution.
- Revise core CS fundamentals before the technical rounds.
The preparation lesson is to build speed on standard data-structure patterns while keeping core CS revision active.
The candidate was approached through a recruiter and reported a process involving DSA, system design and managerial discussion. A longest-substring problem was followed by Java and Spring Boot questions, with later discussion around system design.
- Solve the longest-substring problem.
- Explain Java concepts used in backend development.
- What is Spring Boot and how does it structure an application?
- How would you approach a system-design problem?
- Discuss scalability and trade-offs in your design.
Experienced backend candidates should prepare coding and framework fundamentals together. A project using Spring Boot can naturally lead to questions about APIs, architecture and design choices.
The internship hiring process included coding and an interview with DSA questions. In one discussion, the candidate initially considered binary search before the interviewer hint led toward a sliding-window solution.
- Solve the reported internship coding problems.
- Explain why a sliding-window approach can outperform a naive approach.
- When would you choose sliding window over binary search?
- Walk through the complexity of your solution.
The report shows that receiving a hint is not necessarily negative. Candidates should be comfortable revising an approach and explaining why the new observation changes the solution.
The candidate described a machine-coding round lasting about two and a half hours, with time for clarification, implementation and review. The account highlights the different skill set required when the interview tests design and implementation together.
- Clarify requirements before starting a machine-coding problem.
- How would you structure the code so it is easy to extend?
- What design choices did you make during the implementation?
- How did you test the solution within the time limit?
- Explain trade-offs in your implementation.
For experienced software roles, practise building a small working design within a fixed time. Explain assumptions first and leave time for testing and cleanup.
The candidate described three stages: an assessment combining coding and aptitude, a technical interview and HR. The technical discussion covered projects, HashMap, stack implementation and linked-list reversal.
- Solve coding questions in the assessment.
- Explain HashMap and when you would use it.
- How would you implement a stack?
- Reverse a linked list.
- Explain your project and the decisions behind it.
For service-company technical rounds, make sure basic data structures can be explained and implemented without excessive preparation overhead.
The assessment was reported to contain aptitude, logical reasoning, English, pseudocode, networking and office-software questions. The candidate highlighted the importance of speed because of the large number of questions.
- Solve pseudocode questions quickly.
- How do you approach networking questions in an aptitude-style assessment?
- How do you manage a large number of MCQs under time pressure?
- What logical-reasoning and English strategies do you use?
- How do you handle office-software questions efficiently?
A broad assessment rewards balanced preparation. Do not spend all your time on one technical area when the test evaluates several different skills.
Editorial & Source Transparency
Interview experiences published on this page are based on publicly available candidate reports and submitted experiences. GetYourFirstJob organizes the information and adds independent preparation analysis.
Candidate names are not invented. When a public report does not identify the candidate, the experience is labelled anonymous.
Report dates and interview dates are kept separate wherever the source provides enough information to distinguish them.
These reports are for preparation purposes only. Hiring processes, interview questions and eligibility criteria can change over time.
Outcome labels are conservative: Selected or Rejected is shown only where the public report explicitly supports the outcome. Otherwise the result is marked Not Confirmed.