Deliveroo interview questions & answers

10 real Deliveroo interview questions with full model answers — Behavioral, Coding. Drawn from the same verified bank ChannelPulse drills from (10 Deliveroo questions in total).

BehavioralMediumDeliverooDevOps / SREBehavioural interview

1. Give an example of a time when you and a colleague had a difference of opinion about a project you worked on together.

The full question

Give an example of a time when you and a colleague had a difference of opinion about a project you worked on together. How did you reach a conclusion?

Model answer

  1. Situation — A colleague and I were working on a safer release process for services supporting the delivery journey. We agreed that releases needed better protection, but disagreed about the control: my colleague wanted every deployment blocked by a single, strict platform-wide health gate; I thought that would create false alarms for services with different traffic patterns and failure modes.
  2. Task — I needed to reach a decision that protected customers and on-call engineers without turning the shared deployment platform into a bottleneck. I also wanted to keep the discussion focused on evidence rather than personal preference.
  3. Action
  • I first asked my colleague to explain the incidents behind their proposal. Their concern was valid: a release could look successful while a key customer-facing operation was failing, and teams did not always notice quickly.
  • I explained my concern with a universal threshold: a low-volume service could fail a traffic-based check simply because it had too little data, while a broad aggregate could hide a problem in one important endpoint.
  • We wrote down the outcomes we both wanted—detect harmful releases quickly, roll back reliably, and avoid blocking healthy releases—and reviewed recent incidents against those criteria.
  • I proposed a compromise: require a small set of platform-level checks for every service, such as deployment health and basic availability, while allowing teams to add service-specific indicators and thresholds. We would also start with conservative rollout stages and make the decision and rollback reason visible to the on-call engineer.
  • To test it, we piloted the approach with two services that had different traffic profiles. We deliberately exercised a failing check in staging, then reviewed false positives and the operator experience together.
  • The results led us to refine the defaults and document when a service should define a custom check. I made sure my colleague was credited for surfacing the need for a stronger release gate and invited them to present the pilot findings with me.
  1. Result — We adopted the shared baseline plus service-specific checks, rather than either original proposal unchanged. That gave teams consistent protection while avoiding a one-size-fits-all threshold, and the pilot provided a repeatable way to validate future changes. I learned that a disagreement is often useful when both people make the risks explicit; a small, measurable experiment can turn it into a better design and preserve the working relationship.
BehavioralMediumDeliverooDevOps / SREBehavioural interview

2. Describe a specific task or challenge you faced and how you ensured its successful completion.

The full question

Describe a specific task or challenge you faced and how you ensured its successful completion. What were the key factors in that success?

Model answer

  1. Situation — I was asked to improve the reliability of a deployment path used by several customer-facing services. A failed release could affect restaurant availability or order updates, while overly cautious release procedures were slowing teams down. I was the SRE responsible for coordinating the technical work with service owners.
  2. Task — My goal was to deliver a safer rollout process without creating a new operational burden or forcing every team into an unsuitable health check. I needed to take the change from proposal through production adoption.
  3. Action
  • I began by reviewing recent deployment incidents and speaking with the teams that used the pipeline. The main gap was that releases were judged by whether the process completed, not whether the service remained healthy afterward.
  • I translated that into a concrete design: deploy to a small canary first, monitor service-specific indicators, then increase traffic in stages. I kept the common pipeline simple and made health checks configurable, with sensible defaults.
  • I agreed success criteria with service owners before implementation: no increase in deployment-related incidents, automatic rollback when agreed thresholds were breached, and no material increase in normal release time.
  • I tested the flow in a non-production environment, including deliberately failing health checks and validating that rollback actually restored the previous version. I also documented the operator experience and ran a walkthrough with on-call engineers.
  • Rather than migrate every service at once, I chose a low-risk service for the first production rollout. We reviewed its metrics and feedback, fixed a confusing alert, then onboarded other services in batches.
  • I kept a clear owner for each action and reported progress against the agreed criteria, so teams knew what was ready and what still needed their input.
  1. Result — The rollout completed without a deployment-related incident, and the pipeline could halt or roll back a release when its health checks failed. Teams adopted it incrementally, and the shared process reduced the need for manual release supervision. The key factors were defining success with users, testing failure paths—not just the happy path—and delivering in small, observable steps.
BehavioralMediumDeliverooMachine Learning EngineerMachine Learning Theory

3. What was your decision-making process for choosing models in your previous machine-learning project?

