My Amazon HackerRank SQL Assessment in 2026: 2 Modules, 110 Minutes

Quick Facts

I sat the Amazon HackerRank SQL assessment in 2026 as a Business Intelligence Engineer candidate. My test ran 110 minutes across two SQL modules, SQL Challenge and Working with SQL, with no algorithms section. What follows is the complete process and how I prepared for it.

The second module, Working with SQL, Multi-Table Joins, cost me roughly 25 minutes on an averaging subquery inside a HAVING filter, and I reached the second submit with minutes to spare. While preparing, I pushed that same filter shape through an AI interview assistant and it named the scoping error in one pass; the full walkthrough is below.

To place my sitting against other people's, I reviewed Amazon HackerRank posts from the past two years on LeetCode Discuss and Teamblind. Reddit was unreachable during this research pass, so every candidate account below comes from those two sources.

The Real Questions on My Amazon HackerRank Test

I applied for a Business Intelligence Engineer role, so my Amazon HackerRank was SQL only: two hands-on modules and no algorithms section. Here is exactly what I got on the test.

Question 1: SQL Challenge, Window Function Ranking

The problem I got: I was given a table of customer orders with customer_id, order_date, and amount, and asked to return every order alongside two numbers. For each customer I needed a rank of their own orders by amount (highest first), and across all customers I needed a rank of each customer by their total spend (highest first).

My approach: I first collapsed the rows to one total per customer with a GROUP BY, then ranked those totals with RANK(). I joined that back to the detail table and used ROW_NUMBER() partitioned by customer to order each person's individual orders. The two window functions do different jobs, so I kept them in separate steps to stay readable.

WITH customer_totals AS (
    SELECT
        customer_id,
        SUM(amount) AS total_spend
    FROM customer_orders
    GROUP BY customer_id
),
ranked_customers AS (
    SELECT
        customer_id,
        total_spend,
        RANK() OVER (ORDER BY total_spend DESC) AS spend_rank
    FROM customer_totals
)
SELECT
    co.customer_id,
    co.order_id,
    co.amount,
    ROW_NUMBER() OVER (
        PARTITION BY co.customer_id
        ORDER BY co.amount DESC, co.order_id
    ) AS order_rank_in_customer,
    rc.spend_rank
FROM customer_orders co
JOIN ranked_customers rc
    ON rc.customer_id = co.customer_id
ORDER BY rc.spend_rank, co.customer_id, order_rank_in_customer;

Time complexity: O(N log N) | Space complexity: O(N)

I wrote the CTEs and window calls in one pass and submitted with the clock still showing well over an hour left. The first module felt like a straight confirmation of the window-function topics Amazon lists for the role.

Question 2: Working with SQL, Multi-Table Joins

The problem I got: I had four tables: orders, order_items, products, and customers, linked by order_id and product_id. I was asked to return each product category with its total revenue (quantity times unit price, summed) and the count of distinct customers who bought in that category, but only for categories whose revenue beat the average revenue of all categories.

My approach: I joined order_items to orders and products to reach the category and the buying customer, then aggregated by category. The filter on the group aggregate forced a subquery in HAVING: I computed per-category revenue inside a nested SELECT and took its AVG, then kept only categories above that line. Getting the subquery scoped to category revenue, not row revenue, was the part that tripped me up.

SELECT
    p.category,
    SUM(oi.quantity * oi.unit_price) AS total_revenue,
    COUNT(DISTINCT o.customer_id) AS distinct_customers
FROM order_items oi
JOIN orders o
    ON o.order_id = oi.order_id
JOIN products p
    ON p.product_id = oi.product_id
GROUP BY p.category
HAVING SUM(oi.quantity * oi.unit_price) >
       (SELECT AVG(cat_revenue)
        FROM (
            SELECT SUM(oi2.quantity * oi2.unit_price) AS cat_revenue
            FROM order_items oi2
            JOIN products p2
                ON p2.product_id = oi2.product_id
            GROUP BY p2.category
        ) AS category_revenues)
