r/InterviewCoderHQ

Everything technical I remember from my Visa Software Engineer interview. Three rounds, all in person on the same day, 2 years of experience in Java, Spring Boot, Python, AWS, GitHub Actions, Kubernetes, and MySQL going in.

Round 1 - DSA and OOP (45-60 min)

Three DSA questions were given. The first was palindrome checking using a two-pointer approach comparing characters from both ends, giving O(n) time and O(1) space. The second was finding the kth minimum or maximum element using a heap of size k maintained while iterating through the array, running in O(n log k). The third was a two-pointer and sorting problem where the array is sorted first and pointers from opposite ends are used to find pairs or triplets meeting a condition.

OOP covered all four pillars with real-world examples, Array versus LinkedList tradeoffs in terms of access and modification complexity, and method overloading versus method overriding with the distinction between compile-time and runtime resolution.

Round 2 - Java Internals and Cloud (45-60 min)

Java questions focused on string comparison where == checks reference equality and equals checks character sequence equality, the main method signature broken down keyword by keyword covering why it is public, static, and void and why it cannot be overridden, StringBuilder versus String in terms of mutability and performance, and primitive data types alongside their wrapper classes.

Cloud questions covered Docker versus Kubernetes, with Docker handling containerization and Kubernetes handling orchestration, scaling, self-healing, and rolling deployments across a cluster.

Round 3 - Managerial (45 min)

Covered work experience, project architecture, and behavioral questions. A full CI/CD pipeline was drawn on a whiteboard covering a GitHub Actions workflow that runs tests, builds a Docker image, pushes to a registry, and deploys to Kubernetes with automatic rollback on health check failure.

Following the three rounds, a CodeSignal assessment was completed with 3 out of 4 problems solved. The recruiter confirmed the position was filled by another candidate.

Happy to answer any questions if you are preparing for Visa.

CS student at a university in the US. Applied off-campus for a full-time Software Engineer role at AQR Capital. Two rounds total, both conducted online. Here is the full breakdown.

Round 1 ran for 30 minutes and covered three technical topics after a brief self-introduction.

The first topic was StringBuilder versus String in Java. The core distinction is mutability. String objects in Java are immutable, meaning every concatenation operation allocates a new object in the heap, copies the existing characters, and appends the new ones. In a loop performing n concatenations, this produces O(n²) time complexity due to repeated copying. StringBuilder maintains an internal char array and appends in-place, giving O(1) amortized time per append and O(n) overall. The interviewer was looking for awareness of the heap allocation overhead and the practical implications for performance-critical code.

The second topic was Smart Pointers in C++. The discussion covered the three main types. unique_ptr enforces exclusive ownership of a heap-allocated object, with the destructor automatically deallocating memory when the pointer goes out of scope, and ownership transferable only through std::move. shared_ptr uses atomic reference counting, allowing multiple owners and deallocating only when the count drops to zero, which introduces overhead on every copy and assignment. weak_ptr holds a non-owning reference to an object managed by shared_ptr, allowing observation of the object without incrementing the reference count, which is the standard solution for breaking circular references that would otherwise cause memory leaks.

The third topic was Angular Directives. Component directives define a component with its own template and encapsulated logic. Structural directives modify the DOM structure directly, with ngIf conditionally adding or removing elements and ngFor rendering a template once per item in a collection. Attribute directives change the appearance or behavior of an existing element without altering the DOM structure, with ngClass and ngStyle being the standard examples.

Round 2 ran for 60 minutes and covered three areas.

The first area was output-based code questions. These tested deep knowledge of language-specific behavior rather than surface-level syntax, covering operator precedence, implicit type coercion, variable shadowing, scope resolution, and edge cases around null handling and short-circuit evaluation.

The second area was SQL queries covering data retrieval, filtering with WHERE clauses, aggregation with GROUP BY, and JOIN operations across multiple tables.

The third area was three coding questions. The first was reversing the words in a given string. The approach splits the input on whitespace using a regex to handle multiple consecutive spaces, reverses the resulting array, then rejoins with a single space. Leading and trailing whitespace needs to be trimmed before processing to avoid empty strings in the output array.

The second question was given a list of strings including area, acre, bat, ball, Amsterdam, am, and AmsterdaM, find the string containing all four characters a, A, m, and M. The correct answer is AmsterdaM. The approach iterates through each string, converts it to a character set, and checks for the presence of all four distinct characters. This question requires configuring the character check to treat lowercase and uppercase as distinct since most standard contains checks are case-insensitive by default.

