"This interview experience is sourced from Chill Interview"

Interview Summary

The Disney Senior Data Engineer process covered cloud and hybrid data-pipeline design, Python and SQL, OOP fundamentals, frontend technologies from my resume, AI-assisted engineering scenarios, and extensive behavioral discussion. The technical rounds repeatedly emphasized concrete tool choices and trade-offs across AWS, Azure, local infrastructure, and cloud environments.

Interview Details

Round 1 — Recruiter Screen

The process started with a recruiter call after I applied through Workday. The recruiter reviewed my resume and asked about:

• Technical stack
• Tools I had used
• Basic cloud experience
• Work authorization
• Compensation range
• Location

The recruiter also clarified that the position did not provide sponsorship.

Round 2 — Technical: Data Pipeline Design + AI Usage

The technical round was conducted by a Tech Lead and two Senior Engineers. The main topic was designing a data pipeline in a cloud environment. The discussion went deeply into:

• Architecture choices
• Individual tools and packages
• Trade-offs among technologies
• Data movement
• Reliability and data quality
• Cloud-specific implementation decisions

The interviewers also asked several questions about using LLMs in engineering workflows. One scenario involved migrating an entire codebase from Java to Python and how I would structure prompts for an LLM to help with that migration. Another scenario involved cleaning tens of thousands of database records with AI assistance.

Follow-ups included:

• How would you verify data quality?
• How would you protect sensitive information?
• How would you validate AI-generated transformations?
• What security concerns would you consider?

Want to learn more questions asked in other interview rounds? I've put up the full version at here.

Preparing for your next interview?

Chill Interview tracks recent interview experiences and recurring question patterns across top companies at here.

"This interview experience is sourced from Chill Interview"

Interview Summary

The Snapchat MLE onsite contained four technical rounds covering ML fundamentals, coding, applied machine learning, and system design. Each round spent roughly 10 minutes on company values and project discussion, followed by about 50 minutes on the round-specific technical topic.

Interview Details

Round 1 — Machine Learning Deep Dive

The ML round started from a project on my resume and then drilled into nearly every part of the modeling process. The interviewer asked about problems encountered during training and how those issues were addressed.

Topics included:

• Layer normalization vs. batch normalization
• Multi-label learning
• Multiple engagement levels
• Regularization
• L1 and L2 regularization
• Neural-network-specific regularization such as dropout
• How dropout works
• Loss-function selection

The discussion was highly interactive, with the interviewer repeatedly asking deeper follow-ups based on each answer.

Round 2 — Coding: Organization Chart

The coding problem provided employee-management relationships and asked me to build an organization-chart abstraction. An example of the input was relations = [["M", "N", "P"], ["N", "Q"], ["P", "R"]], meaning M manages N and P, N manages Q, and P manages R.

The first part was to implement an OrgChart class from the relationship data. The next part asked for a rendered hierarchy where indentation represented organizational depth. For the example above, the output would conceptually look like:

M
....N
........Q
....P
........R

The final part asked for all skip-level pairs, where the second employee is exactly two levels below the first. For the rewritten example, the result would be [("M", "Q"), ("M", "R")]. AI assistance was allowed, but I was still expected to explain the approach, test the implementation, cover edge cases, and discuss time and space complexity.

Want to learn more questions asked in other interview rounds? I've put up the full version at here.

Preparing for your next interview?

Chill Interview tracks recent interview experiences and recurring question patterns across top companies at here.

"This interview experience is sourced from Chill Interview"

Interview Summary

The Tesla frontend onsite consisted of five rounds: three technical deep dives tied to projects on my resume, one React coding round, and one manager round combining frontend performance debugging with behavioral questions. Most rounds were constructive, but one technical deep dive was difficult because the interviewer used very broad prompts while expecting answers around a narrow, domain-specific set of concerns.

Interview Details

Technical Deep Dives — Resume Projects + Tesla Scenarios

Three rounds were built around technical areas from three different projects on my resume. For each topic, Tesla matched me with a Staff-level engineer familiar with that area. The interviewer first dug into my previous project and then introduced a related Tesla business scenario for me to analyze or design.

The discussions focused on applying my prior technical experience to practical product or engineering problems rather than solving generic coding questions. One of these rounds was much harder to navigate because the interviewer asked very open-ended questions such as:

• What is the biggest problem with this page?
• What is the hardest part of this page?
• What issues do you expect in this scenario?

When I asked for additional clarification, the questions remained broad. The interviewer eventually explained the specific concern they had in mind, but that made it difficult to determine the expected direction early enough in the discussion.