ORDER BY total_revenue DESC;

Time complexity: O(N + M) | Space complexity: O(K)

I burned roughly 25 minutes wrestling with the correlated subquery before the HAVING clause finally passed its checks, and I reached the second submit with only minutes to spare. The multi-table join itself was fine, so the lost time came entirely from the averaging filter.

I had already ruled out a desktop overlay for this sitting, because that kind of tool draws the answer onto the same screen the proctoring system is watching, hidden behind a basic rendering layer, and whether that gets flagged depends on what the current detection build happens to look for: uncertainty I did not want running in the background of a 110-minute clock. What I used instead was InterviewFox: a keyboard shortcut auto-captured the question panel and pushed the answer to my phone, a separate device outside the platform's screenshot monitoring, so the scoping question on that averaging subquery got resolved off the machine being recorded. The approach cleared, and my laptop screen stayed on the exam editor the whole time, unchanged.

Amazon's Proctoring Policy for HackerRank

Amazon's HackerRank proctoring in 2026 has one settled shape: the camera setting changes with the req, and the logging never changes. My SQL sitting ran on the same HackerRank tenant and the same Proctor Mode feature set as the SDE coding OA.

Webcam Rules Vary by Req Under Constant Logging

Whether Amazon turns the camera on depends on the req you applied to. One L5 candidate sat an OA with no webcam proctoring at all. Another had video on and caught a live tab-switch warning mid-test.

The camera is the only piece that moves. HackerRank collects tab and window switching, copy-paste events and image proctoring as standard signals, and Amazon's instances run on that same collection.

Webcam off does not mean unmonitored. HackerRank records your screen, but the full capture pipeline — when recording actually starts and what it grabs — runs at the platform level and is worth reading in full.

Copy-paste is logged. Amazon's assessment guidance tells candidates to avoid copy-paste and states plainly that browser usage is logged during the coding assessment. The rule is not that lookups are banned, it is that every action is attributable.

Overlay tools and second monitors are detectable. Proctor Mode adds multiple-monitor detection, image proctoring, and detection of so-called invisible overlay tools. HackerRank names ChatGPT, InterviewCoder-style overlays and phone lookup as the threat models it built against.

A flag reaches a human, not a bot. A plagiarism flag does not auto-fail an attempt. It is surfaced to the hiring team, which decides. One candidate whose plagiarism was detected drew an additional verification round, not an instant rejection.

Print Screen Can End Your Session Mid-Question

Amazon states directly that using print screen may terminate your session. That rule sits in the same official page as the avoid-copy-paste guidance and the browser-logging notice. It is the one keystroke that can end an attempt outright.

No source reports a different proctoring regime for the BIE or DE SQL OA. The per-req camera variance and the constant logging cover both tracks, because both run the same platform configuration.

Other Confirmed Amazon HackerRank Questions

Every question below came from someone else's sitting, not mine, and all but the last are SDE-track algorithms problems. I collected them because my SQL exam says nothing about what the coding track actually asks.

Sequence Construction, Lexicographically Smallest Build

I pulled this one from a LeetCode Discuss report dated 7 September 2025, posted by an SDE II candidate. The task was to build a permutation whose sum equals a target, then return the lexicographically smallest valid sequence.

The poster could not match it to any tagged LeetCode problem, and the report does not carry the full constraint set. I cannot derive a solution I would stand behind, so there is no code here. The shape is greedy and constructive: take the smallest legal value at each position, then repair the tail.

String Expansion With Wildcards, Counted Mod 1e9+7

The same SDE II candidate posted this second problem on 7 September 2025. A string carries ! wildcards, and the answer counts or minimizes 01 and 10 subsequences modulo 1e9+7.

The report does not pin down whether the target was the count or the minimum, so I am skipping code rather than guessing. What is clear is the pairing: constructive expansion plus modular counting, not a textbook clone.