The third question was given numbers from 1 to 50, output the ones containing the digit 2, producing 2, 12, 22, 32, and 42. The approach converts each integer to a string and checks for the character 2.

The result was that I was not selected after the second round.

Happy to answer any questions if you are preparing for AQR Capital.

CS student at a university in the US. Went through the Mu Sigma hiring process recently and sharing the full breakdown for anyone prepping.

The process was one online test followed by a single interview round.

Two coding problems, moderately difficult, with a heavy focus on writing efficient solutions that handle edge cases cleanly. Time complexity needs to be thought through before writing a single line, because sloppy solutions with poor optimization get flagged. Problems covered algorithms and data structures, so knowing your sorting algorithms, traversal methods, and space/time tradeoffs going in is mandatory.

The aptitude section ran simultaneously and covered quantitative reasoning, logical puzzles, and verbal ability. Both the speed and accuracy of your answers are scored, meaning practicing under timed conditions beforehand makes a measurable difference in how you perform.

The interviewer went deep on Java through practical scenarios rather than textbook definitions. Topics covered included inheritance, encapsulation, polymorphism, and abstraction all framed around how you would apply them in real systems. Method overloading versus method overriding came up with a focus on when and why you would choose one over the other in actual code. Abstract classes versus interfaces was another area, with the discussion centered on design decision-making rather than syntax differences. Exception handling, how you structure try-catch blocks for clean and maintainable error management, also came up. The collections framework was covered as well, specifically when to use ArrayList versus LinkedList versus HashMap and what the performance tradeoffs behind each choice look like in practice.

The project discussion went deep into every technical decision behind the stack. My project involved React.js, JavaScript, and MySQL, and the questions covered React component lifecycle and how state management was handled across components including how re-renders were controlled to avoid performance degradation. JavaScript asynchronous behavior came up in detail, specifically how promises and async/await were structured and how the architecture avoided callback issues. MySQL schema design decisions were discussed including indexing strategy and how queries were optimized to avoid full table scans on large datasets. The interviewer also pushed on how the frontend and backend communicated, API design choices, and how data consistency was maintained between the React layer and the database.

A dedicated portion covered writing optimized SQL queries, including using JOINs efficiently with a clear understanding of when to use INNER, LEFT, and RIGHT joins depending on the data relationship. Writing subqueries versus CTEs was discussed with a focus on readability and performance. Identifying and fixing slow queries through execution plan analysis came up, along with index usage and the scenarios where adding an index can hurt performance rather than help it.

Debugging questions focused on methodology: how you isolate a problem, reproduce it consistently, and resolve it without introducing regressions elsewhere in the codebase.

Happy to answer any questions if you are prepping for Mu Sigma.

Third year CS student at a university in the US. Already had an internship locked in but GS came to campus so I figured why not. Sharing the full breakdown.

The process was an online assessment, then two technical rounds and an HR round, all in one day. Pay was basically equivalent to a ~$10k/month US tech internship for 2 months.

Around 800 students took the HackerRank test. Three DSA problems, 15-20 aptitude questions, and one descriptive self-story question. You needed 2/3 DSA problems solved plus solid aptitude to move on. Both sections share the same timer so you're basically speed-running your own panic attack. 44 made it through and I was one of them.

First technical round started with a self-intro then straight into projects. DSA covered Merge Sort vs Quick Sort tradeoffs, writing Merge Sort on paper with a full recursion tree diagram, then Floyd's Cycle Detection on linked lists. Basic SQL and light OS questions to finish. 20 students moved on and I cleared it.

Second technical round went back to the project briefly then into security concepts. JWT questions were all scenario-driven, things like "someone steals the access token, now what." Reciting the definition of JWT is not going to save you here. Then the interviewer asked my strongest DSA topic. I said linked lists. Question was reverse a linked list in groups of K, full working code on paper, 10 minutes. Did not finish. 13 students cleared. I was not one of them.

HR round went to 8 students who got the offer.

Happy to answer any questions if you're going through a similar process.

Background going into this: 6 years of experience as a backend engineer, strong on distributed systems and Python, average on algorithms. I did not grind LeetCode for this one and it turned out that was the right call.

Preparation

Anthropic's interview structure does not reward LeetCode pattern recognition. The coding questions are practical engineering problems, so I focused on concurrency primitives in Python, async I/O patterns, ThreadPoolExecutor, producer-consumer queues, and writing production-quality code with proper error handling and logging. I also reviewed system design fundamentals covering distributed systems, fault tolerance, observability, and scalability tradeoffs. Total prep time was around six weeks.

