WeRide Interview Process & Questions

WeRide's loop pairs short, classic algorithm problems with systems follow-ups: infrastructure and platform teams go on to C++ memory ownership, thread safety and file I/O once the code works. Complexity is graded out loud, and interviewers sometimes name the exact state-space reduction they expect. Round counts vary widely, from one screen to five phone rounds, and some China-based teams interview in Chinese.

This guide breaks down each stage of the WeRide interview, what interviewers evaluate in each round, and how to prepare, with questions candidates were actually asked.

Verified: Based on 10 candidate-reported interview experiences, cross-checked against recent public accounts.

WeRide interview process

Each team hires for itself, so every round opens the same way (a resume walk-through, then one or two coding problems) and ends on the team's domain. WeRide's 2026 postings describe an optional online assessment, a recruiter call, then interviews with future colleagues: three for summer interns, three to four for China-based new-grad software roles, and four to five for US new-grad algorithm and computer vision roles. Candidates report one to five technical rounds, most often three.

Interns and new grads nearly always take the assessment. Experienced candidates on infrastructure teams get fewer pure-algorithm questions and more C++, concurrency and process-level follow-ups. The process typically takes two to three weeks after the application review, with reported extremes of one and four.

Here's what the interview process can look like:

• Online assessment (interns, new grads, many others): Three timed coding problems, either graph-heavy or an easy-easy-medium mix.
• Recruiter call: A short, non-technical conversation about background, motivation and availability.
• Technical phone screens (one to five): A resume deep dive, then one or two easy-to-medium problems with a live twist.
• Systems and language rounds (infrastructure and platform teams): C++ internals, Java concurrency, parallel file I/O and small object-oriented exercises.
• Final round (onsite or video): A background discussion, one algorithm problem from approach to code, and time for your questions.

Tip: Leave a third of every coding slot for the follow-up. Prompts are classics with a twist added live, such as swapping list nodes by value and then by reference, and the twist is where rounds are decided.

Online assessment

The assessment is three coding problems with hidden tests, in a window reported at about 75 minutes to two hours. Two sets recur. The graph-heavy set runs an array transformation, a BFS or DFS traversal, and a graph-coloring or bipartiteness task under strict runtime limits. A late-2025 intern set was two easy problems and one medium: reformat a date string into YYYY-MM-DD, reverse a linked list, and a DP that minimizes the cost of adjusting heights so that no two adjacent values are equal.

A perfect score is not required. One candidate passed two problems, hit runtime errors on a few hidden cases of the coloring problem, and still got a recruiter call shortly after.

Interviewers evaluate:

• Runtime discipline: Unpruned backtracking or repeated traversals fail the hidden limits.
• Graph fundamentals: Visited-state handling, cycle awareness and two-coloring.
• Edge cases: Disconnected components, single nodes and malformed date fields.
• Robustness: Iterative traversal where deep recursion would crash.

Practice three-problem sets against a two-hour timer.

Note: The reported coloring failures were runtime errors, not wrong answers. Convert recursive DFS to an explicit stack before submitting anything that walks a large graph.

Sample questions for the online assessment

Here are some questions reported by recent candidates:

• Decide whether a graph can be colored under the given constraints, such as a bipartiteness check.

• Traverse a graph and compute a result from its connectivity or path properties.

• Convert a date string into YYYY-MM-DD format.

• Minimize the cost of raising heights so that no two adjacent heights are equal.

• Graph Coloring Problem

• Is Bipartite Graph

• Graph Traversal Problem

• Preprocess Dates

• Minimize Cost to Make Blocks Unique

Recruiter call

A brief recruiter conversation typically follows the assessment: your resume, why autonomous driving, location and availability. There are no technical questions. WeRide gives no individual feedback during the process, so ask the recruiter about timing and format here.

Interviewers evaluate:

• Track fit: General software, algorithm (prediction, planning, mapping, simulation) or infrastructure.
• Motivation: Real interest in autonomous vehicles, which every posting lists.
• Logistics: Graduation date, location and work authorization.