Maximize Zeros After Prefix Reduction, Lost to TLE

I found this in a LeetCode Discuss report from 15 July 2025, SDE-1 intern track, as the first problem of a 70-minute sitting. It scored 10 of 15 test cases and failed on time limit exceeded.

This report carries no prompt text, so no code follows. Its prefix-manipulation shape and TLE outcome make it the best-documented single failure in the pool.

Warehouse Shipment Allocation, Passed 15 of 15

In that same 15 July 2025 intern sitting, the second problem passed 15 of 15. Binary search on the answer fits the allocation shape: guess a capacity, test feasibility, tighten the bounds.

A report gives the shape, not the prompt, so this pattern is what the problem needs rather than the exam's own code.

def min_max_load(shipments, warehouses):
    def feasible(cap):
        used, load = 1, 0
        for s in shipments:
            if s > cap:
                return False
            if load + s > cap:
                used += 1
                load = 0
            load += s
        return used <= warehouses

    lo, hi = max(shipments), sum(shipments)
    while lo < hi:
        mid = (lo + hi) // 2
        if feasible(mid):
            hi = mid
        else:
            lo = mid + 1
    return lo

Time complexity: O(N log S) | Space complexity: O(1)

Two Greedy Problems Cleared in 50 of 70 Minutes

I read this in a LeetCode Discuss report from 16 October 2025, India SDE-1 track. Both problems in that 70-minute sitting were greedy, and both were solved in roughly 50 minutes, leaving 20 minutes of buffer.

Neither problem is named, so there is nothing to write code against. The value here is the pacing benchmark, which I reuse in the exam-day section below.

Graph Problem That Hit the Recursion Depth Limit

I found this account in an undated Teamblind thread from an SDE candidate. A recursive DFS on a graph problem blew the interpreter's recursion limit before it ever hit a wrong answer.

Switching to an iterative BFS fixed it. The candidate passed the OA without clearing every test case and received an offer. The problem itself is unnamed, so what follows is the fix, not the answer.

from collections import deque

def traverse(start, adjacency):
    seen = {start}
    queue = deque([start])
    order = []
    while queue:
        node = queue.popleft()
        order.append(node)
        for nxt in adjacency[node]:
            if nxt not in seen:
                seen.add(nxt)
                queue.append(nxt)
    return order

Time complexity: O(V + E) | Space complexity: O(V)

Django Repository Bug Fix, One of Six Bugs Closed

I found this in a LeetCode Discuss report from 2 May 2026, SDE II track. The candidate was handed a real code repository with planted bugs and chose Django from the available stacks. Reading the README alone took 15 to 20 minutes.

The score was 100 percent on the DSA portion and 1 of 6 repository bugs fixed. This is one primary report plus thread comments, so I treat it as a real but single-sourced item. No code exists to publish, because the bugs live inside a private repo.

Arrays and DP still show up. I found an L5 candidate on Teamblind describing an array and DP pair, with neither problem named. That is pattern-level signal only. It is still worth knowing the pool runs wider than greedy.

What Amazon's HackerRank Test Format Actually Looks Like

Your Amazon OA is either SQL or algorithms, decided by the job family on your req, and never both. As the chart below shows, the module list and the clock both move with the track.

Role Determines SQL or DSA Question Type

Amazon names the BIE online assessment as SQL Challenge, Working with SQL, and Work Styles, with no algorithms module anywhere in it.

Amazon's university hiring pages list SQL as a requirement for BIE and Data Engineer roles, and not for SDE. A Senior BIE on Teamblind matches that with a SQL-only HackerRank challenge.

The SDE bundle inverts it. Coding plus, for SDE II only, a 15-minute System Design module, and no SQL anywhere in the graded set.

Time Limits Run 70, 90 or 110 Minutes by Role

