Interview Prep
18 Uber OA Reports 2026: Real SWE Questions & Repeats
Qian Zhou · Marketing Specialist ·

Uber’s Software Engineer online assessments can vary from one hiring round to another, even when the questions cover familiar algorithmic concepts. For candidates, the challenge is understanding which problem patterns are worth preparing for and how small changes in requirements can affect the solution.
To provide a clearer picture, Screna reviewed 18 Uber SWE OA candidate reports from April to July 2026, focusing on recurring questions, assessment formats, and common coding challenges. These findings are based on individual candidate experiences rather than official Uber assessment requirements. Some reports describe only part of an assessment, so the findings should not be treated as a complete or standardized picture of Uber’s hiring process.
1. Uber SWE OA Quick Overview
Based on 18 Uber SWE online assessment reports collected by Screna, the assessments primarily focus on algorithmic coding problems. Topics include trees and graphs, dynamic programming, binary search and optimization, as well as arrays and sliding windows. One notable finding is that several coding problems appeared across multiple reports, although similar questions did not always share the same constraints or objectives.
| Key Question | Findings from 18 Uber SWE OA Reports |
|---|---|
| Which questions appeared repeatedly? | Prime-Step Jump Game appeared in 3 reports, while Permutation Contiguous Segment, Tree Edge Reversal, and Pipeline Throughput Optimization each appeared in 2. Some were variations of the same problem type rather than identical questions. |
| How long is the Uber OA, and how many questions are there? | Only 2 reports explicitly mentioned a 90-minute assessment, while 3 provided detailed descriptions of two separate coding questions. The available reports do not establish a standard time limit or question count. |
| What platform does Uber use for its OA? | Hack2Hire was mentioned in 4 reports, but these references do not confirm it as the actual coding assessment platform. Only 1 report explicitly identified HackerRank. Most reports did not specify the platform used. |
| What skills does the Uber OA test? | Beyond fundamental algorithms, the questions involve additional constraints, specific output requirements, and performance considerations. Candidates need to adapt their solutions to the exact problem conditions. |
Overall, preparing for the Uber SWE OA requires more than familiarity with common algorithms. Understanding how similar problems can change under different constraints, along with practicing efficient implementations under time limits, can be more useful than memorizing solutions to individual questions.
2. Uber SWE Online Assessment Format
Based on candidate reports collected by Screna, the Uber SWE online assessment primarily tests algorithmic coding skills, although the platform, duration, and number of questions vary across reported assessment versions. Alongside familiar data structures and algorithms, some questions introduce additional constraints that make implementation more challenging.
What Is the Uber SWE Online Assessment?
The Uber SWE Online Assessment (OA) is a coding assessment used during the software engineer hiring process, with a focus on algorithm design and implementation. Candidates are generally expected to solve coding problems within a time limit, choose appropriate algorithms, handle input constraints, and meet all output requirements. Some questions modify familiar algorithmic problems by introducing unusual movement rules, optimization objectives, or additional output conditions, so a known solution may not work without adjustments.
What Platform Does Uber Use for Its OA?
Most of the 18 Uber SWE OA reports did not specify the testing platform. Hack2Hire was mentioned in four reports, including this Uber SWE OA candidate experience, making it the most frequently mentioned name associated with the assessment process. However, these reports do not establish that Hack2Hire was the platform used to administer the coding test.
By comparison, only one Uber SWE HackerRank OA experience explicitly identified HackerRank as the assessment platform. The candidate also reported having to keep their camera on throughout the assessment.
How Long Is the Uber OA, and How Many Questions Are There?
Only two candidate reports explicitly mentioned a 90-minute assessment: the Uber OA experience discussed above and this Uber SWE two-question OA report. Most other reports did not provide a clear assessment duration.
The number of questions also varied. Both this Uber SWE OA report with two coding problems and this Uber SWE graph-focused OA experience documented two separate coding questions, as did the 90-minute assessment mentioned earlier. The previous Uber OA report also described a two-problem assessment but provided detailed notes on only one question, so the number of questions documented in a report does not always reflect the full assessment.
What Types of Coding Questions Appear in Uber OAs?
The reviewed Uber SWE OA questions covered several algorithmic categories:
- Trees and Graphs: Edge reversals, connected components, and shortest-path traversal.
- Dynamic Programming: Prime-number Jump Game variations and string optimization problems.
- Binary Search and Optimization: Pipeline throughput optimization, budget-constrained problems, and scheduling.
- Arrays and Sliding Windows: Permutation contiguity checks, distinct-element subarrays, and price calculations.
Most of these questions build on familiar data structures and algorithms, but additional constraints can change the expected approach. The next section examines the actual Uber OA questions, recurring problem patterns, and differences between reported variations.
3. Real Uber SWE OA Coding Questions Reported in 2026
Several coding problem families appeared across the reviewed Uber SWE online assessments. Some questions had nearly identical requirements, while others introduced different constraints or outputs that changed the expected solution. The clearest patterns involved prime-number Jump Game problems, permutation checks, tree edge reversals, and pipeline optimization.
Repeated Uber OA Questions and Variations
Prime-Step Jump Game (3 reports)
Three Uber SWE OA reports described related Jump Game problems involving score maximization and prime-number jumps. An Uber SWE OA report involving prime jumps limited jump lengths by a given value and allowed negative scores, while the previously discussed Uber HackerRank OA experience also involved prime-length movements. A third Uber OA variation introduced different movement rules, including a restriction on the final digit of valid prime numbers.
These questions shared a dynamic programming foundation, but their allowed transitions differed. They represent three related variations rather than three identical assessment questions.
Permutation Contiguous Segment (2 reports)
The permutation problem appeared with closely matching requirements in the earlier 90-minute Uber SWE OA and this Uber SWE permutation-contiguity experience. Both asked candidates to determine whether the values from 1 through k occupied consecutive positions in a permutation, then produce a binary string representing the results for different values of k.
Unlike the prime-number Jump Game variations, these two reports described essentially the same core problem and output requirement.
Minimum Edge Reversals in a Tree (2 reports)
Tree edge reversal questions appeared in two related forms. The previously mentioned two-question Uber OA required choosing a root that minimized the number of reversals needed to make every edge point away from it, while the Uber SWE tree-reversal OA experience focused on making every node able to reach a selected root.
The latter report also included a related fixed-root variation involving city 0. Although these questions belong to the same algorithmic family, the required edge directions and root-selection conditions are different.
Pipeline Throughput Optimization (2 reports)
Pipeline optimization appeared in the earlier two-question assessment and a separate Uber OA pipeline-throughput experience. Both involved services connected in series, where the slowest service determined overall throughput and a limited budget could be used for scaling.
The shared objective was to maximize pipeline throughput under a budget constraint, although the reports described somewhat different scaling operations.
Similar coding problems have also appeared in candidate-reported OAs at other companies. The Uber round-trip scheduling problem closely resembles a scheduling question in a Meta SWE OA report, while the permutation-contiguity problem also appeared in a Microsoft OA experience. These examples suggest some overlap in the coding questions reported across Uber, Meta, and Microsoft.

