I Passed the Amazon CoderPad OA in 2026: Real Questions

Quick Facts

I took the 2026 Amazon SDE online assessment that candidates reach by searching amazon coderpad. I chose Java and solved both coding problems in the block. What follows is the complete process and how I prepared for it.

I lost close to twenty minutes on the supplier-profit question after a max-heap attempt timed out. I used dual device real time AI interview helper to check the shortcut. The fix landed on my phone, a separate device, so the captured screen stayed clean. It surfaced the band-sum approach I break down below.

Before my test, I went through every Amazon CoderPad post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced. The sections below cover the traps, particularly the integrity rules that end a candidacy.

The Real Questions on My Amazon CoderPad Test

Here are the exact questions from my Amazon CoderPad OA, in the order I got them. It was the asynchronous coding assessment, not a live round with an interviewer present, and it held two problems: a pure algorithm question and an AI-assisted debugging task.

Question 1: Supplier-Profit Inventory

The problem I got: The platform dropped me into a Java editor with one method to fill in: long highestProfit(int numSuppliers, List<Long> inventory, long order). I had the supplier count, each supplier's stock level, and the number of items I had to sell. Selling one item paid out that supplier's current level and dropped it by one, and I needed the largest total payout. The sample was numSuppliers = 2, inventory = [3, 5], order = 6, and the answer was 19.

My approach: Sell from the fullest supplier first, every time. That greedy choice is obvious, and my first instinct was a max-heap: push every supplier's stock, pop the top one, add its value to the profit, push it back one lower, and repeat order times.

The heap is correct on the sample and hopeless on the clock. order can reach the sum of all inventory, which the constraints put as high as ten billion, so popping one item at a time can never finish. Sorting the stock high to low removes the simulation instead. The top level falls in flat bands, and each band is one arithmetic series I can sum in a single step.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Solution {
    // METHOD SIGNATURE BEGINS, THIS METHOD IS REQUIRED
    long highestProfit(int numSuppliers, List<Long> inventory, long order) {
        List<Long> stock = new ArrayList<>(inventory);
        stock.sort(Collections.reverseOrder());   // fullest supplier first

        long profit = 0L;

        // The top stock level falls in flat bands, so walk the bands top down.
        for (int i = 0; i < numSuppliers && order > 0; i++) {
            long top = stock.get(i);
            long next = (i + 1 < numSuppliers) ? stock.get(i + 1) : 0L;

            long width = i + 1;                    // suppliers sitting at or above this level
            long bandItems = width * (top - next);

            if (order >= bandItems) {
                // Take the whole band: prices run from next+1 up to top, width times.
                long bandSum = (top + next + 1) * (top - next) / 2;
                profit += width * bandSum;
                order -= bandItems;
            } else {
                // Partial band: full layers of `width` items, then one short layer.
                long layers = order / width;
                long rest = order % width;
                long hi = top;
                long lo = top - layers + 1;
                profit += width * ((hi + lo) * layers / 2);
                profit += rest * (top - layers);
                order = 0;
            }
        }

        return profit;
    }
    // METHOD SIGNATURE ENDS
}

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

What tripped me up: The heap detour cost me close to twenty minutes, and the failure was silent. The hidden tests timed out instead of showing me a wrong number, so there was no failing case to read. I had the greedy right from the first minute and the data structure wrong, and by the time the band version passed, the second block was already waiting.

I had burned close to twenty minutes when the heap timed out, and I did not reach for a desktop overlay. The answer would have sat on the same screen the platform's proctoring monitors, hidden by a basic rendering layer, and I did not want that uncertainty in the background.

Instead I pressed a keyboard shortcut; it auto-captured the problem and pushed the reply to my phone, a separate device outside the platform's screenshot monitoring. The band-sum approach came back clear, and my laptop screen never left the editor.

Question 2: AI-Assisted Repo Bug-Fix

The problem I got: The second block was not an algorithm question. I was handed a buggy full-stack repository and an AI assistant built into the same browser window. The prompt named three broken behaviors in the password-reset flow:

• the verification code was never generated
• the verify step never enforced the 30-second expiry window
• the new password was never persisted to the profile

I had to reproduce each one, find the module behind it, prompt the assistant for a targeted fix, and get the bundled test suite green.

My approach: I had to commit to one backend framework before I saw the code, and I could not switch once inside. The choices were Java Spring Boot, Python Django, C++, and others. I picked Spring Boot.