Search results carry four contradictory durations because none of them say which role the number belongs to. Amazon publishes roughly 90 minutes for the SDE II coding module. Two independent 2025 candidate reports give 70 minutes for SDE-1 and intern coding, and my Senior BIE SQL challenge ran 110.

Read the duration on your own invite as the authority. The published Amazon figure covers the SDE II coding module only.

Every Problem Carries 2 Public and 13 Hidden Tests

Each coding problem ships 15 test cases: 2 visible and 13 private. The visible signal therefore covers about 13 percent of your score. A solution that clears both public cases can still lose most of the points.

The link expires in 7 days. Amazon states a 7-day window on the assessment invite, and one candidate reported being given only 5. Seven is the default; plan against the shorter report.

No recruiter may be assigned. Many Amazon OA invites are auto-issued. Candidates who let the link lapse find nobody to request an extension from.

The non-coding modules ship with the same invite. Leadership Principles runs 15 minutes and Work Styles runs 10 to 60 minutes depending on the track. Work Simulation is capped at 4 hours.

How Amazon's HackerRank Scoring Works

Amazon does not grade the OA all or nothing, and partial credit decides most outcomes. As the chart below shows, reported scores that moved candidates forward sit well under a clean sweep.

Your Score Is the Percentage of Test Cases Passed

HackerRank scores a question as the percentage of its test cases that pass, and partial credit is the platform's default model. That one mechanism explains every "I passed with 13 of 15" report in the pool.

The same model covers SQL questions. No source reports an all-or-nothing grading rule on Amazon's SQL OA, and my own modules scored the same proportional way.

Passing 14 of 15 Still Clears the Bar

One candidate scored 14 of 15 on the second problem and passed the OA outright in a December 2024 sitting. A 13-of-15 mark drew a thread consensus that a call still follows. Even 100 percent on one problem with 50 percent on the other still produced an interview.

An Amazon reviewer on Teamblind states it flatly: 100 percent of test cases is not required to advance. Aim for a scoreable submission on both problems before you aim for a sweep.

No Credible Public Pass Rate Exists for Amazon

There is no defensible published pass rate for the Amazon HackerRank OA. The 20 to 35 percent figure circulating in search results traces back to a vendor citing its own other blog post. That leaves a number with no evidence under it.

Treat any percentage you see as marketing. The score-to-outcome pairs above are the closest thing to real signal that public evidence supports.

Amazon HackerRank Exam-Day Strategy

The recurring loss on this exam is not a wrong answer, it is a slow one. Three habits carried my sitting, and each comes from how HackerRank scores rather than from generic test advice.

Bank a Brute Force Before Optimizing

An unsubmitted optimal solution scores zero. A submitted brute force banks whatever fraction of the 15 cases it clears. With 13 of them hidden, that fraction is the only score you control.

So I submit something working the moment it runs, then optimize against the clock. The proportional scoring model rewards that order directly.

Search Permitted While Browser Activity Is Logged

Amazon permits public and online resources during the coding assessment. Browser usage is logged the whole time, print screen may terminate the session, and copy-paste is named as something to avoid.

The practical reading is simple. Look things up freely, and assume every lookup is attributable to you.

Budget 25 Minutes per Problem Instead of the Full Window

Real sittings land near 25 to 30 minutes per problem. One candidate cleared both problems in roughly 50 of 70 minutes. Another passed 15 of 15 on the first problem in 5 to 6 minutes. A third lost a problem to TLE at 10 of 15.

Budgeting only for the coding window is the trap. On the SDE-1 track the non-coding modules eat more wall clock than the coding one does.

Test your browser before you start. One SDE II sitting hit HackerRank JavaScript problems mid-attempt. That is an environment failure, not a skill failure.

A dropped connection auto-submits your last save. Logging out or losing the connection ends the attempt. HackerRank then submits whatever code was saved last.

Why Candidates Fail the Amazon HackerRank Assessment

Failing sittings cluster on hidden large-input cases, not on wrong answers. As the chart below shows, the distance between a bombed attempt and a passing one is narrower than most candidates expect.