The culture and values round requires separate preparation. I spent time reading Anthropic's published research and public writing on AI safety, responsible deployment, and model evaluation. This round eliminated candidates with strong technical performance, so I treated it as a full preparation track, not an afterthought.

Recruiter Screen (30 to 45 mins)

Standard background conversation. The recruiter covered motivation for joining Anthropic specifically, interest in AI safety, communication style, and team collaboration history. The recruiter flagged upfront that the values and culture rounds carry as much weight as the technical rounds in the final hiring decision.

Technical Screen (55 to 90 mins)

Anthropic's technical screen does not include classic algorithmic warm-up questions. The problems are practical engineering tasks. I had to build an async processing pipeline using ThreadPoolExecutor, handle concurrency safety, and debug performance bottlenecks in the implementation.

Common topics reported across candidates include multithreading, async processing, API design, streaming systems, and pipeline debugging. The evaluation criteria were readable code, correct concurrency handling, architecture decisions, and debugging methodology rather than time complexity alone.

Hiring Manager Discussion (45 to 60 mins)

Less coding, more architectural reasoning. Questions focused on system tradeoffs: how would you scale this, what component fails first under load, how would you redesign this with different constraints, how would you instrument this for observability. The interviewer assessed engineering judgment and clarity of reasoning rather than convergence on a specific answer.

Virtual Onsite (4 to 6 rounds)

Coding Round:

• Build a thread-safe cache with configurable eviction policy
• Debug a performance bottleneck in a streaming tokenization system
• Design and implement a reservation service with concurrency constraints

System Design Round:

• Distributed inference API handling high request volume
• GPU scheduling and batching for LLM inference workloads
• Real-time streaming architecture with fault tolerance and observability

Project Deep Dive (45 to 60 mins): This round is consistently underestimated. The interviewer spent the full session on a single past project: architecture decisions, tradeoffs made, bottlenecks encountered, technical debt introduced, monitoring approach, and what would be redesigned with hindsight. The depth of questioning goes significantly further than most candidates prepare for.

Behavioral Round: Standard collaboration and conflict resolution questions. Focus was on how disagreements were resolved, how decisions were made under uncertainty, and how technical debt was communicated to stakeholders.

Culture and Values Round: Questions covered AI safety tradeoffs, ethical decision-making in ambiguous deployment scenarios, intellectual honesty when results conflict with expectations, and reasoning under uncertainty. Multiple candidates who cleared the technical rounds did not pass this stage. Preparation matters here.

Outcome

Received an offer at L4 approximately two weeks after the final onsite. Also received a rejection from OpenAI during the same preparation cycle after clearing the technical screen but not the system design round.

Got laid off recently and started interviewing again, but I haven’t had much success so far.

With so many layoffs and not enough open positions, it feels like companies are raising the bar insanely high. Some of the questions I’ve been asked honestly didn’t feel possible to finish within an hour unless you had already seen them before.

On top of that, it seems like more people are either using AI tools like InterviewCoder during interviews or studying leaked questions from sites like InterviewDB. I know a few people irl who got offers that way, and it honestly feels like I’ll lose out if I don’t do the same.

Anyone else feeling the same way?

A bunch of guys in my mechatronics class decided to test it during upcoming interviews, and every single one of them got caught. The companies detected the software and even sent notices to our school threatening serious consequences, including banning students from their establishments and potentially getting them expelled.

Seriously, do not trust these tools. It's a terrible idea.

I genuinely feel bad for them because they're my friends, but this should be a wake-up call: do your research on what software works and who other doesn't

I want to preface this by saying I consider myself a below average programmer. I still count on my fingers for simple arithmetic, I google how to initialize an array at least once a week, and medium Leetcode questions sometimes take me a full day just to understand what the problem is asking. 12 years of experience as a senior software engineer at a bank in Toronto, 50 to 60 hour workweeks, Zoom calls and no algorithmic work day to day.

Preparation

I completed around 200 Leetcode questions total. Early on I could not solve problems independently and the ones I got through used nested conditionals and consistently hit TLE. I switched to reading editorial solutions immediately instead of attempting cold solves.

My strategy was to identify the top 50 to 100 Meta-tagged questions on Leetcode and repeat each solution a minimum of five times until I could reproduce it from memory, including brute force variants and common follow-up questions. Total prep time was five months, blocked from 5am to 9am on weekdays and weekends.

Recruiter Screen