Frontend Coding — React Feature

One round asked me to implement a small frontend feature using React. The task focused on hands-on frontend implementation rather than algorithmic coding.

Manager Round — Performance Debugging + Behavioral

The manager interview started with approximately 20 minutes of practical debugging. I was given a frontend demo with performance problems and asked to investigate and improve it. The remaining roughly 20 minutes contained three behavioral questions. The behavioral discussion focused on previous work experiences and how I handled different engineering situations.

Overall, four of the five rounds felt reasonably positive from my perspective. The most difficult part of the onsite was the domain-specific deep-dive round where the expected evaluation criteria were difficult to infer from the initial questions.

Preparing for your next interview?

Chill Interview tracks recent interview experiences and recurring question patterns across top companies at here.

"This interview experience is sourced from Chill Interview"

Interview Summary

The Microsoft final loop consisted of four consecutive interviews covering behavioral questions, CS fundamentals, coding, and two system design problems. Technical topics ranged from cloning a doubly linked list with arbitrary pointers and binary-search-based capacity planning to designing a high-volume log storage platform and an online Tic-Tac-Toe service constrained to REST APIs.

Interview Details

Round 1 — Behavioral + Concurrency Fundamentals + Linked List

The behavioral question asked about a time I was blocked for an extended period and how I eventually resolved the blocker and moved the work forward. The interviewer then asked several CS fundamentals:

• What does thread-safe mean?
• What is a deadlock?
• What are some ways to prevent or resolve deadlocks?
• How do arrays and linked lists differ?

The coding problem was to clone a custom doubly linked list. Each node contained value, left, right, and an additional special pointer that could point to any node in the same list. The interviewer wanted a custom Node and linked-list representation rather than using Java's built-in LinkedList.

The clone needed to reproduce not only the normal left and right relationships but also every arbitrary special pointer so that no pointer in the cloned list referenced a node from the original list.

Round 2 — LeetCode 1011: Capacity to Ship Packages Within D Days

The second interviewer started with a brief introduction and then moved directly into coding. The problem was LeetCode 1011 — Capacity To Ship Packages Within D Days. Given an array of package weights and an integer D, determine the minimum ship capacity that allows all packages to be transported within D days. The interviewer also discussed the valid search range and integer-boundary details while I implemented the solution.

Want to learn more questions asked in other interview rounds? I've put up the full version at here.

Preparing for your next interview?

Chill Interview tracks recent interview experiences and recurring question patterns across top companies at here.

Interview Summary

The Instacart Analytics Engineer process covered SQL, analytics and business reasoning, data modeling, and behavioral questions. The most time-pressured round was a one-hour SQL interview with seven progressively harder questions, while the final loop tested product thinking, a store-expansion case, and marketplace-oriented data modeling.

Interview Details

Round 1 — Screening: Fundamentals and Experience

The first round focused primarily on background and role fit rather than deep technical questions. Topics included:

• Resume and previous work experience
• Projects I had owned
• Scope and responsibilities
• Collaboration with business teams
• Why Analytics Engineering
• Why Instacart

The interviewer could follow up on essentially any project listed on the resume.

Round 2 — SQL Coding

The SQL round lasted one hour and contained seven questions. The problems became progressively more difficult. Earlier questions focused on SQL fundamentals, while later questions included:

• Multiple-table joins
• GROUP BY and aggregation
• Subqueries
• CTEs
• Window functions
• Multi-step data transformations

The later questions required chaining multiple CTEs together. I reached the final question but did not have enough time to complete it. With seven problems in 60 minutes, pacing was a significant part of the round.

Want to learn more questions asked in other interview rounds? I've put up the full version at here.

Preparing for your next interview?

Chill Interview tracks recent interview experiences and recurring question patterns across top companies at here.

"This interview experience is sourced from Chill Interview"

Interview Summary

The Harvey AI Engineer onsite covered an agentic system design problem, a project-focused behavioral round, and a coding exercise around embeddings and retrieval. The system design question centered on modifying a contract according to dozens of legal rules, while the coding round required implementing vector retrieval using cosine similarity.

Interview Details

Round 1 — System Design: Multi-Agent Contract Modification

The system design problem provided:

• A contract
• Dozens of different legal rules that needed to be applied to that contract

The task was to design a system that could modify the contract according to all of those rules. A major focus was how to coordinate multiple AI agents when different rules could affect overlapping portions of the document.

The expected design direction involved assigning individual legal rules to separate sub-agents. Each sub-agent could independently determine and apply the modification required by its rule.

