I Cracked Twilio HackerRank in 2026: Real Questions and Prep Plan

Quick Facts

I took the Twilio HackerRank assessment in December 2025 for an early career software engineering role. It was two coding questions on one clock. Question 1 ran clean, and Question 2 swallowed most of my remaining time. This guide covers the full walkthrough and my prep.

The switch from Question 1 to Question 2 is where the test got hard. Question 2 was an implementation-heavy transaction API problem with pagination on top of filtering under a tight clock. I used AI interview assistant to sanity-check the paging boundary. It caught the edge case below.

Before my test, I read every Twilio HackerRank post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced, especially the mistakes that get people flagged or rejected.

The Real Questions on My Twilio HackerRank Test

I sat the Twilio HackerRank assessment in December 2025 as an early career software engineer. It was two coding questions on one clock. Before I started, I closed every non-browser window and laid out a two-question plan.

Question 1: Sliding Window Minimum

The problem I got: The first question handed me an array of integers and a window size k. For every consecutive window of k elements, I had to return the minimum value in that window. It was the classic sliding window minimum, dressed up as a transaction style problem.

My approach: I reached for a monotonic deque. As I walked the array, I dropped older indices that left the current window. I kept the deque in increasing order, so the front always held the smallest value in view. The real twist was the window edge handling when the array was shorter than k.

from collections import deque

def sliding_window_min(nums, k):
    dq = deque()
    out = []
    for i, val in enumerate(nums):
        while dq and nums[dq[-1]] >= val:
            dq.pop()
        dq.append(i)
        if dq[0] == i - k:
            dq.popleft()
        if i >= k - 1:
            out.append(nums[dq[0]])
    return out

Time complexity: O(n) | Space complexity: O(k)

Overall, Question 1 ran clean and the timer felt comfortable. I finished the test cases and nothing surfaced to suggest anything was wrong.

Question 2: Transactions API Retrieval

The problem I got: Question 2 was an implementation-heavy question built around a TransactionSpending class. It had to call https://jsonmock.hackerrank.com/api/transactions/search?userId= and pull transaction records for a user. The response used pagination, with a total_pages field telling me how many pages existed.

I had to page through every result. Then I filtered by txnType and by a given month and year. Finally, I averaged the matching amounts and returned the transaction ids above that average.

My approach: I mapped the shape before touching the logic. I fetched page one, read total_pages, then looped across the remaining pages collecting rows where the type and date matched. Once I had the filtered amounts, I would compute the average and keep the ids above it. I had the request and the filter conditions lined up in my head.

import requests

class TransactionSpending:
    BASE = "https://jsonmock.hackerrank.com/api/transactions/search"

    def get_above_average(self, user_id, txn_type, month, year):
        page = 1
        first = requests.get(self.BASE, params={"userId": user_id, "page": page}).json()
        total_pages = first["total_pages"]
        rows = []
        # page through every result, filter by txnType and month/year, average, return ids above

I clicked from Question 1 to Question 2 and hit the pagination wall. The fetch loop came first, then the filter, then the average, and the clock ran thin. I submitted what I had, and the review below covers what I learned.

InterviewFox shows the answer on your phone, not on the shared screen.

Twilio's Proctoring Policy for HackerRank

HackerRank Proctor Mode is the monitoring layer over a Twilio assessment. The chart below lays out every signal it watches.

The monitored violations include tab switching, face detection, webcam object detection, editor patterns, suspicious gaze, and unauthorized tool use. Unauthorized tools ended a December 2025 Twilio attempt.

Proctor Mode docs call it a stand-in . This AI stand-in replaces a live human proctor. It runs at company and test level. Also, any flag produces a report with session replay and flagged events.

What the platform can see. Proctor Mode simulates live proctoring and records behaviors during the test. But the gap most candidates miss is how many signals feed the same report. In short, read how HackerRank detects cheating before you sit down.