LinkedIn outreach from a Meta recruiter. One informal call, no technical component.

Technical Phone Screen (45 mins)

Two problems pulled from the Meta-tagged questions on Leetcode:

• Stack-based parentheses validation problem
• Palindrome problem with a hard-level follow-up, approach explanation only, no coding required

My approach each round: disclose upfront if I had seen the problem before, state my approach verbally, write pseudocode, walk through boundary conditions and time/space complexity, then ask for confirmation before writing any code.

Online Onsite

Coding Round 1:

• Subarray Sum Equals K (two variants: all positive integers, then allowing negative integers)
• Lowest Common Ancestor of a Binary Tree

Coding Round 2:

• Lowest Common Ancestor (second instance, different problem variant)
• Merge K Sorted Arrays (note: the Leetcode version uses linked lists, the actual question used arrays)

System Design:

• Ticketmaster-style distributed ticketing system, reduced scope
• Used Grokking the System Design Interview to structure responses covering requirements, capacity estimation, API design, data modeling, and component architecture

Behavioral:

• Prepared using Meta-specific behavioral question lists from Google search and YouTube
• Referenced Careervidz on YouTube for structured STAR-format answer templates

Outcome

Received an offer at E4/L4 eight days after the final round. Also received rejections from Amazon and Coinbase during the same preparation cycle.

A recruiter I know at a large tech company told me their team uses an LLM to go through thousands of applications before a human even sees them. Most candidates are literally being judged by AI from the start.

So companies can use AI to screen you, reject you, and rank you but candidates using AI assistance during interviews is crossing the line?

Hiring has changed on both sides. The people getting offers are the ones adapting fastest. Half of my CS class is using InterviewCoder to get their internships and I decided a month ago I was going to start using it too.

Anyway, you're competing against candidates using AI whether you like it or not.

Hear me out, If you're going into junior or senior year of college with zero job experience because you couldn't land internships in your earlier year, you're cooked. Most companies only want applicants who already managed to break in early. The students who got internships freshman or sophomore year now have stacked resumes, referrals, multiple interview cycles worth of experience.

At that point, your only realistic strategy is to mass apply everywhere, to get as many OAs as possible and to use InterviewCoder for the online assessments because passing in-person rounds is honestly way easier than getting filtered out online

You can't convince me otherwise.

I go to UC Berkeley for CS and over 50% of people in my classes still don't have internships for the summer. I'm part of that 50% of course. I thought going to a top school would give me the best shot at getting employed, but I couldn't have been more wrong.

The only people I see getting offers are either absolute geniuses or dudes who somehow launched 3 startups at age 19 after using InterviewCoder on every OA instead of grinding Leetcode.

Does anyone have advice ?

3 years of experience, applied through the official careers portal (not referral - the referral queue is way too long), and got the offer last week.

Getting to the interviews

Applied through Microsoft's careers portal roughly 20 times across different openings. Got test links 3 times total but cleared the first one so the other two never went further.

The online assessment was on HackerRank, 90 minutes. Harder than the actual rounds honestly. One problem required Dijkstra + DFS, another was C(n,k) combinatorics with modular arithmetic. Completed the first test fully, got around 80% on the second. Time pressure was rough.

The interview rounds (August 1-8, fully virtual)

Round 1 was DSA, 60 minutes. Three problems: Rotten Oranges, check if a binary tree is a valid BST, and find the two swapped nodes in a BST. Fundamentals round, nothing too surprising.

Round 2 was Low Level Design: a Post Office system. This one caught me off guard. Design a system that consumes letters from one end and distributes them to multiple postmen efficiently. Core entities were PostOffice, Letter, DeliveryPerson, and Route. We got deep into concurrency - handling multiple delivery workers processing letters in parallel. I hadn't prepped this specific scenario but had built a telemetry logger during prep and borrowed those patterns. Saved me.

Round 3 was another LLD: classic Elevator system. Scheduling logic, multiple floor requests, direction algorithms, controller communicating with individual elevator objects. Standard if you've done LLD prep.

The AA round (Applied Problem Solving) was the most interesting. Three parts: write code to deliberately make a machine sluggish (I went the wrong direction initially - the actual angle was spreading CPU load across cores), pseudo-code for Google Docs LLD covering real-time collaboration and conflict handling, and a deep dive into my Rate Limiter project using the token bucket approach.

A few things worth noting

Interviewers across all rounds were collaborative. They care about how you think through a problem more than whether you immediately land the right answer. If you get redirected, don't panic - engage with it.