Ask which team you are interviewing for and which language each round will use.

Sample questions for the recruiter call

Here are some questions reported by recent candidates:

• Walk me through your background and your most relevant project.
• Why WeRide, and why autonomous driving?

Technical phone screens

Engineers from the hiring team run these phone or video calls. Nearly every one opens with a resume deep dive, and one reported round was nothing else: past projects, the decisions behind them and what the candidate personally owned. Coding is easy to medium: fast exponentiation, valid parentheses, a trie, a diagonal matrix traversal variant, reorder list, and swapping linked-list node values followed by swapping the nodes themselves. Interviewers offer hints when a candidate stalls.

Infrastructure teams push harder. One AI infrastructure candidate had to find the shortest grid path collecting ten coins between fixed endpoints, and the interviewer compared a 100 x 100 x 2^10 search with a 12 x 12 x 2^10 search over the points of interest. Another round asked for the maximum independent set of a binary tree, with the include/exclude recurrence proven. Multi-source BFS also appears.

Interviewers evaluate:

• Complexity reasoning: Bounds for every solution, and the reduced state space found unprompted.
• Adaptability: Absorbing the twist (references instead of values, extra characters in a bracket string) without restarting.
• Resume ownership: The reasoning behind your technical choices, not a feature list.
• Correctness argument: A short proof that a DP recurrence covers every case.

Prepare a five-minute decision narrative for each resume project.

Tip: Interviewers are not always briefed on your role or level. State both at the start so follow-ups are pitched correctly.

Sample questions for the technical phone screens

Here are some questions reported by recent candidates:

• Find the shortest path on a 100 x 100 grid that collects all ten coins, then shrink the state space.

• Swap adjacent linked-list node values, then redo it by relinking the nodes.

• Validate a bracket string, then ignore characters that are not brackets.

• Compute the maximum independent set of a binary tree and prove the DP.

• Shortest Path to Collect All Coins

• Valid Parentheses

• Fast Exponentiation

• Trie Implementation / Trie-based String Operations

• Reorder a Singly Linked List in L0→Ln→L1→Ln-1… Order

Systems and language rounds

Infrastructure and platform teams add systems questions after the algorithm or give them a full round. C++ candidates explained std::weak_ptr, then implemented shared_ptr with a control block and reference counting; move semantics, perfect forwarding, threads, coroutines and virtual memory have also come up. A Java round asked why a shared i++ loses updates and how to make it thread-safe, then moved to Fibonacci by matrix exponentiation.

One candidate had to reverse strings with parallel file I/O, several workers reading and writing segments at once, and then explain cleanup and consistency if a process is killed mid-write. Other prompts include implementing a message queue and, on Java teams, implementing a given interface and comparing interfaces with abstract classes.

Interviewers evaluate:

• Memory ownership: Correct counts across copy, move and destruction, and when a weak reference breaks a cycle.
• Concurrency correctness: Spotting the read-modify-write race and costing an atomic, lock or partitioning fix.
• Failure thinking: What survives a crash during I/O, and how temporary files or atomic renames restore consistency.
• Design rationale: Why a language feature exists, beyond code that compiles.

Write shared_ptr, a thread-safe counter and a bounded message queue from memory before an infrastructure loop.

Note: On infrastructure teams the algorithm is often the warm-up. Candidates who expected pure algorithm screens were caught by smart-pointer and process-cleanup follow-ups, and those decide the round.

Sample questions for the systems and language rounds

Here are some questions reported by recent candidates:

• Implement shared_ptr from scratch, then explain when std::weak_ptr is needed.

• Explain why concurrent i++ loses updates, then write a thread-safe version.

• Reverse strings in a file with parallel workers and keep it consistent if a process dies mid-I/O.

• Implement matrix multiplication and fast exponentiation

• Fibonacci Matrix Exponentiation

• Implement Power Function

Final round