Then I ran the suite first, read which test failed, and opened only the module that failure pointed at. The assistant could see just the one file I had selected, so I fed it the exact failing test and the exact file instead of the whole repository. The loop was the score here, not algorithmic insight: reproduce, localize, patch, re-test.

Once I found them, the three fixes were shallow. The code generator needed a randint call and a stored generated_at, and the verify step had to compare now against generated_at + 30 seconds. The persistence bug was a new password set on an object and never written back into the profile.

One detour I did not expect: a separate test file had undefined variables, so the suite would not even run until I patched those first.

Where the hour went: The clock, not the bugs. The in-browser assistant was quick to hand me a patch and slower to hand me the right one, and reverting its bad diffs ate most of the hour. I left the last five minutes for the final sandbox run, and that run is what turned the suite green.

Amazon's Proctoring Policy for CoderPad

Amazon publishes its coding assessment rules, and they are short. The monitoring around them is what candidates ask about most.

Print-Screen and Copy-Paste Are Banned

During the coding assessment, Amazon allows publicly accessible online resources. Amazon's own page states plainly that it records browser usage. The full wording sits on Amazon's official OA preparation page.

One rule is absolute. Print-screen ends the session, and Amazon says the candidate is locked out afterward.

Copy-paste is discouraged rather than banned outright, and the same page expects submitted code to be the candidate's own. That raises the real question of how a platform spots a paste at all. Whether CoderPad logs a paste as it happens answers the enforcement half.

Some Sittings Report Screen and Webcam Recording

Reports from 2026 say the coding challenge records the screen and the webcam. Knowing what lands in that capture settles the rest. What a CoderPad screen recording actually keeps breaks it down.

The camera is the murkier half. A 2024 data-engineering candidate saw no camera requirement at all. Third-party write-ups say the setup varies per test. That gap is why whether a CoderPad sitting runs a webcam matters.

9 Other Confirmed Amazon CoderPad Questions

Every question below is a confirmed extra beyond the two I faced, and each of the nine keeps its own surface label, because the async OA and the live rounds do not share a pool.

Question 3: Binary Array Rearrangement

One 2026 candidate faced minMoves(arr). It returns the fewest adjacent swaps that group every 0 together and every 1 together, and the running totals need 64-bit integers.

Question 4: Drone Delivery on a Hub Ring

Another 2026 candidate routed deliveries around a ring of hubs in a requested order. The return value was the minimum distance travelled.

A helper arc(a, b) = min(cw, total - cw) picks the shorter way around. The classic bug is the wrap-around between the last hub and the first. A two-hub ring is a degenerate case that breaks the general loop. That record matches the HackerRank-style OA surface.

Question 5: Longest Substring Without Repeating Characters

One candidate confirmed this as the unchanged public problem. The task returns the length of the longest substring with no repeated character. It shared a 30-minute block with Question 7, after a few behavioral prompts about deadlines.

Question 6: Max Money from K Consecutive Bags

calculateMaximumConsecutiveSum(k, segment) turned up in a 2026 OA, asking for the largest sum of k consecutive bags, returned modulo 1e9+7. The running totals need 64-bit integers.

Question 7: Word Search II

One candidate confirmed Word Search II exactly as the public problem, LeetCode 212. The task returns every dictionary word found on a board, using a trie plus depth-first search. It shared the same 30-minute block as Question 5. The confirmed detail stops at the problem identity, so the full solution belongs in the public statement.

Question 8: Allocate Limited Inventory

A limited-inventory allocation problem appeared in a 2026 SDE2 OA. Bids arrive as [customerId, quantity, bidAmount, timestamp], and the higher bid wins. Ties rotate round-robin, and the return is the list of fulfilled order ids.

The worked example ran four bids against 18 units and returned [4]. That record is a two-part OA whose second part is the AI bug-fix round.

Question 9: Minimum Health and Integer-Zero Ops

Two 2026 OA problems were named together. They were Minimum Health to Beat Game and Minimum Operations to Make the Integer Zero.

The first is arithmetically short, and the second is a bit-manipulation count that turns num1 toward zero with additions of num2. The confirmed detail supports the problem identity more than a full derivation, so I left the code out for both.

Question 10: Graph DSA plus Spring Boot Debug

One candidate's round paired a graph problem with an AI-assisted Spring Boot debug. The DSA half scored 8 of 15, and the debug half fixed 5 of 6 bugs. That debug half is a variant of Question 2's round, reported separately. It points the same way, because the engineering loop is what gets scored.