When multiple rule-specific edits affected overlapping sections of the contract, another agent could reconcile or merge those changes into a consistent final version. The discussion therefore focused on orchestration among specialized agents and resolving conflicting or overlapping edits.

Round 2 — Behavioral / Project Deep Dive

The behavioral round focused primarily on previous projects. The interviewer asked standard questions about past technical work and experience.

Round 3 — Coding: Embeddings and Cosine Similarity Retrieval

The coding round used a Colab-style environment. The task involved implementing an embedding and retrieval workflow based on cosine similarity. The exercise required familiarity with:

• Vector embeddings
• Similarity computation
• Cosine similarity
• Metrics associated with embedding-based retrieval
• Ranking or retrieving items based on similarity to a query embedding

A significant part of the round depended on being comfortable with cosine similarity and how it is used to compare embeddings in a retrieval system.

Preparing for your next interview?

Chill Interview tracks recent interview experiences and recurring question patterns across top companies at here.

"This interview experience is sourced from Chill Interview"

Interview Summary

The OpenAI New Grad SWE assessment contained three algorithmic problems covering functional-graph traversal, constrained path counting, and a round-based simulation. The questions became progressively more involved, with the third problem requiring careful handling of left-to-right conflict resolution when neighboring microorganisms could eat one another.

Interview Details

Question 1 — Simple Network

The first problem described a directed network where every node has at most one outgoing edge. Implement: compute(start_node_id, from_ids, to_ids). from_ids and to_ids have the same length and describe directed edges: from_ids[i] -> to_ids[i]. Starting from start_node_id, repeatedly follow the outgoing edge until reaching a node with no outgoing edge. Return that final node ID.

For example, a network could be:

from_ids = [11, 72, 34, 45, 23, 67, 91]
to_ids   = [34, 34, 45, 67, 67, 91, 56]

start_node_id = 23

The traversal is: 23 -> 67 -> 91 -> 56 so the result is: 56. Node IDs are not guaranteed to be consecutive or ordered. If traversal enters a cycle, return the ID of the last node visited immediately before following an edge that would close the loop. A node never points directly to itself. Constraints included: 1 < node_id < 5000

Want to learn more coding questions of this OA? I've put up the full version at here.

Preparing for your next interview?

Chill Interview tracks recent interview experiences and recurring question patterns across top companies at here.

"This interview experience is sourced from Chill Interview"

Interview Summary

The Netflix Research Engineer phone screen has a somewhat different format from more traditional Netflix interviews. The hour was split evenly between ML fundamentals and a practical code-review exercise based on a feature pipeline pull request.

The ML portion focused on Transformer fundamentals, while the practical section tested whether I could identify production risks in code whose existing tests already passed.

Interview Details

Part 1 — ML Fundamentals

The first 30 minutes contained three ML questions:

• What is a KV cache?
• What is attention, and how are Query, Key, and Value computed?
• What is the difference between L1 and L2 normalization?

Part 2 — Practical Coding: Feature Pipeline Code Review

For the second half, the interviewer provided a pull request containing feature-pipeline code. All existing test cases were already passing. Instead of implementing a new feature, I was asked to review the code and identify problems that could appear if the PR were deployed to production.

I found several edge cases, but the interviewer appeared to be looking for additional production-level concerns beyond the issues I identified. The discussion then moved to feature serving.

The interviewer asked how these features should be served when different features have different freshness or real-time requirements. This part of the interview focused less on traditional algorithmic coding and more on reviewing unfamiliar production code, identifying operational risks, and reasoning about online feature-serving behavior.

Preparing for your next interview?

Chill Interview tracks recent interview experiences and recurring question patterns across top companies at here.

"This interview experience is sourced from Chill Interview"

Interview Summary

The TikTok New Grad process included a coding round followed by a system design interview. The coding question focused on graph traversal and topological sorting, while the design round asked for a high-concurrency ticket booking platform with particular emphasis on traffic spikes and preventing overselling.

Interview Details

Round 1 — Coding: Graph / Topological Sort

The first round was a coding interview. The problem was similar to LeetCode 207 — Course Schedule, with the main concepts centered around graphs and topological sorting. Relevant techniques included:

• BFS / DFS
• Dependency graphs
• Topological sorting

The overall difficulty was moderate.

Round 2 — System Design: Ticket Booking System

The second round asked me to design a ticket booking system. The interviewer focused heavily on two areas.

• Traffic Spikes During Ticket Release When tickets become available, a very large number of users may submit requests at nearly the same time. The discussion covered mechanisms such as:
  • Load balancing
  • Queue or waiting-room systems
  • Rate limiting
  • Protecting backend services and databases from sudden traffic spikes