Model answer

  1. Situation — In a delivery-time prediction project, I needed to choose a model that could improve customer-facing estimates across markets with different restaurant behavior and demand patterns. The project had a strict inference-latency budget, and predictions needed to remain useful for operational teams, not just perform well on an offline test set.
  2. Task — I owned the model comparison and recommendation. I wanted to avoid choosing a more complex model simply because it looked impressive, and instead select the simplest approach that met the product and operational requirements.
  3. Action
  • I began with the decision context: the model had to predict delivery time using only features available at request time, respond within the serving budget, and behave reasonably across cities and peak periods.
  • I established a simple historical-average baseline, then compared a regularized linear model and gradient-boosted trees. This gave us a useful range of complexity and helped quantify whether non-linear interactions justified the extra operational cost.
  • I used time-based validation rather than a random split, because future demand patterns are what the deployed model must handle. I also checked performance by city, distance, restaurant type, and busy versus quiet periods.
  • I compared more than one metric: median absolute error for typical accuracy, high-percentile error for painful misses, calibration for whether estimates were systematically optimistic, and inference latency for the customer flow.
  • The boosted-tree model performed best overall and captured useful interactions, but I rejected an experimental alternative that offered only a small aggregate gain while worsening reliability in a low-volume market. I recommended the boosted-tree model with a conservative fallback and staged rollout.
  1. Result — The selected model improved median absolute error by about 10% over the baseline in the pilot and met the latency target. Segment checks and gradual deployment reduced the risk of a strong average result hiding a poor experience for some customers. My main lesson was to choose models against the full decision and serving context: data availability, reliability, interpretability, and operational cost matter alongside predictive accuracy.
BehavioralMediumDeliverooMachine Learning EngineerMachine Learning Theory

4. Can you describe a previous machine-learning project you were majorly involved in?

Model answer

  1. Situation — I was a major contributor to a project that improved delivery-time estimates shown during checkout and order tracking. Estimates that were too optimistic created a poor customer experience and extra pressure on support; estimates that were too conservative could reduce conversion. The project covered multiple cities, restaurant types, and demand conditions.
  2. Task — I owned much of the modelling and evaluation work, partnering with data engineering, product, and operations. Our goal was to make estimates more accurate and better calibrated while keeping inference fast enough for the customer-facing flow.
  3. Action
  • I worked with product and operations to define the target precisely: predict time from order placement to delivery, while also examining preparation and courier travel components so we could diagnose errors.
  • I audited the event data before modelling. We found inconsistent timestamps and a risk of leakage from events that were not available at prediction time, so I aligned the training features with the actual serving-time information.
  • I established a simple baseline and built a gradient-boosted tree model using features such as recent restaurant preparation performance, time of day, distance, and local demand. I evaluated it using time-based splits and slices by city, distance, and peak period.
  • I treated calibration and segment-level reliability as important alongside average error. I reviewed large residuals with operations to distinguish genuine model gaps from data-quality or process changes.
  • I partnered with engineering to deploy the model behind a gradual rollout, with monitoring for prediction error, latency, feature freshness, and changes in input distributions. We kept a straightforward fallback available if predictions became unhealthy.
  1. Result — In the pilot, the new approach reduced median absolute error by roughly 10% against the baseline, with the clearest gains during busy periods, while staying within the serving-latency budget. The work also gave operations a more useful breakdown of where delays came from. I learned that a successful ML project depends as much on trustworthy labels, serving constraints, and monitoring as on model choice.
BehavioralMediumDeliverooMachine Learning EngineerBehavioural

5. Tell me about a time you dealt with a challenging situation, such as a tricky stakeholder, conflicting opinions, or a tight timeline.

Model answer

  1. Situation — On a delivery-time prediction project, we were approaching a seasonal launch when the operations stakeholder asked us to include a new set of restaurant-preparation signals. The data science team was concerned that the signals were not stable across markets, while operations felt the model would be inaccurate without them. The launch date mattered because the estimates affected customer expectations and courier planning.
  2. Task — I was responsible for helping the team reach a decision that protected the launch while addressing the operational concern. I needed to make the disagreement concrete rather than let it become a debate about whose intuition was right.
  3. Action
  • I first spoke with the stakeholder to understand the actual failure they were seeing. Their concern was not “we need more features”; it was that estimates were too optimistic for a particular class of restaurants during peak periods.
  • I translated that into a measurable question: did the proposed signals improve error for those restaurants and periods, without making predictions less reliable elsewhere?
  • I proposed a time-boxed offline evaluation using historical peak-period data, with a baseline and the new signals assessed on the same time-based holdout. We also checked coverage and data freshness, not just average error.
  • The first results showed a useful improvement for the target segment, but inconsistent signal availability in one market. I shared the evidence and recommended launching the stable subset behind a market-level feature flag, rather than delaying everything or taking the full change globally.
  • I agreed with operations on monitoring thresholds and a rollback owner. I also made sure the team documented what evidence would justify expanding the feature after launch.
  1. Result — We met the launch date, improved prediction error for the targeted peak-period segment, and avoided relying on a signal that was unreliable in one market. The staged rollout gave the stakeholder a clear path to broader adoption rather than a flat “no.” I learned that conflict often becomes productive when the underlying user or operational problem is separated from the proposed solution.