Question 11: Merge Intervals and Dijkstra

A February 2026 OA contained a Merge Intervals variant and a graph problem solved with Dijkstra. The same sitting included a work-simulation section that leaned on Ownership and Bias for Action. That record names the two problem shapes but not their full statements. The confirmed part is therefore the pairing, not a runnable spec.

What Amazon's CoderPad Test Format Actually Looks Like

The stage structure is settled and dated. That platform question is not settled, and it is worth resolving before anything else. The chart below lays out the stages.

Four Stages, About Two Hours Total

The full-time OA runs as four timed stages. Coding takes about 70 minutes, workstyles about 15, the work simulation about 60, and the survey about 5. Amazon tells candidates to set aside up to two hours, and the internship version runs nearer 90 minutes.

The Coding Round Is HackerRank-Style, Not CoderPad

The reporting here points one way, and it is the finding most guides skip. Every dated account of the asynchronous coding round describes a HackerRank-style browser IDE.

CoderPad's own candidate documentation separates CoderPad Screen for asynchronous work from CoderPad Interview for the live pad.

That distinction matters, because CoderPad is the credentialled editor candidates meet in Amazon's live technical and phone screens. No official Amazon page names the platform behind the OA.

The question pool splits the same way, with a rate limiter using allow(user_id, timestamp) in a live hiring-manager follow-up and a timestamped key-value store using set and get in a phone screen.

That is an absence of confirmation, not a confirmed denial. The live surface is well evidenced, and the async surface is well evidenced. Neither one is officially labeled by Amazon.

How Amazon's CoderPad Scoring Works

Scoring is where the official description and the community reality split. The chart below maps the reported outcomes. Amazon states that the assessment evaluates coding skill, technical problem solving, and its Leadership Principles.

Scoring Is Partial Credit, Not All or Nothing

Scores arrive in fractions. One 2026 candidate cleared with 8 of 15 on the DSA half. Another passed with 15 of 15 on question one and 14 of 15 on question two. A third cleared the whole OA in roughly two weeks and moved to four back-to-back rounds.

The AI-Assisted Round Scores Separately

The AI-assisted round carries its own score, which is the part most candidates miss. One candidate passed the coding portion and still landed at 3 of 6 on the AI half. Another fixed 5 of 6 bugs and treated that as the headline result.

Amazon CoderPad Exam-Day Strategy

Two habits decided my own sitting, and neither was about studying harder. Both came from how other candidates sequenced their clock.

Run the Tests Before You Prompt the AI

I made a habit of running the full bundled suite before prompting the assistant. The failing test named the module to open, so the assistant only saw the one file that mattered. Keeping its window small is what made its patches usable.

Your Second Problem Eats the Clock

The first question is usually quick, and the second one consumes the clock. One 2026 candidate cleared question one in five or six minutes. That candidate then spent close to forty working question two from 6 of 15 to 14 of 15. Amazon's advice on the same page is to move on when stuck and revisit later.

Why Candidates Fail the Amazon CoderPad Assessment

Three patterns cover most of the failures I read about. Two of them have nothing to do with coding talent. The first one is the sharpest, because it ends the candidacy outright.

A Hidden Overlay Tool Ended a Real Candidacy

One candidate ran a hotkey-activated invisible app behind the assessment window during a live sitting, with an interviewer present. Around 40 minutes in, the interviewer saw an answer card appear beside the code pane. The recruiter later said the live assessment could not be accepted, and the candidacy ended there.

The structural reason is plain. An overlay renders on the same screen the monitoring already sees, however well it hides in the moment. How CoderPad catches a hidden overlay covers the detection side.

InterviewFox works differently. It is a dual device AI interview assistant that puts the answer on my phone, a physically separate device that no screenshot, screen recording, or session monitoring can reach by design.

The AI Round Is Where the Clock Runs Out

One 2026 candidate did not finish the seeded fixes before the 60-minute block closed. Another passed the graph half at 8 of 15 and lost the clock on the Spring Boot debug. That round is a bounded block, not an open-ended task.

Rejected With Every Visible Test Passing

Passing the visible cases proves nothing on its own. One candidate passed every visible test and still saw the application moved to no longer under consideration. Another passed coding and carried 3 of 6 on the AI portion.

How to Prepare for the Amazon CoderPad in 5 Days

Five days is the whole window. The plan below splits it by what actually scores. Day 1 is orientation, and the middle two carry the scored work.

Day 1: Lock the Two-Part Format and Pick Your AI-Round Framework