• Inventory and Concurrency The second major topic was ensuring that the same ticket could not be purchased by multiple users. The discussion included: At the time of the report, the interview process was still waiting for the next update from recruiting.
  • Inventory updates
  • Reservation / hold flows
  • Releasing held tickets after payment timeout
  • Consistency during concurrent purchases
  • Preventing overselling
  • Cache and database behavior under high contention

Preparing for your next interview?

Chill Interview tracks recent interview experiences and recurring question patterns across top companies at here.

"This interview experience is sourced from Chill Interview"

Interview Summary

The OpenAI SWE virtual onsite covered ChatGPT system design, a custom indexed-sequence data structure, and debugging an existing Python job scheduler codebase. The questions were mostly unfamiliar rather than standard interview problems, with follow-ups around SSE vs. WebSocket, rendering long conversations, data-structure performance, testing, and asynchronous job execution

Interview Details

Round 1 — System Design: ChatGPT

The system design question was to design a simplified version of ChatGPT. At the beginning, the interviewer explicitly said not to focus on large-scale architecture and that persistence was not required.

The discussion later moved into several implementation-level follow-ups. One question was why the response-streaming path should use Server-Sent Events (SSE) rather than WebSocket.

The interviewer also asked about the frontend side of the product: as a conversation becomes very long, how could the client optimize rendering so that displaying a large chat history remains responsive?

Round 2 — Coding: Indexed Sequence With Checkpoints

The first coding problem asked me to implement a simplified ordered sequence supporting:

add(index, value)
get(index)

• add(index, value) inserts a string at the specified position. The element previously at that position and everything after it shift one position to the right.
• get(index) returns the value stored at the requested index.

Initially, I interpreted “vector store” as something related to vector databases or embeddings. The intended meaning was actually closer to a C++ std::vector or Java ArrayList: an ordered dynamic sequence with integer-indexed access. A straightforward linked-list implementation was considered too slow because get(index) could require traversing from the beginning of the list.

Want to learn more questions asked in other interview rounds? I've put up the full version at here.

Preparing for your next interview?

Chill Interview tracks recent interview experiences and recurring question patterns across top companies at here.

I went through a bunch of recent Amazon SWE interview reports from Blind, LeetCode Discuss, Glassdoor, Reddit, and other public sources.

Not my personal interview experience — just some patterns that kept showing up.

And honestly, the biggest surprise wasn’t the onsite. It was the OA.

The OA is more than just two coding problems

A lot of people prepare for Amazon assuming: solve two coding questions → get interview. But depending on level, the assessment can include much more than that.

For SDE II, for example, Amazon’s current prep material includes:

• two coding questions
• system design scenarios
• a Work Style survey based on Leadership Principles

And candidate reports for new grad roles frequently describe additional behavioral / work simulation components.

So one of the biggest mistakes is preparing only for algorithms and treating everything else as a formality. It isn’t.

Different levels seem to get very different processes

This is another thing I’d watch out for. A New Grad interview guide may not be very useful if you’re interviewing for SDE II.

SDE II candidates should expect system design much earlier in the process, while new-grad pipelines tend to emphasize coding and behavioral assessment more heavily.

Before preparing, I’d make sure you know which process your exact role and level is using.

Coding is still very Amazon

Medium-level problems still seem to dominate, but there are a lot of Amazon-flavored variations:

• servers
• warehouses
• parcels
• scheduling
• graphs
• top-K
• caches
• dependency graphs

Some recurring topics across reports include:

• Top K Frequent Elements
• Course Schedule
• LRU Cache
• graph traversal
• weighted shortest paths
• heap / priority queue problems
• trie / search-style questions

The exact LeetCode number matters less than being able to recognize the underlying pattern after Amazon wraps it in a completely different story.

I’ve also seen more reports involving debugging or modifying an existing codebase, which is a very different skill from solving a clean LeetCode prompt from scratch.

But LP might still be the most “Amazon” part of the interview

This is probably the part people from other big tech companies underestimate the most. Leadership Principles don’t live in one isolated behavioral round.

They can show up throughout the loop. You might finish a coding discussion and immediately get: Tell me about a time you disagreed with your team.

Then five minutes later:

• What specifically did you do?
• Why did you make that decision?
• What was the measurable impact?
• What would you do differently now?

The recurring advice from candidates is pretty consistent:

Don’t prepare generic STAR stories.

Prepare stories with enough depth that someone can keep asking “why?” for ten minutes without the story falling apart. And be very clear about “I” vs “we.”

