In February 2026, a Senior SDE candidate who calls herself Emily walked into Uber’s final on-site loop and drew a hexagonal H3 grid on the whiteboard. She explained a surge pricing engine ingesting millions of GPS pings per second.
The interviewer nodded, then asked the follow-up that ended her loop: “How do you handle surge pricing across city boundaries where hexagonal zones overlap different regulatory regions?” She froze.
Three days later, Emily got a six-month re-apply notice. The recruiter’s debrief used a phrase that has become Uber’s calling card after its first $1B-plus quarter of GAAP operating income in Q3 2024 — “didn’t demonstrate sufficient depth in cross-region system complexity and edge case handling.” (Source: Emily’s Feb 2026 postmortem.)
“Didn’t demonstrate sufficient depth in cross-region system complexity and edge case handling.” — Uber recruiter debrief, Feb 2026
What follows is not the generic “Top 50 Uber interview questions” listicle. It is a guide built around two named candidate postmortems with verbatim 2024-2026 question text.
The article is calibrated for the rubric senior Uber interviewers actually score against right now: cost-conscious system design, multi-network marketplace orchestration, and the unanimously-positive debrief bar that turns one wobbly round into a rejection.
In this article, we’ll cover the following 15 questions:
- Walk me through finding the largest 1-bordered square in a grid
- Find the longest subarray where any two pair difference is at most K
- Find the minimum characters to insert to make a string a palindrome
- Schedule n trains across m platforms (the machine coding round)
- Design Uber's real-time surge pricing engine
- Design the dispatch service that matches a rider to a driver
- Design a popularity-ranked merchandise browse service at 50M items, 10K RPS
- How would you extend the rider app to dispatch Waymo and human drivers simultaneously?
- How would you design Michelangelo's feature store for 10,000+ shared features?
- When does a feature need near-real-time compute vs batch precompute?
- Walk through Michelangelo's model-deployment safety levels
- Tell me about a time you disagreed with a technical decision on your team
- Tell me about a time the business problem wasn't clearly defined
- Describe a time you had to make a quick decision under pressure
- How did you manage conflicting priorities across stakeholders?
How Uber interviews shifted after the 2024 first-profit milestone
Uber’s third quarter of 2024 was the first time in the company’s history that it delivered over $1 billion in GAAP operating income in a single quarter — $1.061B, up 169% year-over-year, on Gross Bookings of $40.97B and 2.87B trips, per the Oct 31, 2024 SEC earnings release. CEO Dara Khosrowshahi framed the shift bluntly in Fortune’s Sept 2024 culture-change profile: “The bigger you get, the more shots you can afford to take. Protect the hunger, not the record.” Internally, this rewired what engineering interviewers score.
Three concrete changes show up in 2024-2026 loops:
- System design rubrics weight cost-of-design at scale heavily. Interviewers actively probe what a candidate’s architecture would cost at 10x volume, not just whether it scales.
- Behavioral interviews calibrate against Uber’s eight refreshed values that replaced Travis Kalanick’s “always be hustlin'” set. The Risk-Conscious Founder Mentality is the value interviewers test for most.
- The rider app now dispatches multiple networks simultaneously — Waymo autonomous vehicles in Austin and Atlanta since early 2025, plus human drivers, plus Uber-managed fleet ops. This adds a multi-marketplace orchestration question to senior platform-engineer loops that didn’t exist in 2022.
If you prepped for Uber two years ago, your mental model still works for ~70% of the loop. The remaining 30% — the parts where senior offers are made or lost — has changed substantially. The rest of this guide walks through both.
The Uber onsite loop: 4-5 rounds, two days, and the unanimous-debrief bar
The Uber onsite interview loop is 4 to 5 rounds, each 60 minutes, typically spread across two consecutive days and mostly virtual since 2022. The pipeline before onsite runs: recruiter screen → optional CodeSignal online assessment (4 easy-to-medium questions) → an eliminatory DSA phone screen.
Candidates who clear the phone screen are scheduled for the on-site loop. It currently runs a coding round, a machine-coding / LLD round, a system design round, a behavioral / hiring-manager round, and — for Senior, Staff, and above — a Technical Retrospective deep-dive on a past project. Sources for the sequence: Exponent’s 2026 SWE guide and the Dec 2024 L4 SDE2 candidate postmortem from Laxman Kumar Meghwal.
The detail that catches candidates off guard is the unanimous-positive-debrief rule. Laxman’s writeup states it directly: in the post-loop committee meeting, “all feedback must be unanimously positive” for an offer to issue.
One weak signal — even from an interviewer the candidate felt ran a peripheral round — collapses the loop. This is why Emily’s strong behavioral round in Feb 2026 could not save the wobbly system-design follow-up.
“The committee bar is not majority strong; it is no detected weakness.”
Practical implications follow from that bar:
- Pacing matters most. A candidate who burns the first 20 minutes of a DSA round on the brute-force discussion and then rushes the optimal solution lands a “concerns about time management” note from one interviewer, and the loop ends.
- Cross-question discipline matters next. In Laxman’s machine-coding round, he started writing code immediately to chase a working solution and never surfaced corner cases with the interviewer. That single round took down an otherwise viable loop.
The Uber loop rewards candidates who give every interviewer a clean signal across all rounds, even at the cost of depth in any one round.
Coding round and machine coding: the working-code-first failure mode
Uber’s coding rounds split into two distinct evaluations: a pure DSA round (one to two hours of optimised algorithm work, leetcode-medium to leetcode-hard) and a separate machine-coding / LLD round (one hour, OOP design + working code + design patterns). Candidates routinely conflate the two, and that conflation is the single most-cited failure mode in postmortems. Below are four questions reported verbatim by named 2024-2025 candidates, with what the interviewer is actually scoring on each.
Walk me through finding the largest 1-bordered square in a grid
Concept: dynamic programming on grids | Difficulty: senior | Stage: eliminatory DSA phone screen
Direct answer: The largest 1-bordered square problem expects you to walk through three solution tiers before writing code. Tier one is the O(N⁴) brute force: for every cell pair, check whether every border cell is a 1. Tier two is the O(N³) optimisation: precompute, for each cell, the length of the consecutive 1s extending to its left and above, then iterate over candidate top-left and bottom-right corners and use the precomputed lengths to verify borders in constant time. Tier three is the optimal answer Uber’s interviewer wanted: still O(N³) on the time axis but with cleaner state. Reference: LeetCode 1139.
What they’re really probing: Can you verbalise the brute-force complexity before coding, accept a hint without resetting your scaffold, and write the optimal solution with passing test cases inside 45 minutes? Laxman’s Dec 2024 phone screen ran exactly this script.
The deeper pattern the interviewer watches for is whether you treat optimisation as a search through complexity tiers — not as a binary “brute or optimal” leap. Junior candidates jump to the optimal idea and write buggy code; senior candidates articulate the path.
That articulation is the signal. Cite: Laxman Kumar Meghwal, L4 Dec 2024.
Find the longest subarray where any two pair difference is at most K
Concept: sliding window with monotonic deques | Difficulty: senior | Stage: onsite DSA
Direct answer: The longest continuous subarray with absolute diff at most K problem has a clean O(N) solution using two monotonic deques — one tracking the rolling maximum, one tracking the rolling minimum. You expand the right pointer while max minus min stays within K, and contract the left pointer whenever the constraint breaks. The expected complexity articulation walks from O(N⁴) brute force through O(N²) with a check on every subarray to the O(N) two-deque solution. State this complexity ladder out loud before writing code — Uber interviewers score the verbal walk as much as the final implementation. Reference: LeetCode 1438.
What they’re really probing: Whether you recognise the monotonic deque pattern as separate from a standard two-pointer sliding window. Most candidates land the brute force and the two-pointer, then stall on the deque transition.
The deque pattern is the senior signal: the interviewer is looking for the move from “sliding window with re-scan” to “sliding window with O(1) extremum lookup.” Practitioners who completed Striver’s A-Z DSA Sheet (recommended by Laxman as sufficient prep) will have seen this pattern by name. Without it, expect to grind through O(N log N) heap-based approaches that the interviewer will accept but not score as senior.
Find the minimum characters to insert to make a string a palindrome
Concept: 2D dynamic programming | Difficulty: mid-to-senior | Stage: onsite DSA
Direct answer: The minimum insertions to form a palindrome reduces to the longest palindromic subsequence problem — the answer equals string length minus LPS length. The clean dynamic-programming solution iterates over substring lengths from 2 to n, comparing characters at positions i and j; equal characters extend the inner-substring answer, unequal characters take the minimum of skipping the left or right character plus one insertion. Time complexity O(N²), space O(N²) which can be reduced to O(N) with row-rolling. State the LPS reduction explicitly in the first two minutes — that verbal move is what separates the senior signal from a junior who treats this as a fresh problem. Verified by Exponent’s Uber SWE question bank, asked roughly five months before publication.
What they’re really probing: Recognition that this is a transformation of LPS, not a fresh problem. Senior candidates state the transformation explicitly within the first two minutes. Source: Exponent Uber question bank.
Watch for the common error of building a 1D DP that double-counts insertions when characters partially match. The recurrence has to be expressed on substring boundaries, not character positions, and that distinction is where mid-level candidates stumble.
Schedule n trains across m platforms (the machine coding round)
Concept: priority queues + LLD design patterns | Difficulty: senior | Stage: onsite machine coding / LLD
Direct answer: The train-platform scheduler machine coding problem is structurally equivalent to LeetCode Meeting Rooms III. The clean implementation uses two priority queues — one min-heap on available platforms keyed by platform-free time, one min-heap on scheduled trains keyed by departure time. On a new train arrival, pop expired scheduled trains back into the available pool, then assign the lowest-numbered available platform; if none is free, the next-to-finish platform is chosen and the train’s arrival is delayed. Three APIs typically required: scheduleTrain(arrivalTime, duration), handleWait(arrival), and getTrainAt(platform, time). Surface clarification questions about platform numbering and tie-breaking rules before writing code — interviewers score that interaction.
What they’re really probing: Whether the candidate treats machine coding as “DSA with extra English” rather than overthinking it as a Strategy-pattern OOP exercise. Laxman’s loop ended on this round because he started writing without first surfacing corner cases with the interviewer; his retrospective advice is direct: “do not overthink of it as LLD and machine coding and using design pattern, once working code is done, design pattern, solid principle u can inject in your working code.“
The interviewer wants to see clarification questions first, then a working minimal solution, then a refactor pass that introduces the Factory or Strategy pattern over a clean code skeleton. Working code that passes the test cases is the floor; design pattern polish is the ceiling.
Candidates who chase the ceiling without securing the floor end the loop here. For broader senior-level prep across companies, our senior software engineer interview prep guide covers the LLD-versus-DSA boundary in depth.
System design: surge pricing, dispatch, and the cross-region follow-up that killed Emily’s L5
Uber’s system design round is the highest-variance interview in the loop. Pass rates correlate less with knowing the canonical “design Uber” answer and more with handling the second-order follow-up questions — failure modes, regulatory edges, cross-region consistency, multi-network orchestration. Below are the four prompts that named candidates report verbatim from 2024-2026 loops, with what each is actually testing.
Design Uber’s real-time surge pricing engine
Concept: streaming systems + geospatial indexing | Difficulty: senior | Stage: onsite system design
Direct answer: The surge pricing engine ingests driver GPS pings and rider requests, maps each event to an Uber H3 hexagonal cell at resolution 7 (roughly 5km² hexagons with 64-bit IDs), maintains sliding-window supply and demand counters per hex in Redis, and runs an Apache Flink streaming job every 30 to 60 seconds that computes a multiplier per hex. The multiplier writes to a Redis pricing cache that the Pricing Service reads at request time. The naive formula is max(1.0, demand_count / (supply_count * target_ratio)); the senior version blends supply across the six neighbouring hexes returned by H3’s kRing(hex_id, 1) function and layers historical baselines plus external signals (weather, events). Failure mode: stale-cache TTL of 120 seconds, dead-letter queue for failed Flink events, circuit breaker that defaults to 1.0x after three minutes of calculator downtime.
What they’re really probing: Knowledge of Uber’s open-source H3 library, command of streaming-system failure modes (Flink checkpoints, watermark handling, DLQ patterns), and — crucially — the second-order follow-ups: cross-region regulatory caps, hex boundaries that overlap multiple cities, fallback semantics when a region bans surge entirely.
The verbatim interviewer framing from Emily’s Feb 2026 Senior SDE loop ran: “We need a system that can calculate dynamic pricing for every hexagonal zone in a city in near real-time. It should consider current ride requests, available drivers, historical demand patterns, and external factors like weather or events. The multiplier must update at least every 60 seconds.”
Her diagram landed with the interviewer until the follow-up arrived:
“How do you handle surge pricing across city boundaries where hexagonal zones overlap different regulatory regions? NYC caps at 2.5x, some cities ban it entirely. Your Flink job is processing globally — how does it know which regulatory rules to apply per hex?”
The recruiter’s debrief — “didn’t demonstrate sufficient depth in cross-region system complexity and edge case handling” — translates plainly: the happy path gets you L4 strong; the cross-region edges get you L5. Source: Emily, Feb 2026. For comparable big-tech design rubrics, see our Google’s design interview format guide.
Design the dispatch service that matches a rider to a driver
Concept: marketplace matching + spatial query | Difficulty: senior | Stage: onsite system design
Direct answer: The dispatch service sits between the rider request stream and the driver fleet. Drivers continuously publish location to a geospatial index (sharded H3 hex buckets in Redis or a dedicated service like Uber’s published Ringpop-based dispatch); rider requests query the index for the K nearest drivers in candidate hexes, then a matching algorithm scores each candidate on ETA, driver utilisation, surge spread, and acceptance probability. The winning driver gets a push notification via Uber’s Fireball real-time push platform. Latency budget: P95 under 500ms end-to-end on match decisions. Marketplace-aware ML scoring runs on top of the base matcher for batched optimisation across multiple simultaneous riders in dense hexes.
What they’re really probing: Whether you treat dispatch as a pure shortest-driver lookup or as a marketplace optimisation problem. Senior candidates explicitly trade off rider wait time against driver utilisation against surge stability; junior candidates greedy-match the nearest driver and ship.
The interviewer expects you to surface the false-positive problem: greedy matching produces empty-driver-bunching in low-demand hexes because no rider arrives while the second-best driver is held in reserve. The fix is batched matching every two to three seconds with a Hungarian or auction-style optimisation. This pattern appears in Uber’s published simulated marketplace work — a citation that signals you have read the actual engineering blog.
Design a popularity-ranked merchandise browse service at 50M items, 10K RPS
Concept: batch + serving split, offline scoring | Difficulty: senior | Stage: onsite HLD
Direct answer: The popularity-ranked merchandise service at 50 million items across 10,000 categories with a p99 of 10,000 RPS requires the canonical batch-versus-serving split. Popularity scores compute offline in a Spark job over the order-history fact table — score equals a weighted combination of buy count, average rating, and recency decay. Scores write to a per-category sorted set in Redis keyed by category ID, with item IDs as set members and popularity as the score. The browse API does an O(log N) ZREVRANGE against the relevant category set, hydrates item metadata from a cache-aside MySQL or Cassandra read, and returns paginated results. Sharding the popularity sets by category ID gives natural horizontal scale; the bottleneck shifts to cache hydration latency, not popularity computation. For distributed-systems prep beyond this question, see our distributed systems interview prep guide.
What they’re really probing: Whether the candidate can defend the entity model under senior pushback. Laxman’s Dec 2024 loop ended on this question because his entity design “would not be scalable at large scale data” — the interviewer pushed for a denormalised structure, the candidate stayed with normalised entities, and the time ran out.
The senior move is to draw two entity diagrams up front: a normalised one (Item, Category, Order, Rating) and a denormalised one (CategoryItemRanking) that exists specifically to serve the popularity query at 10K RPS. Make the tradeoff explicit. The interviewer’s pushback is the prompt, not the trap.
How would you extend the rider app to dispatch Waymo and human drivers simultaneously?
Concept: multi-network marketplace orchestration | Difficulty: staff+ | Stage: onsite system design (senior/staff loops)
Direct answer: The multi-network AV marketplace question reflects Uber’s live 2025 reality — running Waymo’s autonomous Jaguar I-PACE fleet in Austin and Atlanta alongside human drivers on the same rider app, per the Sept 2024 partnership expansion announcement. The dispatch service needs a network-routing layer that picks which network handles each ride request based on a per-hex eligibility matrix: AV-supported hex IDs, current AV fleet utilisation, rider opt-in state, ride class (UberX, Uber Green, Uber Comfort, Uber Comfort Electric all qualify for Waymo matching per the announcement), and regulatory zone caps. The routing layer sits above the matching layer, not inside it — staff candidates draw this two-layer split on the whiteboard within the first ten minutes.
What they’re really probing: Whether the candidate frames this as a routing problem (which network gets which request) versus a matching problem (within a network, which vehicle gets the rider). The two are independent and chain together.
The follow-up to expect is fleet-management splits: Uber exclusively manages Waymo vehicle cleaning, repair, and depot operations, but Waymo retains the autonomous-driving stack itself. Your design has to surface where the responsibility boundary sits — a driver-state service for human drivers becomes a vehicle-state service for the AV fleet, with Uber owning depot state and Waymo owning operational state via a defined integration API. Staff candidates name this boundary explicitly within the first ten minutes.
Michelangelo and ML platform questions for MLE and Applied Scientist tracks
Uber’s Machine Learning Engineer and Applied Scientist loops swap one DSA round for an ML system design round, and the canonical reference is Michelangelo — Uber’s internal ML-as-a-service platform that, as of November 2025, runs over 400 active use cases, executes 20,000+ training jobs per month, and serves more than 15 million real-time predictions per second at peak. Source: eng.uber.com, Raising the Bar on ML Model Deployment Safety, Nov 2025.
How would you design Michelangelo’s feature store for 10,000+ shared features?
Concept: feature store architecture + offline/online consistency | Difficulty: senior MLE | Stage: ML system design
Direct answer: The Michelangelo feature store separates offline storage (HDFS-backed parquet, accessed via Spark and Hive) from online serving storage (Cassandra, keyed by entity ID + feature name, read at low latency at prediction time). Both pipelines feed from the same source-of-truth feature definitions registered by data scientists, and the platform guarantees offline-online consistency by running identical compute logic in both paths — batch precompute writes into Cassandra on a schedule for slow-moving features, near-real-time Samza streaming jobs against Kafka write into Cassandra for fast-moving features. The DSL — a Scala subset — expresses feature selection and transformation so the exact same expression runs at training time and prediction time.
What they’re really probing: Whether the candidate names the offline-online consistency problem unprompted. The canonical failure mode of feature stores is training-serving skew; senior MLEs lead with that problem and the architectural pattern that prevents it. Source: Meet Michelangelo, Uber Engineering, 2017; consistency invariant unchanged in Michelangelo 2.0, March 2024.
The interview-relevant detail is feature-store scale. The original 2017 launch post named roughly 10,000 features in the store; the 2024 update notes the Michelangelo Job Controller as a unified federation layer for batch workloads, scheduling against compute and data affinity. Mentioning the federation layer signals you have read the recent posts, not just the seven-year-old founding piece.
When does a feature need near-real-time compute vs batch precompute?
Concept: feature freshness tradeoffs | Difficulty: mid-to-senior MLE | Stage: ML system design
Direct answer: The near-real-time versus batch decision hinges on the feature’s freshness budget and source-data velocity. Batch precompute runs nightly or hourly via Spark over HDFS data; it suits features where staleness of a few hours is acceptable, like “restaurant’s average meal preparation time over the last seven days” — Uber’s published example. Near-real-time compute runs Samza streaming jobs against Kafka interview questions-style event topics, writing freshly-computed aggregates to Cassandra; it suits features where the seven-day window collapses to a one-hour window, like “restaurant’s average meal preparation time over the last one hour.”
What they’re really probing: The implicit cost-of-freshness tradeoff. Streaming pipelines are expensive to operate; batch pipelines are not. Senior candidates ask about prediction latency budgets and source-event throughput before recommending streaming over batch.
The deeper signal is the cold-start problem: streaming features need backfill from historical data so the model has training examples that match what serving will see. Uber’s published architecture solves this by running a batch job against historical logs that feeds the same Cassandra keys the streaming job will later update. Mention backfill explicitly in your answer.
Walk through Michelangelo’s model-deployment safety levels
Concept: ML deployment governance | Difficulty: senior MLE | Stage: ML platform deep dive
Direct answer: Michelangelo’s model deployment safety framework, expanded in the Nov 2025 Uber blog post, classifies models into safety tiers and gates deployment behind tier-appropriate checks. As of mid-2025, over 75% of critical models were onboarded to at least the Intermediate safety level. The progression — Basic, Intermediate, Advanced — adds shadow deployments, automated regression tests against production prediction distributions, canary rollout with auto-rollback on metric breach, and human-in-the-loop approval for the highest tiers. Three deployment modes coexist: offline batch (Spark job), online prediction service cluster (P95 latency under 5ms without Cassandra lookup, under 10ms with), and library deployment embedded as a Java library into another service.
What they’re really probing: Whether the candidate distinguishes deployment safety from model quality. A high-accuracy model can still cause production outages via skewed feature pipelines or unanticipated input distributions; safety levels exist to catch the second class of failure.
The senior version of this answer connects safety levels to business risk. A model that ranks restaurant search results can run at Basic safety with auto-rollback; a model that prices a trip — which directly affects revenue and rider trust — runs at Advanced with human approval on deploys. The mapping from business impact to safety tier is the staff-engineer signal.
Behavioral questions calibrated to Uber’s Risk-Conscious Founder Mentality
Uber’s behavioral round is calibrated against the eight refreshed values that replaced Travis Kalanick’s “always be hustlin'” set — the cultural reset Dara Khosrowshahi pushed through and that Fortune documented in detail in Sept 2024. The Risk-Conscious Founder Mentality value is the one interviewers test for most directly: Khosrowshahi’s framing — “protect the hunger, not the record” — translates to behavioral prompts that probe whether you take calculated bets at scale. Four questions surface repeatedly across 2024-2026 candidate accounts.
Tell me about a time you disagreed with a technical decision on your team
Concept: technical disagreement + influence | Difficulty: senior | Stage: behavioral / HM round
Direct answer: The technical disagreement question lands hardest when answered with the STAR-L framework — Situation, Task, Action, Result, Learning — and grounded in numbers. Emily’s Feb 2026 example, which the interviewer reportedly liked, was a polling-versus-event-driven debate at her previous company: 5-second polling caused CPU spikes; she built a Kafka proof-of-concept in three days, presented latency data (polling: 5s avg vs events: 200ms avg), addressed Kafka operational concerns, and the team adopted event-driven. CPU usage dropped 60%. The learning she shared closed the answer: “data wins arguments, not opinions. Every technical disagreement should be fought with a prototype and a benchmark, not a slide deck.”
What they’re really probing: Risk-Conscious Founder Mentality. The interviewer wants to see ownership over a contested decision, calculated risk-taking (building the POC in three days, not three weeks), and the maturity to acknowledge a tradeoff (Kafka operational complexity) rather than dismiss it.
The common failure mode is to tell a victory story where you were obviously right and the team was obviously wrong. That reads as confrontational rather than founder-mindset. The strong answer acknowledges the legitimate concern of the dissenting side and explains how you addressed it with data.
Tell me about a time the business problem wasn’t clearly defined
Concept: ambiguity navigation | Difficulty: senior | Stage: behavioral
Direct answer: The undefined business problem question, verified by Exponent as asked at Uber and Anthropic in the last year, tests the value Uber calls “Bold and Optimistic.” Strong answers walk through three concrete moves: surfacing stakeholders to clarify implicit success metrics, narrowing scope from the executive ask to a tractable first slice, and shipping a measurable artifact within two weeks that surfaces the next decision. Verbiage like “I led the analysis and developed a solution; however, first, I needed to transform this ambiguous directive into a clearly defined problem” lands well — paraphrased from the verified answer in Exponent’s bank.
What they’re really probing: Whether you treat ambiguity as an information problem to solve, not a permission problem to wait out.
The senior signal here is acting before you have complete information — bounded by a defined check-back point. Junior candidates either freeze and ask for more direction or build the wrong thing for a month; senior candidates ship a two-week probe with the stakeholders explicitly aligned on what the probe will surface.
Describe a time you had to make a quick decision under pressure
Concept: judgment under uncertainty | Difficulty: mid-to-senior | Stage: behavioral
Direct answer: The quick-decision-under-pressure prompt is testing time-bounded judgment, not heroics. The strongest answers cite a production incident or launch decision where you had insufficient information, a defined deadline, and a fallback that limited downside if you were wrong. The structure is: what was the decision (one sentence), what information was missing (one sentence), what fallback you put in place (the senior move), and what you learned from the outcome regardless of whether the call was right. Uber interviewers score the fallback explicitly — candidates who skip past it and lead with the outcome lose the round because they sound like they got lucky rather than engineered the downside.
What they’re really probing: Calibrated confidence. The interviewer wants to hear “I made this call knowing I could be wrong, and here’s the rollback path” — not “I made the right call because I’m smart.”
Avoid stories where the quick decision worked out and you take credit. Tell one where the call was a coin flip, the fallback caught the loss, and the team learned something. That structure signals the maturity Uber’s debrief committee scores positively.
How did you manage conflicting priorities across stakeholders?
Concept: stakeholder alignment + scope negotiation | Difficulty: senior | Stage: behavioral / HM round
Direct answer: The conflicting priorities question rewards structured prioritisation frameworks. The verified Uber-bank answer cites a RICE variant — Reach, Impact, Confidence, Effort — applied to the disputed work. The strong structure walks the interviewer through: how you scored each stakeholder’s ask on a shared rubric, how you escalated the unresolvable conflict to a single decision-maker rather than splitting the difference, and how you communicated the deferred work back to the stakeholder whose ask got de-prioritised. The deferred-communication piece is what most candidates miss. Senior Uber interviewers explicitly probe the deferred-communication step — they have seen it skipped often enough to make it the differentiating signal.
What they’re really probing: Whether you treat stakeholder management as a transparent system or a series of one-off compromises. Transparent systems scale; compromises don’t.
The Uber-specific edge in this answer is to acknowledge the platform tradeoff explicitly: every minute spent on a custom feature for one team is a minute not spent on the platform improvement that benefits all teams. Naming the platform tradeoff signals that you understand Uber’s current engineering posture — building leverage, not bespoke work.
The Technical Retrospective round: what senior candidates are actually scored on
The Technical Retrospective round is Uber’s senior-and-above-only deep dive on a past project. Exponent’s 2026 SWE guide names it explicitly: a deep-dive conversation where the interviewer explores a specific project from your resume, probing requirements, features, and technical tradeoffs. What that bland description hides is the scoring rubric.
The round is testing four things the standard system-design round cannot reach:
- Post-mortem maturity. The interviewer asks what you would do differently with what you know now. Weak candidates either defend every original choice or wholesale repudiate the project. Strong candidates surface two or three specific decisions that were defensible at the time and demonstrably wrong in hindsight, and explain the new evidence that changed the call.
- Cost archaeology. Senior interviewers explicitly probe what your system would cost at 10x volume, where the cost lives, and which architectural choice introduced the worst cost vector.
- Ownership scope. The interviewer separates what you personally drove from what the team owned collectively, and discounts ambiguous “we” language.
- Cross-functional friction. Most production projects had a difficult product or design or infra conversation, and the interviewer wants to hear how that conversation went, not whether everyone agreed.
Prepare two projects in this depth, not five at surface level. Each project should carry:
- A one-paragraph context covering the business problem and the team’s stake.
- A three-bullet architectural summary — components, data flow, the one tradeoff that drove the design.
- A list of three decisions you would revisit with hindsight, with the new evidence that changed the call.
- A cost-at-scale projection at 10x current volume.
- One specific cross-functional conflict with a named outcome.
The interviewer picks the project to drill into; your job is to be ready for either.
Questions to ask the interviewer (the post-profit-era senior signal)
The reverse-questions section of the loop carries asymmetric weight at Uber. Khosrowshahi’s Sept 2024 Fortune-documented cultural reset made cost-awareness and platform leverage explicit values; reverse questions that probe these signals immediately separate seniors who have read the cultural shift from those still prepping against the 2021-era Uber. Six questions to keep ready, calibrated to the round you’re in:
- For the HM round: What does your team’s current ratio of platform investment to product work look like, and how has it shifted since Uber crossed the GAAP-profit threshold in Q3 2024?
- For the system-design interviewer: Which of your team’s services has the worst unit-economics curve at 10x scale, and what’s the planned mitigation?
- For the senior IC interviewer: When the team disagrees on whether a new system is a platform investment or a one-off ride-app feature, who decides and on what evidence?
- For the AV / Waymo-adjacent interviewer: How does your team handle the integration boundary with Waymo’s autonomous stack — what state is owned where, and where have you found the boundary too brittle?
- For the MLE interviewer: How has Michelangelo’s safety-tier framework changed which models your team can iterate on quickly versus which require a deploy approval?
- For the recruiter: What’s the current leveling expectation gap between an external Senior hire and an internal promotion to the same level — where do the rubrics differ?
Each question signals the same thing: you have read Uber’s public engineering output and current strategic posture. The wrong questions in this round — “What’s the work-life balance like?” or “What languages does the team use?” — score as low-signal because they could be asked of any company.
Uber interview prep: a 10-day sequence built around eng.uber.com
The single piece of advice that recurs across every named 2024-2026 candidate postmortem is to read the Uber Engineering Blog cover to cover. Emily put it most directly: “That 2 hours of reading their actual engineering blog was worth more than 2 weeks of generic system design prep.” The reading list below maps to specific eng.uber.com posts, ordered by what each round most needs. Pair it with practice runs that include follow-up pressure — Pramp or paid mock interviews on Exponent — because the standard “Design Twitter” diagram does not prepare you for the “what about regulatory zones” follow-up.
- Days 1-2 (foundational reading): Meet Michelangelo, the H3 hexagonal indexing library docs, and the Scaling Uber Eats from Restaurants to Retail piece on the INCA catalog.
- Days 3-4 (recent architecture): the 2024 Michelangelo predictive-to-generative post, the 2024 AI/ML infrastructure scaling piece, and the Nov 2025 model deployment safety framework.
- Day 5 (real-time + dispatch): the Fireball push platform piece and the Delivery Search Platform post. Both cite specific data flow patterns interviewers will recognise.
- Days 6-7 (DSA on company-specific patterns): work through Striver’s A-Z DSA Sheet emphasising sliding-window-with-monotonic-deque, 2D DP, and priority-queue scheduling — the patterns Laxman’s Dec 2024 loop hit.
- Day 8 (mock system design with follow-up pressure): run two mock interviews on the surge pricing prompt and the multi-network AV prompt. Have the mock interviewer ask the cross-region regulatory follow-up specifically.
- Day 9 (behavioral STAR-L drilling): write four STAR-L stories — one disagreement, one undefined problem, one quick decision with fallback, one stakeholder conflict — and time yourself delivering each in under three minutes.
- Day 10 (logistics + recovery): set up Excalidraw before the virtual onsite, rehearse the narrative diagram-walkthrough technique, and prepare the six reverse questions tied to specific rounds.
Two prep failure modes show up across postmortems. The first is reading the founding 2017 Michelangelo post and stopping there — the 2024-2025 follow-ups are where current interview signals land. The second is grinding DSA without practising the live cross-question dialogue that machine-coding rounds demand.
Both are fixable inside the ten days above if you start now. The compensation context, for what it’s worth as of mid-2026: Levels.fyi reports median total compensation of $452,573 for Senior SWE (L5), $723,069 for Staff SWE, and $819,750 for Senior Staff — figures that move quarterly with Uber’s equity price, so verify before you negotiate. Sources: Levels.fyi Senior SWE, Staff SWE.