Tree and Graph Problems
Tree and graph questions tested candidates' ability to translate problem requirements into graph representations and choose appropriate traversal strategies. The edge-reversal problems discussed above involved determining which directed edges needed to change, with the solution depending on whether the root was fixed or could be selected. For versions considering every possible root, re-rooting techniques can reduce the need for repeated graph traversals.
The Uber SWE two-question graph OA experience included a generalized knight-movement problem on a chessboard. Candidates needed to calculate the minimum number of moves to reach a target position for different movement configurations, or return -1 when the destination was unreachable. The same assessment also included a segment-reversal problem involving a token whose position changed after reversing a contiguous segment, with certain positions forbidden.
Connected components appeared in an Uber SWE OA question involving balls on a grid. Two balls were directly connected when their Euclidean distance was strictly less than a given threshold, and connections were transitive. The task was to determine how many connected groups existed and calculate the minimum number of triggers needed to absorb all balls.
Dynamic Programming Problems
Dynamic programming appeared in questions involving score maximization, constrained transitions, and string optimization. In the Prime-Step Jump Game variations, candidates needed to maximize the accumulated score while respecting the permitted jump lengths. The changing movement rules made valid transitions an important part of the problem, while versions allowing negative scores or unreachable positions introduced additional considerations.
String problems introduced different challenges. A 2026 Uber SWE OA wonderful-string experience asked for the minimum cost of converting a string into one where at most one character had an odd frequency. The problem combined character-frequency conditions with a cost-minimization objective, making it more involved than a straightforward parity check.
Another Uber OA experience involving palindrome costs required calculating the combined cost of converting every substring of a given string into a palindrome. Because many substrings overlap, the problem raised questions about how to avoid repeated calculations. Efficiently organizing reusable information was an important consideration for this type of string optimization problem.
Binary Search and Optimization Problems
Binary search appeared in Uber OA questions involving optimal feasible values and boundaries in ordered data. Pipeline throughput optimization is one example: candidates needed to determine the highest throughput achievable while keeping scaling costs within a fixed budget. The relationship between a target throughput and its feasibility made binary search a relevant technique, although the specific scaling rules differed between reports.
A 2026 Uber SWE OA report on stall-price queries involved a non-decreasing array of prices, with each query specifying a starting position and budget. The task was to find the maximum number of consecutive items that could be purchased moving rightward without exceeding the budget. The ordered prices and repeated queries made efficient range-cost calculations important.
Optimization also appeared in an Uber SWE online assessment involving elevator and stair travel. Candidates had to choose how many floors to travel by elevator before climbing the remaining floors by stairs. Elevator travel increased available energy, while climbing consumed energy, and the objective was to minimize the difference between elevator and stair travel times while ensuring the climb remained feasible.
Scheduling provided another variation in an Uber OA round-trip scheduling experience. Given two sorted departure-time arrays for locations A and B, candidates needed to complete a specified number of round trips, with each leg taking 100 time units. Finding the next eligible departure efficiently was an important part of the problem.
Array and Sliding Window Problems
Array-based questions tested whether candidates could maintain information efficiently while meeting exact conditions and output requirements. The permutation-contiguity problem discussed earlier required checking whether the values from 1 through k formed a continuous segment for every k. Tracking the positions of those values allows the contiguity condition to be evaluated efficiently without repeatedly scanning the entire permutation.
A 2026 Uber SWE sliding-window OA experience asked for the shortest contiguous subarray containing at least k distinct integers, returning -1 if no such subarray existed. The distinction between at least k and exactly k was important, as was maintaining the distinct-element count while examining different window boundaries.
A different Uber SWE OA question involving discounted prices required finding the first later item whose price was less than or equal to the current item's price and applying that value as a discount. Candidates needed to return both the final total and the indices of items that received no discount. The problem combined a familiar array-search pattern with additional output requirements.
4. Common Challenges in Uber SWE OA Coding Questions
Based on the Uber SWE OA experiences collected by Screna, candidates faced challenges beyond understanding the underlying algorithms. Additional problem requirements, algorithm selection, and code efficiency could all affect their test results.
Edge Cases and Additional Output Requirements
Some Uber OA questions introduce special requirements beyond familiar algorithms. For example, the Uber SWE discount-price OA experience required candidates to return the indices of items that received no discount, in addition to the final price total. The candidate reported that handling this additional output was more challenging than the core calculation.
Other questions involved constraints that were easy to overlook. The Uber connected-components OA problem required the Euclidean distance between connected balls to be strictly less than d, while a separate Uber SWE bit-manipulation OA experience involved integers up to 2^60, provided as decimal strings.
These examples show how overlooking output requirements, boundary conditions, or input constraints can cause a solution to fail certain test cases, even when the underlying algorithm is familiar.
Difficulty Finding the Right Algorithm
Some Uber OA questions resemble familiar algorithm practice problems, but additional constraints can change which approach works best. The Uber SWE grid word-search experience highlights the importance of understanding the search rules before choosing an algorithm.
Optimization problems can also lead candidates toward intuitive approaches that may not be effective. In the Uber pipeline-throughput OA experience, the candidate described difficulties selecting an appropriate algorithm. For these problems, understanding the constraints and optimization objective is essential before deciding how to solve them.
Performance Bottlenecks and Hidden Test Cases
Among the 18 Uber SWE OA reports, only two candidates explicitly reported time-limit issues. The Uber directed-tree edge-reversal OA experience and the Uber palindrome-cost OA experience both described solutions that struggled with execution time.
Separately, the Uber Hack2Hire Jump Game experience noted that hidden test cases are where candidates often get burned.
5. How to Prepare for the Uber SWE Online Assessment
The Uber SWE OA experiences reviewed above point to three useful preparation priorities: understanding problem variations, checking implementation details, and managing algorithmic complexity. A focused practice routine should address each of these areas.
Practice Problem Variations and Check Constraints
Start by reviewing Uber interview questions and OA experiences to identify relevant problem categories, including graphs, dynamic programming, binary search, and arrays. Rather than memorizing individual solutions, practice similar problems with different constraints and consider whether the same algorithm still applies. Before writing code, identify the allowed operations, input limits, and optimization objective.
You can also use Screna AI Mock for role- and job-description-based question-and-answer practice to explain your algorithm choices and discuss trade-offs. Pair this with hands-on coding exercises to strengthen both your problem-solving reasoning and implementation skills.
Check Edge Cases and Output Requirements
Treat edge cases and output requirements as part of the solution from the beginning. During practice, test scenarios involving equal values, boundary conditions, large inputs, and unreachable states where applicable. Before submitting, verify that your code returns every requested result in the correct format, including any required indices or ordering.
Test Complexity Before Submission
Estimate the time and space complexity of your solution against the maximum input size before finalizing your approach. If an algorithm repeatedly scans the same data or performs unnecessary calculations, consider whether a more efficient technique could reduce the workload.
Practice testing solutions on larger inputs instead of relying only on sample cases. A final check of runtime performance and boundary conditions can help catch issues that may otherwise appear only in hidden test cases.