The interviewer needs to understand what you personally owned. If I were preparing, I’d probably have around 8–12 strong stories and map each one to multiple LPs:

• Ownership
• Dive Deep
• Deliver Results
• Disagree and Commit
• Bias for Action
• Customer Obsession
• Learn and Be Curious

The stories don’t need to be perfect. They need to be real enough that you can survive follow-up questions.

System design also feels very Amazon

The reported questions tend to have a strong operational flavor:

• job schedulers
• notification systems
• inventory / stock updates
• Kindle-style systems
• monitoring platforms
• exactly-once processing
• file systems

Less: “Draw Twitter.”

More:

• “What happens when this fails halfway through?”
• “How do you retry safely?”
• “Where does the source of truth live?”
• “Is this decision reversible?”

That last one is very Amazon. Thinking explicitly about one-way vs two-way door decisions is actually a useful mental model when explaining design tradeoffs.

My biggest takeaway

Amazon prep in 2026 feels like three separate interviews you need to prepare for at the same time:

• Coding: recognize patterns quickly and write correct code.
• System design: think about reliability, operations, and failure modes.
• Leadership Principles: explain what you actually did, why you did it, and what happened afterward.

Being strong at only one of the three probably isn’t enough. I’ve been collecting recent Amazon interview experiences, recurring questions, and role-specific interview patterns at Chill Interview if you’re currently preparing.

And if you interviewed with Amazon recently, I’d especially love to hear whether your OA matched the current format — the differences between New Grad, SDE II, and senior roles seem bigger than people realize.

"This interview experience is sourced from Chill Interview"

Interview Summary

The Rippling Senior Backend onsite consisted of an AI-assisted coding round, a hiring manager interview, and a system design round. The coding exercise focused on task scheduling and how effectively I collaborated with an AI assistant, while the system design round asked for a Google News-style aggregation platform that pulled articles from external publishers and generated personalized feeds.

Interview Details

Round 1 — AI-Assisted Coding: Task Scheduler

The first round lasted 60 minutes and explicitly allowed AI assistance. The interviewer explained that an AI assistant was already available in the environment and that I should use it similarly to how I would use AI in day-to-day engineering work, while still making the important decisions myself.

The input consisted of tasks with fields such as:

description
due_date
priority
completed
parent_id

The task involved several steps:

• Deduplicate tasks using (description, due_date)
• Remove completed tasks
• Sort the remaining tasks according to the specified priority rules
• Ensure child tasks appear immediately after their parent task

The core algorithm was relatively straightforward. After sorting, the parent-child hierarchy could be expanded into the required final ordering. A major part of the evaluation appeared to be how the candidate interacted with the AI assistant rather than only whether the final code worked. I barely used the provided AI assistant during the round, which I later felt may have hurt the evaluation.

Round 2 — Hiring Manager

The hiring manager round lasted about 60 minutes. The interviewer had been at Rippling for several years and had worked across areas including HRIS Platform and Device Management.

Questions included:

• Tell me about yourself.
• What project are you most proud of?
• How did you implement idempotency?
• How did you define and monitor SLA?
• Tell me about a technical approach you changed midway through a project.
• Tell me about a design that another engineer challenged.
• What practices from your current company would you want to keep?
• What would you prefer to leave behind?
• Why Rippling?

The project deep dive included substantial follow-up on technical details. The interviewer also discussed how Rippling evaluates senior engineers after I asked about the performance rubric.

Want to learn more questions asked in other interview rounds? I've put up the full version at here.

Preparing for your next interview?

Chill Interview tracks recent interview experiences and recurring question patterns across top companies at here.

"This interview experience is sourced from Chill Interview"

Interview Summary

The EliseAI Research Scientist process included an initial team conversation, a coding interview based on Tic-Tac-Toe, and a 24-hour ML take-home followed by a 30-minute research presentation. The take-home combined supervised learning for lease-renewal prediction with unsupervised or representation-based analysis for categorizing why tenants chose not to renew.

Interview Details

Round 1 & 2 — Team Conversation + Coding: Tic-Tac-Toe Variant

The first round was a 30-minute conversation with a member of the team. The coding interview used a Tic-Tac-Toe variant. The problem was related to several common LeetCode Tic-Tac-Toe questions:

Round 3 — Take-Home ML Assignment + Research Presentation

The final stage was a take-home assignment with a 24-hour completion window, followed by a 30-minute presentation. The overall objective was to model whether residents were likely to renew their leases. Two main sources of data were provided:

1. JSON files containing 1,000 conversations with tenants considering lease renewal

2. SQLite tables:
   residents
   maintenance_history
   renewal_offers