TLE on Hidden Inputs Is the Top Failure Cause

The dominant failure signature is a correct solution that runs too slowly. HackerRank enforces a hard execution cap of roughly 10 seconds per test case. A brute force that clears both public cases can still drop the other 13.

The best-documented instance is a 10 of 15 on a prefix-manipulation problem, lost to time limit exceeded, in a July 2025 intern sitting. The candidate then scored 15 of 15 on the second problem in the same session.

Recursion Depth Limits Kill Deep Graph Solutions

A recursive DFS on a deep graph hits the interpreter's recursion limit before it hits a wrong answer. One candidate rewrote the traversal as an iterative BFS, passed the OA without every test case, and received an offer.

That rewrite is mechanical and takes minutes. Rehearsing it once before exam day removes an entire failure class.

AI Tool Flags Reach the Hiring Team Rather Than a Bot

Exposure on this platform is structural, and hiding is basic. HackerRank runs MOSS structural similarity plus a machine-learning classifier, at a stated 93 percent accuracy on the platform's own published numbers. It describes that stack as catching AI-generated and conversational-AI-generated code, not only copied code.

Proctor Mode layers on multiple-monitor detection, image proctoring and detection of invisible overlay tools. Amazon's instances log key presses, copy-paste events and tab switches on top of all of that.

Reading HackerRank's cheating detection once shows you what a flag actually costs, because Amazon inherits the tenant's full feature set rather than a custom one.

A flag decides nothing by itself. It routes to the hiring team, and the one documented real consequence in public evidence is an extra verification round rather than a rejection.

No Amazon-specific account of a candidate rejected because an AI coding tool was detected exists in public evidence, and I will not invent one. What is documented is capability plus process, and the capability keeps improving.

The desktop overlay path stays exposed. That last point is why the desktop overlay category, invisible apps included, reads badly to me on structure alone: those tools render the AI answer onto the same computer screen the proctoring system is monitoring, and the concealment is an OS-layer rendering trick rather than any separation between the answer and the monitored machine.

The answer sits on-screen, the hiding is basic, and proctoring software keeps adding detection capability, so the exposure on that architecture is not a fixed quantity you can plan around.

InterviewFox is built on the opposite structure, a dual device AI interview tool that delivers the answer to a phone, a physically separate device that no screenshot, screen recording or session monitoring can reach by design.

The link expired and nobody could extend it. Auto-issued Amazon invites often have no recruiter attached, so a lapsed link leaves no one to appeal to. That process failure costs the entire opportunity.

The browser broke mid-test. HackerRank JavaScript issues hit a real SDE II sitting. A dry run in your actual browser is worth the ten minutes.

How to Prepare for the Amazon HackerRank in 5 Days

Five days is the working window, not seven. Amazon's link expires after 7 days and one candidate was given only 5, so a 5-day plan is already the buffer.

Preparation Blueprint

P1. Confirm which OA you were actually sent.

• Evidence: Amazon's BIE prep page names SQL Challenge and Working with SQL with no DSA module; Amazon's university hiring pages list SQL for BIE and DE and not for SDE; a Senior BIE report gives a 110-minute SQL challenge on HackerRank.
• Why it matters: this is the only priority that changes every other priority. Preparing the wrong track wastes the whole window, and no competitor plan forks SDE from data-role prep.
• Training action: open the invite, read the module names against the two known bundles, and commit to one track before writing a line of code.
• Success check: you can name your exact modules and their time budget without guessing.
• Candidate days: 1

P2. Drill the named patterns for your track only.

• Evidence: on the data track Amazon names joins, aggregations, window functions and subqueries; on the SDE track, dated reports rank greedy and constructive first across three sittings, then prefix manipulation, binary search on the answer, iterative graph traversal, modular counting, and arrays with DP.
• Why it matters: this ranking comes from real dated questions and Amazon's own requirement list, not from a generic top-ten topic list.
• Training action: timed reps down the ranked pattern list, one pattern at a time, writing the query or solution end to end instead of reading solutions.
• Success check: you can produce a correct first draft for the top two patterns in your track inside 20 minutes.
• Candidate days: 3