I reviewed the official stage list and settled on one backend framework before the clock started. The AI round fixes the framework up front and forbids a switch. That makes the choice a Day 1 decision, not a Day 5 one. The success check was simple. Before Day 2 I could name all four stages and my locked framework.

The Prep Agent from InterviewFox was my other prep tool in the days before the OA. I sent it the confirmed question patterns for this company over WhatsApp and got back a short drill plan and a per-stage strategy.

I skipped broad tag-grinding and system-design prep. New-grad SDE I has no system-design round, and the coding block is one medium problem plus a debugging round.

Days 2-3: Drill the AI-Debug Loop and a Timed Medium

I ran the run-tests, prompt, diff loop on a small repository until it was automatic. Then I solved one medium under a 20-minute cap. The success check was measurable. A seeded bug had to reach a green test run inside 30 minutes, and the medium inside 20.

Days 4-5: Simulate Both Parts and Rehearse LP Stories

I ran one full two-hour mock under the official rules and finished with no rule breach. I also wrote three Leadership Principles stories. The work-simulation section leans on Ownership and Bias for Action. Each story ran under two minutes and carried a number.

What Happens After You Submit the OA

The assessment ends with a survey, and then the waiting starts. That rule and the reported timelines below are what to expect.

Finish the Survey or Your Results Are Delayed

Amazon requires the end-of-assessment survey. Amazon states that skipping it delays the results, and the confirmation page has to appear. A two-part completion email follows within 24 hours. Recruiters reach out directly only if the application moves forward.

Most Candidates Hear Back Within Two Weeks

One candidate cleared the OA and got the interview mail. Another cleared in roughly two weeks and moved to four back-to-back rounds. Some applications move to no longer under consideration with no explanation. Two weeks is therefore a working expectation, not a promise.

The Two Amazon OA Formats in 2026

Which format a candidate receives is the bonus question. The answer is boringly literal, because it sits in the invitation.

Your Invitation Email Decides Which One You Get

The 2026 fork comes down to the invitation. One version runs two algorithm problems, and the other runs one algorithm plus one AI-assisted problem. February 2026 saw the two-algorithm form, and a July 2026 report described the AI-assisted one.

No public rule says who gets which. The labeled section times inside the email are the only reliable signal.

FAQ

Is the Amazon OA actually on CoderPad?

No official Amazon page names the platform behind the OA. The asynchronous coding round is reported as a HackerRank-style browser IDE. CoderPad is the credentialled collaborative editor used in live technical and phone screens. CoderPad's own documentation separates CoderPad Screen from CoderPad Interview along exactly that line.

What are the Amazon CoderPad interview questions?

Amazon CoderPad interview questions cover the same ground as the OA. The confirmed set here runs from a supplier-profit greedy problem to Word Search II. It also covers sliding windows, intervals, graphs, and object design. Live rounds swap some of that for debugging and framework questions.

How many questions are on the Amazon CoderPad OA?

The coding block holds two problems. They are either two algorithms or one algorithm plus one AI-assisted problem. No public rule for the 2026 fork decides which one a candidate receives. The wider OA adds a workstyles section, a work simulation, and a feedback survey.

Can I use AI tools during the Amazon OA?

Only where the platform supplies its own assistant. The AI-assisted round includes a built-in assistant that the recruiter has to enable. No outside tool works alongside it. Print-screen terminates the session and locks the candidate out. Amazon logs browser usage.

Can I use an AI tool or invisible app during the Amazon CoderPad OA?

Desktop overlay tools render the AI's answer on your computer screen as a hidden layer above the browser, held there by a basic OS-layer trick. The answer is still on-screen, and proctoring software keeps adding detection capabilities as AI tools spread, so that exposure is not fixed.

InterviewFox pushes the answer to your phone instead, a physically separate device that no screenshot, screen recording, or session monitoring can reach by design, which keeps the laptop screen on the exam editor, unchanged. If you plan to use AI assistance during the OA, the dual-device architecture removes the answer from your screen entirely.

What happens if I pass all the visible test cases?

Passing the visible tests is not the same as passing the OA. One candidate passed every visible case and still moved to no longer under consideration. Another passed coding while scoring 3 of 6 on the AI portion, which is scored separately.

How long do I have to complete the OA?

Reports put the completion window at about five days from the link. Roughly an hour and a half of that is active work. Amazon's own page puts the full sitting at up to two hours. The internship version runs nearer 90 minutes.