What Twilio specifically turns on. Evidence comes from a December 2025 candidate case and the platform docs. Whether it enables webcam, tab-switch, or desktop-process monitoring stays unclear. Twilio publishes no proctoring statement of its own, so I will not claim a Twilio-written policy.

Why "invisible" is the wrong mental model. The process that ended the December 2025 attempt was an overlay-style copilot. It ran outside the browser at low opacity. Yet that contradicts the common assumption that HackerRank only watches the browser tab. It is the exact setup the unauthorized-tool signal targets.

What Twilio's HackerRank Test Format Actually Looks Like

There is no single Twilio OA. The chart below shows how the question mix and clock shift by role and team. Two questions is the near-universal constant, while the type and the time limit are what move.

Two questions is the constant. Across every confirmed account the count holds at two. The clock runs 45 minutes for an intern, 90 for a standard SWE.

Constraints tell you the complexity target. HackerRank problems state bounds that signal the required time complexity. So I read the bounds before choosing an approach.

The difficulty reports genuinely disagree. Some candidates call it basic array manipulation. Meanwhile, intern candidates describe two mediums as far harder. I present the split rather than one average number.

What stays unknown. No confirmed invite link-expiry window exists anywhere in the pool. I say so rather than invent a number. This gap is why the prep plan below runs for seven days.

3 Other Confirmed Twilio HackerRank Questions

Beyond my own sitting, candidate accounts or Twilio-specific primary sources confirm three more Twilio HackerRank questions. Meanwhile, a fourth tier of playlist titles only signals a theme. I keep the distinction honest below.

Question 3: Vanity Number Search

A HackerRank playlist problem asks you to output the subset of input phone numbers that match requested vanity codes. It sits at Medium difficulty, framed as Twilio customers requesting vanity numbers.

Also, Glassdoor's Twilio question page independently lists the same task. A 2020 LeetCode Discuss post asks for numbers containing at least one vanity code such as "TWLO". Three sources converge, so this one carries evidence.

Question 4: SMS Splitting

A Medium problem in the same playlist splits a message into SMS-standard-length segments. Nine segments is the cap. The character set stays at A-Z, a-z, spaces, commas, and periods. Glassdoor's page describes the identical task, so two sources back this one.

Question 5: React Feature Build

A Blind post from April 2022 describes the Segment team L3 OA. The second question was not a LeetCode problem but a ReactJS starter app. It asked me to implement two features plus some styling fixes.

Two extra features handled sorting and filtering the rendered content. This is a single strong first-person source, so I mark it evidence-backed.

Demo-Playlist Titles Signal Theme, Not a Leak

The HackerRank Twilio playlist also lists K-Subarrays, Coding Friends, and Subarray with Given Sum as theme signal only. No candidate account names these specific titles, and the playlist carries a demo label. It works as platform-published prep material, not a leak of a live test.

One circulating GitHub file, Twilio_DSA.md, listed FizzBuzz, array to BST, intersection of string lists, and symmetric tree. That file now returns a 404, and I could not locate a live primary source. I do not present those as confirmed questions.

How Twilio's HackerRank Scoring Works

Twilio runs the HackerRank scoring engine without publishing its own pass bar. The chart below maps each score state to what actually happened to candidates. The mechanism never changes, while the outcomes vary by how completely you finished.

Each challenge carries a 100-point Max Score. HackerRank sets that number per problem. Published success rates on the Twilio challenge set sit between roughly 63 and 88 percent.

Aim for full test cases, not a passing fraction.

For example, one April 2022 candidate failed some Q1 test cases and ran out of time before Q2. The verdict came back REJECTED.

Partial credit alone did not advance them. See the Twilio L3 OA reject. It reads as a dated first-person account.

A flag is a different failure state than a low score.

A proctoring flag skips scoring entirely: no partial credit, nothing submitted, nothing to appeal.

The exact threshold stays unpublished.

Twilio does not release a minimum score, so I will not invent one or imply it exists.

Twilio HackerRank Exam-Day Strategy