If you're prepping for L61 specifically, build something real from scratch. Having actual code you wrote makes the design rounds way more grounded. Happy to answer questions.

I was reading the testimonials on their website yesterday and genuinely couldn't tell if they were satire.

Some had em dashes everywhere. The worst one said: "the interview wasn't the problem, friction was."

Dawg 😭 who talks like this in real life?

Hi everyone,

I have an upcoming interview for the Sr. Software Engineer, FinTech role at Tesla. My first technical round is scheduled for 45 minutes, and the recruiter mentioned it would be a system design round.

I was a little surprised because in many companies I have usually seen the first technical round start with coding, followed by system design in later rounds.

Has anyone interviewed for this role or a similar Tesla software engineering role recently? What was the interview process like? Was the first round actually system design, coding, behavioral, or a mix?

Any guidance on what to expect or how to prepare would be really helpful.

Thanks!

Deloitte USI came to our campus in September for analyst hiring. Got selected at the end so sharing the full breakdown.

Online Assessment 65 MCQs covering programming and reasoning, plus 2 coding questions that were easy to medium level. 90 minutes total. Out of everyone who sat it, 100 students from our college moved forward to the technical round.

Technical Round 30 minutes, fully virtual. The focus was DSA, problem-solving approach, and SQL. Questions I got: difference between SQL and NoSQL, a medium-level DSA problem, and some OOP concepts. Nothing too deep but they pay attention to how you think through problems out loud, not just whether you get the right answer.

HR Round 15 minutes, also virtual, taken by a manager. They went through my resume project by project and asked about my specific role in each one. Standard behavioral questions on top of that. The main thing here is just being honest about what you actually built vs what the team built. They can tell when you're vague.

Verdict: Selected.

Hey there, I hope the react family is doing good, after struggling for 2 years, finally HR arranged intrdocutory call tomorrow, please experienced developers do help me out, how can I pass that introductory session at least.

Thank You.

I ran a few of UltraCode's testimonial videos through an AI detector out of curiosity and some of them came back as AI-generated.

They did look very very weird at first glance so I'm not surprised.

Using fake AI-generated people to promote software that can literally get you blacklisted from companies is insane. Massive red flag. Would never trust a tool like this.

Third-year CS at an NIT here. Goldman Sachs came to campus for their Summer Analyst Trainee internship and I went through the full process. I already had a Visa offer locked in so there was no pressure, which made it easier to observe everything clearly. Sharing this for anyone who has this coming up.

Nearly 800 students sat the OA across all branches. By the HR round, 8 were left. The funnel is steep and the cuts happen fast.

Online Assessment

Taken from home, open to all branches. Around 1.5-2 hours total: three DSA problems, 15-20 aptitude questions, and one descriptive self-story question all in the same window. Minimum bar was solving at least 2 DSA problems with a solid aptitude score. Managing time between coding and aptitude in one sitting was the hardest part. 44 students cleared it. I was one of them.

First Interview

Face to face on campus, 25-30 minutes. Opened with a self-intro, then the interviewer went into my project, covering design decisions and specific optimizations. DSA section covered Merge Sort vs Quick Sort differences, writing Merge Sort on paper with a full recursion diagram, time complexity across all three cases, and Floyd's Cycle Detection for linked lists. A few SQL queries and basic OS questions at the end. 20 students advanced. I cleared it.

Second Interview

Same format, 25-30 minutes. First half went deeper into my project, focusing on architecture and design tradeoffs. Then Authentication vs Authorization, how JWT works internally, and a real-world scenario around Access Tokens and Refresh Tokens: if a token gets stolen, how do you protect the user without forcing a full re-login? For coding, I said Linked List was my strongest topic. The problem was reversing a linked list in groups of K, on paper, in 10 minutes. I didn't finish in time and didn't clear this round. Some friends who advanced were also given logic puzzles, so prepare those separately.

HR

I didn't sit this round, eliminated in the second interview. From the 13 who reached it: relaxed and conversation-based, covering behavioral questions, interests, teamwork scenarios, and a few short logic puzzles. No heavy technical content. 8 students got the offer.

Closing Thoughts

Topics that came up across all three rounds:

• Merge Sort and Quick Sort: differences, on-paper implementation, all three time complexity cases
• Linked list problems, especially group reversal (K groups)
• Floyd's Cycle Detection
• JWT internals, Access Tokens, Refresh Tokens, and token theft scenarios
• Authentication vs Authorization
• Basic SQL queries
• Logic puzzles (GeeksforGeeks is a solid source)