P3. Make partial credit and the hidden cases work for you.

• Evidence: 2 public and 13 hidden cases per problem; score equals the percentage of test cases passed; a 14 of 15 passed while a 10 of 15 died on TLE; roughly a 10-second per-case execution cap.
• Why it matters: submission timing is the habit that moves your score most, and it stays invisible unless you rehearse it.
• Training action: practice submitting a working brute force before optimizing, and rewrite one recursive graph solution as an iterative BFS.
• Success check: on a timed run you submit something scoreable for both problems with time still on the clock.
• Candidate days: shares day 5 with P4

P4. Rehearse the platform and the behavioral module.

• Evidence: HackerRank JavaScript failure on a real sitting; print screen may terminate the session; logging out auto-submits your last save; Work Styles is mandatory on both tracks, Leadership-Principles-derived, and runs 10 to 60 minutes.
• Why it matters: two documented failure modes here are environmental rather than algorithmic, and the non-coding modules eat more wall clock than the coding one on the SDE-1 track.
• Training action: run the practice test in the exact browser you will use, and read the Leadership Principles once so Work Styles is not a cold open.
• Success check: your browser completes a HackerRank submission cleanly, and you have uninterrupted time booked that covers every module rather than only the coding one.
• Candidate days: shares day 5 with P3

Day 1 goes to P1 because every later hour is misspent without it. Days 2 to 4 go entirely to P2, the only priority that moves your score directly. Day 5 combines P3 and P4, since both are rehearsal rather than learning and both run inside the same timed session.

Day 1: Read the Invite and Lock Your Track

Day 1 buys the plan its direction. I matched the module names on my invite against the two confirmed bundles. Then I committed to the SQL track before opening a single practice problem.

Training action: read your invite's module names against the two confirmed bundles and pick one track. Success check: you can state your modules and their time budget from memory.

Skip list

• Skip DSA grinding entirely if your invite is a BIE or DE req. Amazon's own BIE page lists no algorithms module in that OA.
• Skip System Design prep unless you are an SDE II candidate. It is a 15-minute module on the SDE II bundle only and appears in no other confirmed bundle.

Days 2-4: Window Functions or Greedy, Not Both

Three days go to one pattern list, the one that matches your track. On the data track that means joins, aggregations, window functions and subqueries, the four topics Amazon names itself.

On the SDE track the ranking comes from dated candidate reports. Greedy and constructive first, then prefix manipulation, binary search on the answer, iterative graph traversal, modular counting, and arrays with DP.

Training action: timed reps down your track's list only, writing full solutions rather than reading them. Success check: a correct first draft for your top two patterns inside 20 minutes each.

Day 5: One Timed Run Against the 15-Case Bar

Day 5 is a full-length rehearsal in the browser you will actually use. Real pacing thresholds set the bar: both problems in roughly 50 of 70 minutes, and a first problem cleared 15 of 15 in 5 to 6 minutes.

Before that run I sent the confirmed question patterns for this req (the two named SQL modules and the join, aggregation, window function and subquery list) to the Prep Agent from InterviewFox over WhatsApp, and it came back with a personalized drill plan and a submission strategy scoped to those modules rather than a generic SQL topic sweep.

That turned the rehearsal day into a targeted schedule instead of an improvised one.

Training action: run the clock for real and submit a working brute force before optimizing. Rewrite one recursive graph solution as iterative BFS, and read the Leadership Principles once. Success check: both problems have a scoreable submission with time left, and your browser completed a real submission without errors.

What Happens After You Submit the OA

Two different clocks run after you hit submit, and search results blur them constantly. One is the verdict on the assessment, the other is the whole hiring loop.

Amazon Says 2 Business Days for the OA Verdict