Generic time-management advice would not earn this section. Three named, sourced specifics do, and each maps to a real failure or friction report.

Clear Every Overlay Tool Before the Q1 to Q2 Switch

A December 2025 candidate report froze the instant they switched problems while a low-opacity desktop copilot was open. Nothing overlay-based or desktop-resident survives a question switch. So I now close every second window before I move on.

Reveal Test Cases First, Then Budget for Boot Time

A Blind Segment L3 report notes the HackerRank UI hides test cases and explanations behind clicks. The JavaScript input-format handling was awkward. A React app took over a minute to boot inside the 60-minute limit.

I spend the first minutes on the interface and input format. Still, I treat boot time as a budgeted cost.

A Hard Per-Question Cap Prevents the Q1 Time Sink

A 2022 LeetCode Discuss account says the author exhausted most of the time on Q1. Thus they could not finish Q2 and received a REJECTED verdict. I cap Q1 and move on with it imperfect, because an unattempted Q2 was part of a real rejection.

Why Candidates Fail the Twilio HackerRank Assessment

Two failure modes carry named, dated causes. The first is the strongest available evidence of what an AI tool actually costs you on this test.

An Unapproved Desktop Process Voids the Attempt

One candidate report from December 2025 kept a desktop copilot window set to low opacity open. When they switched to Question 2, the editor froze and a proctoring message named an unapproved desktop process. Their attempt ended before submission, and the system issued no score.

The same navigation layer that logs a tab change caught their problem switch. See how HackerRank sees tab switches for the recording details.

Low opacity did not help.

The window was nearly invisible, and the proctoring layer still named it as an unapproved process. It happened the moment they changed problems.

It was not even in the browser. The tool ran outside the open tab. But that contradicts the widespread assumption that HackerRank proctoring only watches browser activity. Unauthorized tool use counts as an explicitly monitored violation. HackerRank's detection uses external tool usage patterns, typing cadence, and behavioral anomalies to flag it.

Partial Test Cases on Q1 Produced a Reject

Also, a 2022 LeetCode Discuss account failed some Q1 test cases and ran out of time before Q2. Still they received a REJECTED verdict. This is the clearest public failure with a named cause in the pool.

Environment Friction Burns the Same Clock

A Blind Segment L3 report lists hidden test cases and JavaScript input-format friction. Also, a React app took over a minute to boot inside 60 minutes. No one reported it as a rejection. Still, it leads to the same outcome as the Q1 time sink above.

How to Prepare for the Twilio HackerRank in 7 Days

Overall, the plan below binds every stage to a confirmed Twilio fact. It skips what the evidence says you will not face. Seven days is a flat window because no confirmed link-expiry exists to subtract a buffer from.

Days 1-3: Sliding Window to Full Test Cases Under 25 Minutes

I spent the first three days on sliding-window, subarray, and array-hashmap manipulation taken to full test-case coverage. The Q1 pattern is Sliding Window Minimum, with Sliding Window Maximum as the practice analogue. A candidate who sat the exam named that pattern directly.

I ran timed two-pointer sets and pushed every run to full coverage. That meant empty input, a single element, duplicates, and maximum-constraint cases. My success check was a medium sliding-window problem solved twice in 25 minutes or less.

I skipped system design. Every confirmed Twilio OA account is two coding or app-building questions inside 60 to 90 minutes. Not one contains a system-design task, so it belongs to later rounds.

I also skipped deep graph, tree, and DP grinding. Every confirmed question clusters on arrays, strings, hash maps, sliding window, or API and JSON handling. Only tree signals in circulation come from a 404 GitHub file I could not verify.

Days 4-5: Vanity Codes, SMS Limits, and Paginated JSON

Days 4 and 5 covered Twilio's domain wrappers. That means vanity-code matching, SMS segmentation, and paginated retrieval against a mock JSON API. Algorithms stay ordinary, but the domain wrapper is what makes them slow to parse under the clock.