Both the conversational data and database data were split into training and test sets.

Want to learn more questions/follow-ups asked in the interview? I've put up the full version at here.

Preparing for your next tech interview?

Chill Interview tracks recent interview experiences and recurring question patterns across top companies at here

"This interview experience is sourced from Chill Interview"

Interview Summary

The Google SWE AI/ML process included separate ML and behavioral interviews followed by two onsite coding rounds. T

Interview Details

Technical Round — Machine Learning

The ML round focused primarily on fundamental ML concepts. The specific questions were closely related to the interviewer’s own technical background. When I was unclear on an answer, the interviewer provided hints and, in some cases, explained the expected concept directly.

Technical Round — Behavioral

The behavioral interview contained relatively standard questions. There were no major questions around conflict, failure, or difficult collaboration scenarios.

Onsite Coding 1 — Maximum Value From Two Array Positions

The first onsite coding problem involved an array. The task was to choose two indices and maximize a value defined using the sum between those positions and the internal subarray between them. After simplifying the expression, the problem effectively reduced to identifying the best two endpoint values.

I first clarified the problem and walked through several examples with the interviewer. We discussed a brute-force approach, prefix sums, and then a more direct mathematical interpretation before implementing the final version. The interviewer briefly asked about time and space complexity afterward.

Onsite Coding 2 — Employee Shift Intervals

The second coding problem was a variant related to LeetCode 2402 — Meeting Rooms III. The input contained employee information such as:

employee_id
employee_name
shift_start
shift_end

The task was to return information for each time interval showing which employees were currently on duty and how many employees were active during that interval. The time-based processing naturally involved ordering shift boundaries and maintaining active employees as intervals started and ended.

After the implementation, the interviewer asked for a detailed time and space complexity breakdown. The discussion went beyond the overall complexity and covered individual operations such as:

• Heap insertion
• Heap removal
• Sizes of intermediate data structures
• How different input dimensions contributed to the final complexity

The interviewer wanted the complexity expressed precisely using multiple variables, with each variable clearly defined in comments.

Communication was a major part of the technical interviews. Clarifying requirements, constructing examples, explaining the approach while coding, and carefully analyzing complexity all received substantial attention during the onsite.

Preparing for your next tech interview?

Chill Interview tracks recent interview experiences and recurring question patterns across top companies at here

"This interview experience is sourced from Chill Interview"

Interview Summary

The DatologyAI process included two coding interviews. The first focused on implementing a text editor with increasingly complex cursor movement, while the second provided a simplified Spark RDD abstraction and asked me to implement additional transformations using the existing APIs.

Interview Details

Round 1 — Text Editor

The task was to implement a basic TextEditor supporting three operations:

type_in(char)
backspace()
__str__()

• type_in(char) inserts a character at the current cursor position.
• backspace() removes the character immediately before the cursor.
• __str__() returns the current text while displaying the cursor using |.

The interviewer then added two follow-ups. First, support: move_cursor(direction) so the cursor could move left and right through the text. The second follow-up extended cursor movement to support moving up and down across multiple lines.

Round 2 — Mock Spark RDD

The interviewer provided a lightweight version of a Spark-style RDD abstraction. The available operations included:

flatMap(func)
groupByKey()
union(other_rdd)
collect()

The underlying class conceptually looked like:

pythonclass SimpleRDD:
    def __init__(self, items):
        self.items = items

    def flatMap(self, func):
        ...

    def groupByKey(self):
        ...

    def union(self, other_rdd):
        ...

    def collect(self):
        ...

Want to learn more questions/follow-ups asked in the interview? I've put up the full version at here.

Preparing for your next tech interview?

Chill Interview tracks recent interview experiences and recurring question patterns across top companies at here

I’ve been going through recent Meta interview reports from Glassdoor, Blind, LeetCode Discuss, and other public sources.

Not my personal interview experience — just a summary of patterns I’ve been seeing across 2026 reports.

The biggest change is obviously the AI-enabled coding round.

Instead of the traditional “here’s a LeetCode problem, start coding” format, some candidates have reported a CoderPad environment with an editor, file browser, and access to AI models.

The interesting part is that this round doesn’t seem to be about who can generate code the fastest.

It’s much more about whether you can:

• give the AI useful instructions
• understand the code it generates
• catch incorrect assumptions
• write tests instead of blindly trusting the output
• optimize the solution when requirements change

In other words, using AI is allowed, but blindly copying AI-generated code is probably the worst possible strategy.

Traditional coding rounds are still very much alive though.