BehavioralMediumDeliverooDevOps / SREBehavioural interview

6. Tell us about a time when you failed to meet a deadline.

The full question

Tell us about a time when you failed to meet a deadline. What did you fail to do, and what did you learn?

Model answer

  1. Situation — I was responsible for moving several production services onto a new deployment pipeline ahead of a busy trading period. The target date was agreed with the service teams because the existing pipeline was difficult to audit and slower to roll back. I underestimated how much work was hidden in service-specific configuration and alerting.
  2. Task — I owned the migration plan and had committed to completing it before the release freeze. The challenge was balancing that deadline with the need to preserve safe, observable deployments.
  3. Action
  • I initially planned around the pipeline changes themselves and treated service onboarding as repetitive work. In practice, teams had different health checks, deployment permissions, and rollback procedures.
  • When the first integration exposed these differences, I tried to recover by working longer hours rather than revising the forecast. That was my mistake: it delayed an honest conversation and left service owners with too little time to plan.
  • Once I recognized the date was at risk, I told my manager and the affected teams, explained the remaining work, and proposed a smaller milestone: migrate the highest-risk services first, then complete the rest after the freeze.
  • I made the scope visible in a service-by-service checklist, assigned owners for missing readiness checks, and added a documented rollback test as a release gate. I also shared a short daily status update so there were no surprises.
  • We completed the priority migrations safely, but missed the original deadline for the full rollout. I then updated the planning template to include discovery and onboarding effort, rather than estimating only the platform engineering.
  1. Result — The critical services were on the new pipeline before the freeze, and the remaining services were migrated in the next planned window without an incident. I learned that meeting a deadline is not the same as hiding schedule risk: as the owner, I should surface uncertainty early, make scope choices explicit, and protect reliability rather than rely on last-minute effort.
BehavioralMediumDeliverooSoftware EngineerBehavioural interview

7. Can you give an example of when you applied techniques to understand requirements?

Model answer

  1. Situation — In a previous engineering role, I was asked to improve an order-status feature used by customers, support agents, and restaurant partners. The initial request was simply to “make tracking clearer,” but each group meant something different by that: customers wanted to know when food would arrive, while support needed a reliable explanation for delays.
  2. Task — I owned turning that broad request into requirements the team could build and verify. The key constraint was that we had to work with several existing status systems rather than replace them.
  3. Action
  • I began by identifying the users and decisions the feature needed to support. I spoke with support agents, reviewed recent customer complaints, and mapped the current order journey with the product manager.
  • I asked targeted questions about ambiguous cases: What should the customer see if a restaurant has accepted an order but not started preparing it? What happens when an ETA changes? Which system is authoritative if events arrive late?
  • I wrote a journey map and a small set of user stories, with acceptance criteria for normal, delayed, and missing-update scenarios. For example: “When an ETA changes materially, show the revised estimate and explain that it has changed.”
  • I separated must-haves from follow-up ideas, then reviewed the proposed behavior with design, backend, and support. That exposed a dependency on event freshness that had not been in the original request.
  • I documented assumptions and open questions, assigned owners, and used a short prototype review to confirm that the wording and status transitions made sense before implementation.
  1. Result — The team agreed on a smaller, testable first release and avoided building a polished interface on top of unreliable status data. We shipped with clearer delayed-order messaging and tracked support contacts and customer engagement with tracking; the number of avoidable “where is my order?” contacts fell by about 15% in the pilot. I learned to treat requirement discovery as an ongoing conversation, not a hand-off document.
CodingEasyDeliverooSoftware Engineer

8. Logger Rate Limiter (LeetCode)

Model answer

The task

Build a logger that decides whether to print each message. A message is allowed if it has not been printed in the previous 10 seconds.

Key idea

Store the timestamp of the last time each message was accepted. Allow a message when it has never been printed or at least 10 seconds have elapsed since its last accepted print.

Approach

  1. Create a hash map from message text to its last accepted timestamp.
  2. For each request, look up the message’s previous timestamp.
  3. If there is no previous timestamp, or the elapsed time is at least 10 seconds, record the current timestamp and return True.
  4. Otherwise, return False without changing the stored timestamp.
class Logger:
    def __init__(self):
        # Message text -> timestamp of its last accepted print.
        self.last_printed = {}

    def shouldPrintMessage(self, timestamp: int, message: str) -> bool:
        previous = self.last_printed.get(message)

        if previous is None or timestamp - previous >= 10:
            self.last_printed[message] = timestamp
            return True

        return False

Complexity:

  • Time: O(1) average per request for hash-map operations.
  • Space: O(m), where m is the number of distinct messages stored.