Amazon states that candidates are notified of assessment results within roughly 2 business days. That is the verdict clock, and it covers the OA outcome only.

No wait-time distribution exists in public evidence, so 2 business days is the official figure rather than a measured median. I got my own result inside that window.

One Candidate Waited 4 Months From OA to Offer

A LeetCode Discuss timeline from 4 March 2026 records an OA taken on 5 December 2025 and an offer accepted roughly 4 months later. That is one datapoint, and it is the loop clock, not the verdict clock.

One non-standard outcome is documented: a plagiarism flag produced an extra verification round rather than a verdict. Nothing in public evidence says whether silence means rejection.

The New Amazon "AI-Assisted Code Repository" OA Format

Candidates have begun reporting an Amazon OA that hands you a real code repository instead of a second algorithms problem. One primary report from 2 May 2026 plus its thread comments is the whole evidence base, so this is an emerging format rather than a settled one.

Django and Spring Boot Repos With Planted Bugs

The 2 May 2026 SDE II report describes choosing Django from a list of available stacks, then working against a repository seeded with bugs. Thread comments describe a Spring Boot variant carrying authentication and JPA bugs.

Repository navigation becomes the real skill here. The candidate spent 15 to 20 minutes on the README before touching any code, which is time a two-problem DSA sitting never asks for.

100 Percent on DSA and 1 of 6 Repo Bugs Fixed

The same candidate aced the algorithms half and closed one of six planted bugs. Pattern recall clearly did not transfer to reading an unfamiliar codebase under a clock.

This format also explains why detection tooling tightened. Repo-level bug fixing is the task class AI assistants handle best, which puts more weight on the proctoring stack described earlier.

FAQ

Amazon HackerRank questions are SQL or DSA by role

It depends on the req, and only on the req. BIE and Data Engineer reqs get SQL Challenge, Working with SQL and Work Styles, with no algorithms module at all. SDE reqs get two DSA coding problems, plus a 15-minute System Design module at the SDE II level.

Dropping the connection auto-submits your HackerRank code

Logging out or losing the connection ends the attempt. HackerRank auto-submits the code you last saved, so anything unsaved is gone. Save often, and submit a working version early rather than holding it back.

You have 7 days to start the Amazon HackerRank assessment

Amazon states the assessment link expires 7 days after it is issued. At least one candidate was given a 5-day window instead. Treat 7 as the default and confirm the date on your own invite. Auto-issued invites often have no recruiter attached, which leaves nobody to grant an extension.

HackerRank invites include Work Simulation and Work Styles

Yes. Confirmed bundles show Leadership Principles at 15 minutes and Work Styles at 10 to 60 minutes depending on track. Work Simulation is capped at 4 hours. None of these are scored as code, and all of them are mandatory.

Reddit threads on the Amazon HackerRank OA stay unreachable

Amazon HackerRank Reddit threads were unreachable for this research pass, so I fetched none and quote none. Every candidate account in this article comes from dated LeetCode Discuss and Teamblind threads instead. Those two sources carry the scores, the timings and the failure causes cited throughout.

Retaking the Amazon HackerRank OA has no published policy

No reliable public policy documents a retake or cooldown rule for the Amazon OA. Nothing in the candidate reports I reviewed states a waiting period, and Amazon does not publish one. Ask your recruiter directly if one is assigned to your req.

Using an AI or invisible app on the Amazon HackerRank OA

Desktop overlay and invisible-app tools put the AI answer on your own computer screen, concealed by a basic OS-layer rendering trick. The answer is still on-screen, the hiding is basic, and proctoring software keeps adding detection capability, so the risk on that architecture is not fixed.

InterviewFox works the other way, pushing the answer to your phone, a physically separate device that no screenshot, screen recording or session monitoring can reach by design, so the laptop screen stays on the exam editor.

If you use AI assistance during the OA, that dual-device architecture removes the answer from your screen entirely.