Some candidates finish with an onsite or final video round shaped like a phone screen: a short background discussion, then one problem from approaches to tested code. A recent example was the k-th largest element in an unsorted array, taken to quickselect, its average linear time, and a randomized pivot for worst-case inputs. The last minutes are for your questions. China-based algorithm tracks have reported a longer ladder ending in scenario design and a director-level conversation before HR.

Interviewers evaluate:

• Approach before code: Options and trade-offs outlined, with alignment checked before writing.
• Worst-case awareness: The adversarial input and its fix, named unprompted.
• Testing: Edge cases walked through the finished code.
• Engagement: Specific questions about the team's stack and problems.

Practice comparing sorting, a heap and quickselect in two minutes.

Sample questions for the final round

Here are some questions reported by recent candidates:

• Find the k-th largest element in an unsorted array, then discuss quickselect's worst case.

• Walk through the technical decisions on your most recent project and what you would change.

• Top K Largest Elements

• In-Flight Movie Pair (Two Sum Variant)

How WeRide makes hiring decisions

The hiring team weighs the interview feedback and decides. WeRide says AI tools may help screen applications, but people make the final call. It gives no individual feedback during the process, and the reports describe no separate committee or cooldown policy.

How to prepare for the WeRide interview

1. Write graph code iteratively: BFS, DFS, bipartiteness and coloring with an explicit stack, so hidden tests do not hit recursion limits.
2. Argue the state space: For grid and bitmask search, explain why compressing to the points of interest wins.
3. Rehearse the twists: Node swaps by reference, brackets with ignored characters, quickselect with a random pivot.
4. Know the math-core problems: Fast exponentiation, matrix multiplication and Fibonacci by matrix powers, with complexity.
5. Implement ownership primitives: shared_ptr with a control block, weak_ptr and move semantics for infrastructure teams.
6. Prepare one concurrency case end to end: The race, the fix and its cost, and crash consistency during file I/O.
7. Tell each project as decisions: Every round opens on your resume, and follow-ups ask why.

About working at WeRide

WeRide, founded in 2017 and headquartered in Guangzhou, builds Level 2 to Level 4 autonomous-driving products on one platform: robotaxis, robobuses, robosweepers, robovans and driver assistance. By early 2026 its fleet passed 2,000 vehicles, including more than 1,100 robotaxis, across about a dozen countries, and its Abu Dhabi robotaxi service runs with Uber. It has been listed in New York since 2024 and in Hong Kong since November 2025. Engineers work in China, San Jose, Singapore and the Middle East, mostly in safety-critical C++.

WeRide hires software engineers across its driving stack and supporting systems. Teams include:

• Prediction: Forecasting the behavior of nearby vehicles and pedestrians.
• Planning and control: Motion planning, decision-making and vehicle control.
• Mapping and localization: High-definition maps and precise positioning.
• Simulation: Sensor modeling and 3D world reconstruction for validation.
• General software and infrastructure: In-vehicle real-time systems, data logging, fleet cloud services and ML training and deployment infrastructure.

Experience and education requirements

New-grad software roles ask for a bachelor's or master's degree in computer science, software engineering, mathematics or a related field, with C++ and/or Python, Java or Go. Algorithm roles typically ask for an MS or PhD, and ML or robotics publications help. Experienced backend, infrastructure and mapping roles typically ask for about three years of professional C++.

FAQs about the WeRide interview

How long does the WeRide interview process take?

Typically two to three weeks from the first technical round to a decision, with reported extremes of one and four weeks. The application review before that can take a few weeks.

What is the hardest round of the WeRide interview?

The systems and language rounds on infrastructure teams, where a solved problem is followed by implementing shared_ptr or reasoning about crash consistency. In algorithm-only loops, the follow-up twist decides most rounds.

What language should I use?

C++ is the default for vehicle and infrastructure work, and those teams probe its internals. Java-oriented teams ask concurrency and interface questions. Some China-based rounds are held in Chinese.

How much does a WeRide software engineer make?

Official US postings list base pay of $120K to $165K for 2026 new-grad algorithm roles and $130K to $182K for an experienced San Jose engineering role, with an annual performance bonus and equity on top.