Common follow-ups

  • What if requests arrive out of timestamp order? Store timestamp history per message and check whether any accepted print falls within the relevant interval.
  • How can memory use be reduced for a chronological stream? Evict entries older than the rate-limit window, using a queue or time-ordered structure.
  • How would this work across multiple servers? Use shared, atomic state in a distributed store, with a consistent rate-limit operation.
CodingEasyDeliverooSoftware Engineer

9. Find Words Containing Character (LeetCode)

Model answer

The task

Given a list of words and a character, return the indices of all words that contain that character. Keep the indices in their original order.

Key idea

Scan each word once and use string membership to check whether it contains the character. Collect the index whenever the check succeeds.

Approach

  1. Create an empty list for matching indices.
  2. Visit each word together with its index.
  3. Check whether the character occurs in the word.
  4. Add the index if it does, then return the collected indices.
from typing import List

class Solution:
    def findWordsContaining(self, words: List[str], x: str) -> List[int]:
        matching_indices = []

        for index, word in enumerate(words):
            if x in word:
                matching_indices.append(index)

        return matching_indices

Complexity:

  • Time: O(C), where C is the total number of characters examined across the words.
  • Space: O(n) in the worst case for the returned indices, where n is the number of words; excluding the result, O(1).

Common follow-ups

  • What if matches should be case-insensitive? Normalize the words and character before checking membership.
  • What if the query character changes many times? Build a character-to-indices index in one pass, then answer each query from it.
  • What if only the number of matching words is needed? Increment a counter instead of storing indices.
CodingMediumDeliverooSoftware Engineer

10. Design Authentication Manager (LeetCode)

Model answer

The task

Implement an authentication manager that creates tokens with a fixed lifetime, renews valid tokens, and reports how many remain valid at a given time.

Key idea

Keep a hash map from token IDs to nodes in a doubly linked list ordered by expiration time. Since operation times are nondecreasing and every token has the same lifetime, newly created or renewed tokens go at the end; expired tokens can be removed from the front.

Approach

  1. Store each token’s expiration time in a list node, and map its ID to that node.
  2. Before each operation, remove all front nodes whose expiration time is at or before the current time.
  3. For generation, remove any existing node with that ID, then append the new expiration.
  4. For renewal, update only if the token remains in the map after expiration cleanup.
  5. Return the map size for a count request.
class _Node:
    def __init__(self, token_id=None, expiry=0):
        self.token_id = token_id
        self.expiry = expiry
        self.prev = None
        self.next = None

class AuthenticationManager:
    def __init__(self, timeToLive: int):
        self.ttl = timeToLive
        self.tokens = {}

        # Sentinels make insertion and removal uniform.
        self.head = _Node()
        self.tail = _Node()
        self.head.next = self.tail
        self.tail.prev = self.head

    def _remove(self, node: _Node) -> None:
        node.prev.next = node.next
        node.next.prev = node.prev
        del self.tokens[node.token_id]

    def _append(self, node: _Node) -> None:
        last = self.tail.prev
        last.next = node
        node.prev = last
        node.next = self.tail
        self.tail.prev = node
        self.tokens[node.token_id] = node

    def _expire(self, currentTime: int) -> None:
        while self.head.next != self.tail:
            node = self.head.next
            if node.expiry > currentTime:
                break
            self._remove(node)

    def generate(self, tokenId: str, currentTime: int) -> None:
        self._expire(currentTime)

        # Replacing an existing ID is safe, even if IDs are normally unique.
        if tokenId in self.tokens:
            self._remove(self.tokens[tokenId])

        self._append(_Node(tokenId, currentTime + self.ttl))

    def renew(self, tokenId: str, currentTime: int) -> None:
        self._expire(currentTime)
        if tokenId in self.tokens:
            self._remove(self.tokens[tokenId])
            self._append(_Node(tokenId, currentTime + self.ttl))

    def countUnexpiredTokens(self, currentTime: int) -> int:
        self._expire(currentTime)
        return len(self.tokens)

Complexity:

  • Time: O(1) amortized per operation; each token node is removed at most once.
  • Space: O(n), for the currently stored tokens.

Common follow-ups

  • What if operation times are not nondecreasing? Use a min-heap keyed by expiration, with lazy deletion for renewed tokens.
  • What if each token has a different lifetime? Store its calculated expiration; use a min-heap if list ordering can no longer be guaranteed.
  • How should duplicate token IDs behave? Define whether generation replaces the old token or rejects the request.

Practice these out loud, don't memorise them

Reading an answer is not the same as being able to give one under pressure. ChannelPulse plays the interviewer, asks the follow-ups, and scores each answer with feedback and a model answer so you can hear the gap between what you said and what lands.

Get ChannelPulse Browse all questions