I implemented one vanity-code matcher, one SMS splitter, and one paginated fetch-filter-average against a mock API. The splitter honored the nine-segment and character-set limits. My success check required solving the paginated problem end to end in 30 minutes or less without opening docs.

Days 6-7: One-Window 90-Minute Run With No Overlay Tools

Those final two days made one full timed run in a clean single-window environment. Only one failure mode in the whole pool costs the entire attempt with no score: an overlay tool. Friction that ate a real candidate's budget is the same reason to rehearse the interface.

I ran two questions in 90 minutes on one display with no second application open. I started by revealing test cases and reading the input format. My success check was attempting both problems inside 90 minutes with zero non-browser windows open for the whole run.

What Happens After You Submit the OA

In short, a pass and a flag lead to opposite places. The wait between submission and response is wide. Silence at two weeks is inside the normal range.

A pass moves you to a recruiter call, then the technical loop.

From there the process continues into the later rounds, including the values round later on.

A flagged attempt produces no score and no advance.

This closes the loop opened in the proctoring, scoring, and failure sections. A flag voids the attempt entirely.

The range is wide and the silence is normal.

Reported wait times run from two days to over two weeks. The whole process averages about 25 days across more than 1,200 reported interviews. That figure is process-level rather than OA-specific.

Twilio's OA Wraps DSA in Its Own Messaging Domain

The recurring twist on this test is that ordinary algorithms arrive wearing Twilio's product surface.

The problems are wearing Twilio's product.

Vanity phone numbers, SMS segmentation, and transaction API retrieval show up across four independent sources. Those sources are HackerRank's Twilio playlist, Glassdoor, a 2020 LeetCode Discuss post, and the 2022 transactions problem.

The algorithm is usually familiar, the wrapper is what costs time.

Subset matching, string segmentation, and paginated fetch and filter are standard. Parsing the domain framing under a 60 to 90 minute cap is the real difficulty. That is why the vanity and SMS practice days exist in the plan.

Difficulty gradient across the themed set.

The playlist's published success rates run from 88.08 percent for Vanity Number Search. They drop to 62.57 percent for K-Subarrays. These are HackerRank-wide practice success rates, not Twilio candidate pass rates. I do not present them as a bar you must clear.

FAQ

Is the Twilio HackerRank OA proctored?

Yes in capability. HackerRank Proctor Mode monitors unauthorized tools, tab switching, and webcam signals. The December 2025 case shows a Twilio attempt that got flagged and ended. Twilio itself does not publish its per-invite configuration.

Can I use an AI tool or invisible app during the Twilio HackerRank OA?

Desktop overlay tools put the AI's answer on your computer screen, rendered as a hidden layer above the browser. The hiding is basic, and proctoring software keeps adding detection capabilities as AI tools become more common. So the risk exposure never stays fixed.

InterviewFox pushes the answer to your phone, a physically separate device. No screenshot, screen recording, or session monitoring can reach it by design. The laptop screen stays on the exam editor, unchanged. If you use AI during the OA, the answer leaves your screen entirely.

How long is the Twilio HackerRank OA?

Two questions in 60 to 90 minutes for standard SWE roles. Some team variants run 60 minutes, and intern OAs run 45 to 60 minutes.

Is the intern OA different from the full-time OA?

Yes. Intern reports describe one Easy plus one Medium in 45 to 60 minutes. Full-time roles get two medium DSA questions in about 90 minutes. The format chart above breaks it down by role.

How long does Twilio take to respond after the OA?

Reported response times run from two days to over two weeks, with the whole process averaging roughly 25 days. None of these is a Twilio service commitment, so treat the timeline as a range, not a promise.

What happens if a proctoring flag fires mid-test?

The attempt can end before submission, with no score issued at all. That is a different and worse outcome than a low score, and it comes from the December 2025 case.

Does passing the OA lead straight to an interview?

It leads to a recruiter call and then the technical loop, with the values round later in the process. The full loop is beyond the scope of this guide.