The usual pattern still seems to be roughly two problems in ~35–40 minutes, so speed matters a lot. A solution you can finish comfortably in 50 minutes during practice may be very different under interview pressure.

A few coding topics also seem to show up repeatedly in recent reports:

• Binary Tree Vertical Order Traversal
• Lowest Common Ancestor
• Simplify Path
• Range Sum of BST
• Two Sum / stock-style questions as warmups
• stack / expression parsing
• streaming-style problems

One trend I find more interesting than the exact question list:

Meta seems to be using more variations of familiar problems rather than simply repeating the exact LeetCode prompt.

So memorizing the solution to a tagged problem is becoming less useful than understanding why the solution works and being able to adapt it quickly.

For system design, the questions still tend to be closely related to large consumer products:

• News Feed
• Messenger
• Instagram Stories
• notification systems
• recommendation / friend suggestion systems

And behavioral is something I definitely wouldn’t leave until the last minute.

Recent candidate reports continue to describe pretty deep questioning around impact, conflict, ownership, and project decisions, especially at senior levels.

If I were preparing for Meta right now, I’d probably focus on three things:

1. Know the common coding patterns extremely well

Not just the final solution. Be able to recognize the pattern and adapt it under time pressure.

2. Practice with a timer

Two mediums individually may feel easy. Two mediums plus explanation, debugging, and follow-ups in ~40 minutes is a different problem.

3. Practice coding with AI as a reviewer, not as an answer generator

Have AI generate something, then force yourself to review it, find edge cases, test it, and explain every important decision.

The interesting question is whether this becomes the new normal across big tech.

If engineers are increasingly expected to work with AI every day, testing whether someone can supervise AI-generated code may eventually be more useful than testing how fast they can type out a memorized algorithm.

Have you interviewed with Meta recently? How was your experience with the AI-enabled coding round?

I’ve started an ongoing thread on Chill Interview to collect recent experiences and insights from candidates. Would love to hear yours.

Preparing for your next tech interview?

Chill Interview tracks recent interview experiences and recurring question patterns across top companies at here.

"This interview experience is sourced from Chill Interview"

Interview Summary

The Netflix process stretched across three stages and included problem solving, system design, hiring manager, and partnership interviews. Technical topics included duplicate detection in viewing history, an ML job scheduler, a movie-playlist data structure with score updates and repeat cycles, multithreading, and a team-specific system design.

Interview Details

Round 1 — Problem Solving: Viewing History Duplicate Detection The first technical screen involved detecting duplicates in viewing history. The problem had three parts. The first two were relatively straightforward, while the third required a bucket-sort-style idea and was more involved.

Round 2 — Hiring Manager The hiring manager discussion focused primarily on my previous experience. One behavioral question asked me to describe one of my weaknesses.

Round 3 — System Design: ML Job Scheduler The first virtual-onsite system design round asked me to design an ML Job Scheduler. This round went well overall.

Round 4 — Problem Solving: Movie Playlist The coding problem involved maintaining a movie playlist where each movie had a score that could change over time. The system needed to support score updates while enforcing an important playback rule: during one cycle, each movie could only be returned once. After every movie had been exhausted, a new repeat cycle could begin.

Round 5 — Partnership Interview The Partnership round was conducted by a manager from a collaborating organization. The interview was primarily behavioral and focused on working across teams and handling collaboration scenarios. After this stage, HR told me that I'll move forward to the next stage.

Round 6 — Team-Specific System Design The next system design round involved a problem directly related to the team’s work. The scope of the problem was broad, and I spent too much time on areas that the interviewer considered less important. The interviewer reminded me about the remaining time during the round. Although I was able to respond to most of the technical questions, the recruiter later explained that the main negative feedback was that I did not complete the overall design within the allotted time.

Round 7 — Hiring Manager Behavioral The final interview was another hiring manager round. This conversation focused mostly on standard behavioral questions and previous experience. After completing the final stage, I received a Not Moving Forward decision. I later spoke with the recruiter to get additional feedback on the process.

Preparing for your next interview?

Chill Interview tracks recent interview experiences and recurring question patterns across top companies at here

"This interview experience is sourced from Chill Interview"

Interview Summary

The 45-minute technical phone screen consisted of one grid-based pathfinding problem involving a robot with limited battery capacity and charging stations. The solution needed to optimize three objectives in priority order: number of charging stations visited, required initial battery capacity, and total path length.

Interview Details

Coding — Robot Pathfinding With Charging Stations

The problem provided a 2D grid representing an environment through which a robot must travel from a starting cell to a destination. Each grid cell could be one of the following:

S = Starting cell
D = Destination cell
. = Traversable cell
C = Charging cell
# = Blocked cell

The robot could move up, down, left, or right to an adjacent traversable cell. Each move consumed one unit of battery. Whenever the robot entered a charging cell, its battery was immediately restored to its maximum capacity.

The task was to find an optimal path from S to D according to the following priorities, applied lexicographically:

1. Minimize the number of charging cells visited.
2. Among paths using the minimum number of charging cells, minimize the initial battery capacity required.
3. If multiple paths were still tied, minimize the total number of moves.

Preparing for your next interview?

Chill Interview tracks recent interview experiences and recurring question patterns across top companies at here

"This interview experience is sourced from Chill Interview"

Interview Summary

The interview process covered grid traversal, path optimization, computational geometry, dynamic programming, and range-query optimization. Several questions began with familiar algorithmic ideas but added significantly harder follow-ups, including maximizing safety from an adversary, finding arbitrary-orientation rectangles, and preprocessing repeated range queries for O(1) lookup.

Interview Details

Phone Interview 1 — Grid Paths and Maximum Safety

The warm-up used an N x N grid containing a start position S, a destination T, and impassable water cells. Movement was allowed horizontally and vertically. The task was to determine whether any valid path existed from S to T.

The main question expanded the same grid scenario. A mouse starts at S and wants to reach cheese at T. The grid also contains water cells and a cat at position C. The mouse can move horizontally or vertically through land cells. The task was to find a path from S to T that maximizes the minimum Manhattan distance between any point on the path and the cat.

Phone Interview 2 — Googlyness

The behavioral round included questions such as:

• Why Google?
• What would you do if you did not pass this interview process?
• If you were a manager, what would you expect from your own manager?
• How would you apply those expectations when managing others?
• How would you balance project delivery, leadership expectations, employee interests, and situations requiring extra effort?

Onsite Round 1 — Maximum-Area Rectangle

Given a collection of points in a two-dimensional plane, find the largest-area rectangle that can be formed using those points. The rectangle did not need to have sides parallel to the coordinate axes. The problem was similar in structure to LeetCode 963 — Minimum Area Rectangle II, except the objective was to find the maximum rectangle area instead of the minimum.

Onsite Round 2 — Job Scheduling and Range Queries

The first question was LeetCode 1235 — Maximum Profit in Job Scheduling. Each job had:

startTime
endTime
profit

The task was to select non-overlapping jobs while maximizing the total profit. The second question involved an array and a query range. Given a specified interval, determine whether the elements within that range are unique.

The interviewer then added repeated-query follow-ups:

• How would the design change if many different range queries needed to be answered?
• What information could be precomputed to make those queries faster?
• Implement preprocessing with an efficient overall complexity so that each subsequent range query could be answered in O(1) time.

Preparing for your next interview?

Chill Interview tracks recent interview experiences and recurring question patterns across top companies at here

Problem Description

There are N players, and each player holds exactly three playing cards.

A card contains a rank and a suit. For example:

AH
TC

represents the Ace of Hearts and Ten of Clubs.

Card ranks are ordered as:

2, 3, 4, 5, 6, 7, 8, 9, T, J, Q, K, A

The program receives a mode, the number of players, and three cards for each player.

The task is to classify every player's hand and determine the winner.

Mode 1 — Ignore Suits

When mode = 1, suits do not matter.

Hand strength from strongest to weakest is:

Three of a Kind
Pair
High Card

Mode 2 — Include Flushes

When mode = 2, flushes are also considered.

Hand strength from strongest to weakest is:

Three of a Kind
Flush
Pair
High Card

A flush means all three cards have the same suit.

Tie-Breaking Rules

• For Three of a Kind, compare the repeated rank.
• For a Flush, sort all three ranks in descending order and compare them lexicographically.
• For a Pair, compare the pair rank first and then the remaining kicker.
• For High Card, sort all three ranks in descending order and compare them lexicographically.

If every comparison value is identical, the players tie.

Input Format

The input follows the general form:

mode N
card1 card2 card3
card1 card2 card3
...

Each group of three cards represents one player's hand.

Output Format

For each player, output the classified hand and the three cards:

Player i: <hand-type> <card1> <card2> <card3>

After all players have been evaluated, output the winner:

Winner: Player k

If multiple players share the strongest hand with identical tie-breaking values:

Winner: Tie (Players i,j,...)

Want to practice more real & exact coding questions asked in interviews, I've put up the question bank at here.

Preparing for your next interview?

Chill Interview tracks recent interview experiences and recurring question patterns across top companies at here.