Skip to content

How to prepare for and pass an OA

For anyone with an OA due in the next 3 to 30 days. You leave with a day-by-day plan, a minute-by-minute budget for test day, partial-credit tactics, input templates in Python, Java and C++, and the integrity rules.

Pick your plan

Time until your deadline Plan Daily time
3 days or less 72-hour plan 2 to 3 hours
1 to 2 weeks 2-week plan 1.5 to 2 hours
3 weeks or more, or a whole season of OAs 4-week plan, then one timed set per week 1 to 2 hours

If the deadline is too close and you have exams, ask for more time today with the extension template. Amazon says to ask through the contact in your OA email (Amazon OA prep).

Set up once

Do these before any plan. They take one evening.

  1. Pick one language and stay with it. Python is fastest to type. Use Java or C++ only if you are much stronger in it. Codility and Amazon both tell you to use the language you know best.
  2. Learn input and output in that language. Copy the templates below and run them once.
  3. Learn the standard library cold. Python: Counter, defaultdict, deque, heapq, bisect. Java: HashMap, ArrayDeque, PriorityQueue, TreeMap. C++: unordered_map, priority_queue, set and map with lower_bound.
  4. Bookmark the official docs. Amazon allows public docs like the JDK and STL during its OA. Keep these three open in one window before you start: Python collections, Java java.util, C++ containers.
  5. Take every free official practice test once. HackerRank Sample Test, Amazon practice test, Goldman Sachs practice test, CodeSignal practice area, Codility demo. The goal is the editor, not the problems: where Run is, where Submit is, how custom input works.
  6. Learn your platform's submit rule. HackerRank grades your old submission unless you Run Code and Submit after each edit. Codility's Submit is final, and CodeSignal keeps your best submission (OA platforms).

72-hour plan

  • Hour 1: Read the invite. Read the platform section on OA platforms. Take that platform's practice test.
  • Day 1: Solve the top 6 most-asked problems on your company's guide (find it in the companies index) with a 30-minute timer each.
  • Day 2: One full mock in the exact format. For a GCA, use the Day 5 set in the 2-week plan. For a 2-problem HackerRank OA, take 2 unseen mediums from your company guide in 70 minutes. For a progressive OA, the mock ICA in 90 minutes.
  • Day 3 morning: Re-solve every problem you missed, without notes. Run the day-of checklist. Take the OA.

2-week plan

Week 1: platform and fundamentals.

Week 2: company and format.

  • Days 8 to 10: 5 problems a day from your company's guide. Use Jugal's timer rule: "Set a timer. 30 minutes per medium problem. If you can't solve it in 30, look at the solution, understand it, and move on. Come back to it three days later." (Amazon is still hiring after the biggest layoffs)
  • Day 11: Drill your format's special part. Progressive: ICA playbook. Repo: repo playbook. MCQs: OS, DBMS, networks, OOP and aptitude.
  • Day 12: Full mock under real conditions. Webcam on, one tab, no notes, timer running.
  • Day 13: Fix your weakest pattern. If it is Amazon, read the Leadership Principles and write one line per principle on when you showed it. That is your Workstyles prep.
  • Day 14: Day-of checklist. Sleep. Take the OA.

4-week plan

Week 1: fundamentals and platforms.

  • Take every free official practice test listed in set up once.
  • Do one module a day of a CodeSignal Learn algorithms path (Python version). Jugal's instructions: "Take the 'Mastering Algorithms and Data Structures' path in whatever language you'll actually interview in (Python, Java, or C++)." "When you're stuck, ask Cosmo before you look up the answer." (Want a Job in the Next 30 Days?)
  • Do 3 problems a day. Jugal's routine is "3 LeetCode problems a day (focus on patterns, not volume)" (The Job Hunt I Didn't Burn Out Doing).

Week 2: timed GCA-style sets.

Week 3: company-specific.

Week 4: your format, then full mocks.

Tip: Volume is not the goal. Jugal cleared Amazon, Google and Meta with 120 LeetCode problems (I Cleared Amazon, Google, and Meta With Only 120 LeetCode Problems). His plan ends with 2 to 3 timed problems per pattern ("the timer matters here"), then full mocks only. Pattern lists are on coding patterns.

Time allocation during the test

Rules for any OA

  1. Read every question first. Spend 2 to 3 minutes. Codility recommends it, and you need it to choose the order.
  2. Solve the easiest question first. Bank those test cases before the hard one.
  3. Stuck for 10 minutes with no new idea? Save a compiling version and move on: submit it on HackerRank and CodeSignal, leave it in the editor on Codility (Submit is final there). Amazon's page says "If you get stuck on a problem, move to the next one and revisit questions as needed."
  4. Keep the last 5 minutes for checks: every answer compiles, is submitted, and has no debug prints. On HackerRank, click Run Code and then Submit on anything you touched after your last submit.

Budgets by format

CodeSignal GCA (4 questions, 70 min). CodeSignal's framework says about 10, 15, 20 and 30 min
(75 in total), so trim to fit:
  Read all four ............... 2 min
  Q1 basic coding ............. 10 min
  Q2 data manipulation ........ 13 min
  Q3 implementation ........... 20 min
  Q4 problem solving .......... 25 min   (brute force first if stuck)

Amazon, official format (2 coding problems, about 70 min):
  Read both ................... 3 min
  Easier problem .............. 25 min
  Harder problem .............. 35 min
  Edge cases and resubmit ..... 7 min

Amazon, 2026 reported format (Coding Challenge, about 100 min):
  DSA problem ................. 40 to 45 min
  AI-assisted repo task ....... 55 to 60 min (start the dependency install while you read the README)

Goldman Sachs (official, Aug 2026):
  Software Fundamentals ....... 30 min
  Software Diagnostics ........ 45 min
  Math (Quant Strats only) .... 22 min

CodeSignal ICA (1 problem, 4 levels, 90 min). The official framework gives
10 to 15, 20 to 30, 30 to 60 and 30 to 60 min. That adds up to more than 90 on purpose:
  Levels 1 and 2 .............. 30 min total (fast and clean)
  Level 3 ..................... 30 to 40 min
  Level 4 ..................... whatever is left; submit what passes

Stripe-style multi-part (1 problem, 60 min):
  Read the whole spec ......... 5 min
  Parts 1 and 2 ............... 25 min
  Later parts ................. 25 min
  Final run and submit ........ 5 min

MCQ plus coding (India campus):
  Each section usually has its own timer, and some cannot be revisited
  (D. E. Shaw India reports). Answer in order. Do not plan on coming back.

The Goldman minutes are official. The GCA and ICA splits are trimmed from CodeSignal's official framework PDFs (GCA, ICA). The rest are starting points built from candidate reports.

One Amazon candidate said switching between the file tree, editor and AI panel ate most of their time (LeetCode post). Another lost 40 of 60 minutes to dependency installs (Amazon page).

Read the constraints first

The input limits tell you the complexity the hidden tests expect. Read them before you design anything.

Largest n (USACO Guide) Target complexity Usual techniques
up to 20 O(2^n x n) Subsets, bitmasks, backtracking
up to 400 O(n^3) Triple loops, interval DP, Floyd-Warshall
up to 7,500 O(n^2) Double loops, 2D DP
up to 5 x 10^5 O(n log n) Sorting, heaps, binary search, ordered maps
up to 5 x 10^6 O(n) Hash maps, two pointers, prefix sums, fast input
up to 10^18 (a value, not a length) O(log n) or O(1) Binary search on the answer, math

A safe estimate is about 10^8 simple operations per second (USACO Guide). Many OAs do not show the time limit. HackerRank publishes per-language limits: 2 seconds for C and C++, 4 for Java, 10 for Python 3 (execution environment). Leave margin either way.

During the test, step by step

  1. Read all questions. Note the constraints for each.
  2. Start with the easiest.
  3. Write the brute force if the optimal idea is not clear within 5 minutes. Submit it (on Codility, keep it in the editor instead). It collects the small tests.
  4. Run the samples. Then add your own inputs: empty, one element, all equal, duplicates, negatives, the largest values.
  5. Improve toward the target complexity. Keep the working version until the new one passes.
  6. Debug with prints to stderr, never stdout: print(x, file=sys.stderr), System.err.println(x), cerr << x. Exact-match graders compare stdout.
  7. Stuck 10 minutes: move on and come back.
  8. Last 5 minutes: everything compiles and is submitted. On HackerRank, Run Code then Submit again after any edit.
  9. Never open ChatGPT, a second device, or a solution site. Use docs only if the rules allow it.

Partial credit tactics

Platform How partial credit works Your move
HackerRank Points per hidden test case, exact output. An edit after Submit counts only if you Run Code and Submit again Submit a correct brute force early, then optimize and resubmit
Codility Percent of tests passed. Code that does not compile scores 0. Submit is final; timeout auto-submits the editor Keep the editor compiling at all times. Press Submit only when done with that task
CodeSignal GCA Your highest-scoring submission per question counts, even if a later one breaks Submit after every improvement
CodeSignal ICA Points per level. The next level opens when the current one passes Pass level N fully before you start level N+1
Multi-part (Stripe style) All parts graded by hidden tests Finish parts 1 and 2 cleanly before part 3

Tactics that pick up points:

  1. Brute force first. A correct O(n^2) solution usually passes the small tests. A wrong O(n) one passes none.
  2. Handle small inputs separately if you must. If you cannot find the full solution, use brute force when n is small and your best heuristic when it is large. Say so in a comment.
  3. Return the right type on every path. A stub that returns nothing fails every test.
  4. Use 64-bit integers for sums and products. In Java and C++, a sum of 10^5 values up to 10^9 overflows int.
  5. Never leave a section blank. SQL, Bash and MCQ sections are scored (Intuit reports).
  6. Do the guessing math on negative-marked MCQs. Expected value of a blind guess = (chance right x points) minus (chance wrong x penalty). With 4 options at +2 and -0.5, that is 0.5 - 0.375 = +0.125, so guess. If the result is negative, skip, unless you can rule out an option first.

Test your code like the hidden tests will

Hidden tests usually include these cases. Check each one before you submit.

  • Empty input, or the smallest allowed (n = 1)
  • All elements equal, or all distinct
  • Duplicates
  • Negative numbers and zero
  • Already sorted, and reverse sorted
  • The largest n (does it finish in time?)
  • The largest values (does it overflow?)
  • No valid answer (return what the spec says: -1, [], an empty string)

When a problem keeps failing hidden tests, compare your fast solution against a slow one that is obviously correct, on thousands of random small inputs. It is a few minutes of typing and finds bugs your examples miss:

import random


def max_subarray_brute(nums: list[int]) -> int:
    # Obviously correct, O(n^2). Never submit this one.
    return max(sum(nums[i:j + 1]) for i in range(len(nums)) for j in range(i, len(nums)))


def max_subarray_fast(nums: list[int]) -> int:
    # The solution you plan to submit (Kadane, O(n)).
    best = current = nums[0]
    for x in nums[1:]:
        current = max(x, current + x)
        best = max(best, current)
    return best


random.seed(1)
for trial in range(3000):
    nums = [random.randint(-5, 5) for _ in range(random.randint(1, 8))]
    expected, got = max_subarray_brute(nums), max_subarray_fast(nums)
    if expected != got:
        print("MISMATCH on", nums, "expected", expected, "got", got)
        break
else:
    print("3000 random tests passed")

Build this habit in practice first. During an OA, use it only if you have spare time and the platform runs your code: type it into the editor yourself, run it, then delete it before you submit.

Reading input (stdin templates)

Most HackerRank and Codility questions give you a function stub, so you only fill in the function. Some questions say "read from STDIN" and give you an empty editor. Flipkart's story problems and some Cloudflare and OpenAI tests are like this.

These templates read every token regardless of line breaks, which survives odd spacing in test files.

The example input is a number of test cases, then for each case n and n integers:

3
4
5 1 9 2
1
7
3
-1 -1 -1

Python

import sys


def solve(nums: list[int]) -> int:
    # Replace with your logic. Example: range of the array.
    return max(nums) - min(nums) if nums else 0


def main() -> None:
    tokens = sys.stdin.buffer.read().split()  # every token, across all lines
    pos = 0

    def next_int() -> int:
        nonlocal pos
        pos += 1
        return int(tokens[pos - 1])

    test_cases = next_int()  # delete this loop if the input has one test case
    answers = []
    for _ in range(test_cases):
        n = next_int()
        nums = [next_int() for _ in range(n)]
        answers.append(str(solve(nums)))
        # print("debug", nums, file=sys.stderr)  # stderr never reaches the grader
    sys.stdout.write("\n".join(answers) + "\n")


if __name__ == "__main__":
    main()

When lines matter (a grid, or names with spaces), read lines instead of tokens:

import sys

lines = sys.stdin.read().splitlines()
rows, cols = map(int, lines[0].split())          # "3 4"
grid = [list(lines[1 + r]) for r in range(rows)]  # each row is a string like "#..#"
q = int(lines[1 + rows])
queries = lines[2 + rows: 2 + rows + q]          # whole lines, spaces kept

Java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Solution {

    private static long solve(long[] nums) {
        // Replace with your logic. Example: range of the array.
        if (nums.length == 0) {
            return 0;
        }
        long min = nums[0];
        long max = nums[0];
        for (long x : nums) {
            min = Math.min(min, x);
            max = Math.max(max, x);
        }
        return max - min;
    }

    public static void main(String[] args) throws IOException {
        FastReader in = new FastReader(System.in);
        StringBuilder out = new StringBuilder();
        int testCases = in.nextInt(); // delete this loop if the input has one test case
        for (int tc = 0; tc < testCases; tc++) {
            int n = in.nextInt();
            long[] nums = new long[n];
            for (int i = 0; i < n; i++) {
                nums[i] = in.nextLong();
            }
            out.append(solve(nums)).append('\n');
            // System.err.println(java.util.Arrays.toString(nums)); // debug goes to stderr
        }
        System.out.print(out); // one print at the end is much faster than one per line
    }

    /** Reads whitespace-separated tokens across any number of lines. */
    private static final class FastReader {
        private final BufferedReader reader;
        private StringTokenizer tokens;

        FastReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
        }

        String next() throws IOException {
            while (tokens == null || !tokens.hasMoreTokens()) {
                String line = reader.readLine();
                if (line == null) {
                    return null; // end of input
                }
                tokens = new StringTokenizer(line);
            }
            return tokens.nextToken();
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        /** Whole line with spaces kept. Call it only at a line boundary. */
        String nextLine() throws IOException {
            tokens = null;
            return reader.readLine();
        }
    }
}

C++

#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;

long long solve(const vector<long long>& nums) {
    // Replace with your logic. Example: range of the array.
    if (nums.empty()) return 0;
    return *max_element(nums.begin(), nums.end()) - *min_element(nums.begin(), nums.end());
}

int main() {
    ios::sync_with_stdio(false);  // fast I/O; do not mix with scanf/printf after this
    cin.tie(nullptr);

    int testCases;
    if (!(cin >> testCases)) return 0;  // delete this loop if the input has one test case
    while (testCases--) {
        int n;
        cin >> n;
        vector<long long> nums(n);
        for (auto& x : nums) cin >> x;
        cout << solve(nums) << '\n';  // '\n' not endl: endl flushes on every line
        // cerr << "n=" << n << '\n';  // debug goes to stderr
    }

    // Whole lines with spaces (names, sentences): skip leftover whitespace first.
    // string line;
    // getline(cin >> ws, line);
    return 0;
}

All three were run on the sample input above and print 8, 0, 0. The C++ version compiles as C++11, which is what HackerRank's plain "C++" option uses. The Python one needs Python 3.9 or later for the list[int] hints.

Input and language traps

Trap What happens Fix
Python input() in a loop over 10^5+ lines Slow, can time out Read everything with sys.stdin.buffer.read()
Java Scanner on large input Slow BufferedReader with StringTokenizer, as above
Java StreamTokenizer Parses numbers as double, losing precision above about 2^53 Use the reader above for big integers
C++ endl in a loop Flushes every line, slow Use '\n'
C++ <bits/stdc++.h> Works on GCC only Include the headers you use
C++17 syntax (auto [a, b]) under HackerRank's plain "C++" Compile error: that option is C++11 Pick C++20 or C++23 in the dropdown, or avoid the newer syntax
Python recursion deeper than about 1,000 calls RecursionError on a long list or a deep tree Use an explicit stack or BFS, or call sys.setrecursionlimit (sys docs)
Python grid as [[0] * m] * n Every row is the same list, so one write changes all rows (Python FAQ) [[0] * m for _ in range(n)]
Debug print to stdout Breaks exact-match output Print to stderr, remove before submit
int sums in Java or C++ Overflow on large inputs long or long long

AI-assisted repo tasks

Seen in Amazon OAs (2026 reports), Goldman Sachs Software Diagnostics (official), Walmart's 2026 HackerRank test, and an IBM India second round. You fix bugs or add a feature in a small web app (Django, Node/Express or Spring Boot), sometimes with a built-in assistant.

  1. Read the README and the names of the failing tests first. List the bugs you suspect.
  2. Find the route or controller for the broken feature. Trace it down to the service and data layer.
  3. Start the dependency install while you read. One Amazon candidate lost 40 of 60 minutes to installs (Amazon page).
  4. Use the assistant for "where is X handled" and "what does this error mean". Goldman's assistant "will not provide the full solution but can help with UI navigation, syntax, or problem statement clarity" (Goldman Sachs guide).
  5. Do not count on it to find the bug. Candidates in Meta's AI-enabled rounds report the in-interview assistant was weaker than the same model outside (Hello Interview). Read the failing test and the code yourself.
  6. Make the smallest correct change. Match the existing style. Goldman tells candidates to practice "making targeted changes rather than building an application from scratch", and some Codility bug-fix tasks reward the fewest edits.
  7. Add the missing pieces these tasks usually test: input validation and correct HTTP status codes. One reported Amazon intern task needed missing save and delete calls, 400 and 404 checks, and a rate limit returning 429 (LeetCode post).
  8. Run the provided tests after every fix.
  9. Assume a person reads your AI chat. HackerRank shows the transcript to the evaluator (AI assistant in tests). Ask short, specific questions and check every answer.

Practice drill (45 minutes): clone any small open-source Spring Boot, Django or Express sample app. Break three things (remove a save call, return the wrong status code, delete a validation). Then fix them against the clock with an assistant used only for navigation and syntax.

Progressive (ICA) tasks

  1. Only level 1 is visible at first. Read it fully.
  2. Build a clean data model in level 1: one class per entity, small methods, a dictionary keyed by id. Handle missing ids and duplicates, because level 1 tests them.
  3. Finish levels 1 and 2 in about 30 minutes total to leave time for 3 and 4. CodeSignal's framework budgets 10 to 15 minutes for level 1 and 20 to 30 for level 2; one reply on a Meta OA thread says 10 minutes for both (Blind thread).
  4. When level 3 changes old behavior, refactor the shared helper. Do not copy and paste. CodeSignal says you "must reuse, encapsulate, and refactor earlier code".
  5. Re-run earlier levels' tests after each change. A failing test can come from an earlier level's data handling (Airbnb page).

See a weak and a strong level 1 side by side on code quality.

Work style, work simulation, and video sections

Amazon Workstyles (about 15 minutes): "built around Amazon's Leadership Principles". Amazon says "There is no practice needed" (Amazon OA prep).

  1. Read the 16 Leadership Principles once.
  2. Answer as your real working self.
  3. Stay consistent. These questionnaires repeat ideas in different words.
  4. Do not overthink. It is short.

Jugal's tips from The Definitive Guide for Meta & Amazon Engineering Interviews: for Workstyles, "Be consistent" and do not hover in the middle on paired statements. For the Work Simulation: "Customer > Everything", "Ownership > 'Checking with Boss'", and "Data > Gut Feeling". His post calls the simulation a 20-minute game; Amazon's official page says an average of 60 minutes, so budget 60.

Amazon Work Simulation (full-time, and some 2026 intern reports): emails, videos and instant messages from a virtual team. You rate 4 to 5 responses or pick the best one, using the wikis, code snippets and roadmaps provided. Amazon gives an average of 60 minutes, and the page also says "You are provided 120 minutes".

  1. Do the full-time prep course. It covers the simulation.
  2. Prepare stories with the Leadership Principles page. Jugal's advice: "Prepare Amazon's behavioral component separately" (FAANG AI engineer internship post).

Google Hiring Assessment: workstyle statements before interviews. Answer consistently. Details on platforms.

Recorded video (HireVue and similar): use the practice question, then the answer shape on platforms.

Day-before and day-of checklist

The day before:

  • Read the invite: platform, question count, time limit, deadline, proctoring, AI rule.
  • Run the platform's system check: webcam, mic, screen share, browser. Amazon links a webcam check, and Mettl has a mock test.
  • Use a supported browser. Codility screen sharing needs Chrome 131+, Edge 130+ or Opera 114+. HackerRank does not support Brave.
  • If the invite requires the HackerRank desktop app, install it and test it on this laptop. It will not run in a virtual machine (Desktop App Mode).
  • Have your ID ready. Amazon (North America) asks for a student or government ID. CodeSignal proctored tests need a government photo ID.
  • Use a laptop or desktop, one monitor, at least 1024 x 768 (Amazon's minimum).
  • Plug in power. Use wired internet or strong wifi. HackerRank calls 10 Mbps good.
  • If the link redirects to a login page, turn off pop-up and ad blockers for the test site (Amazon's troubleshooting advice).
  • Quit every AI tool, copilot, overlay, screen recorder and notification app.
  • Keep the allowed docs bookmarked in one window.
  • Block the time: 2 hours for Amazon full-time (Amazon's advice), 90 minutes for the official Amazon intern format, 2.5 to 3 hours if your Amazon invite shows the 2026 format (about 100-minute coding challenge plus Work Simulation and Work Style), 70 to 90 minutes for CodeSignal, 45 minutes for HireVue.
  • Sleep.

Thirty minutes before:

  • Quiet room, door closed. Phone in another room. HackerRank Proctor Mode flags phones even partly in view.
  • Water nearby. Check the rules page before using scratch paper.
  • Close every app and tab except the test.
  • Bathroom now. Codility says its timer cannot be paused once you start. Assume the same everywhere.

If something breaks during the test:

  • Amazon: use the troubleshooting guide inside the test. If that fails, log out and back in with the same OA link. Amazon says "Do not repeatedly refresh the screen."
  • HireVue: reopen the same link to continue where you left off.
  • Write down the time and the exact error text. Do not use print screen (it ends Amazon's session) and do not pick up your phone on camera. Send the technical failure report the same day.

After you submit:

  • Amazon: complete the feedback survey; it is part of the OA. The confirmation page should appear within 2 minutes, and two-part OAs send a completion email within 24 hours. Check spam.
  • Write down, for yourself only, what slowed you down. Do not post the questions. CodeSignal says it monitors LeetCode and Stack Overflow for leaked questions and files takedowns (CodeSignal cheating and fraud).
  • Technical failure during the test: email the recruiter (and support@codesignal.com for CodeSignal) the same day with the template below.

Integrity rules

What is allowed

Source Allowed Not allowed
Amazon OA (official) Public docs such as the JDK or STL Sites that need a login, private repos, print screen (ends the session), copy-paste ("We expect this to be your own code")
CodeSignal GCA (official) Syntax-only web searches (for example, C++ queue methods) Pages that explain how to build the thing; any AI, "including syntax search"
HackerRank Proctor Mode (official) What your test's instructions allow External AI coding assistants, answer-sharing sites, GitHub, phones in view, extra monitors
Meta CodeSignal OA (reported) Reference docs AI, searching for solutions
Hudson River Trading (official 2021 blog) Books and the internet as a language reference AI tools (2026 postings)
Goldman Sachs Diagnostics (official) The built-in "limited" AI assistant Outside AI
Karat (official) A built-in AI assistant, or outside tools, only in modules that allow them Outside help, code that is not your own, pasting the question into a search engine or a GPT

Company AI rules (official, as of Oct 2026)

Company Rule
Microsoft Use AI to prepare. "During assessments and interviews, candidates should demonstrate their own skills without outside assistance unless explicitly permitted" (source)
Google "AI tools are not permitted to be used during your interviews" (source)
Amazon Amazon "asks that candidates acknowledge that they won't use unauthorized tools during the interview or assessment process", per a spokesperson (CNBC)
Nvidia "The use of unapproved outside tools, such as ChatGPT, during the interview will result in the disqualification of candidacy" (source)
Anthropic Take-homes "without Claude unless we indicate otherwise". Live interviews: "This is all you, no AI assistance unless we indicate otherwise" (source)
IBM AI "should not be used: To complete assessments, technical tests, or coding challenges" (source)
Cisco Fine for preparation. Poor use includes "Generating the solution to a coding problem or design question in real time" (source)
Waymo "the use of AI tools or LLMs is not permitted" unless the instructions say so (source)
Instacart In virtual and take-home assessments, AI may help organize thoughts or proofread, not complete the task (source)
Goldman Sachs Software Diagnostics includes a "limited" AI assistant. Use it "while applying your own engineering judgment to evaluate, refine, and validate the final solution" (source)
Qualcomm No AI tools, bots or LLMs in assessments or interviews unless Qualcomm asks (source)
Two Sigma, Snowflake, ServiceNow, HRT Ban AI in assessments unless told otherwise. See each company page: Two Sigma, Snowflake, ServiceNow, HRT

If your invite does not mention AI, assume none is allowed. If unsure, ask the recruiter in writing.

What gets flagged

Behavior Who flags it How to avoid an innocent flag
Pasting code HackerRank records pastes and shows them in reports. CodeSignal scores paste size, count and timing Type your code, including your templates
Copying the problem text CodeSignal "Description Copy" events, especially early or near the end (Suspicion Score) Read it on screen. Type the numbers you need
Leaving the tab HackerRank logs how often and how long you leave the window Stay in the test window unless docs are allowed
A phone or second face in view, looking away often HackerRank Proctor Mode, image proctoring Clear desk, phone in another room, look at your screen
Code that appears all at once, or line by line top-down HackerRank AI plagiarism model; Karat interviewers Write the way you normally do: outline, brute force, refine
High similarity to other submissions HackerRank MOSS (renaming variables does not hide it); CodeSignal similarity diffs Write your own solution
Switching language plus pastes CodeSignal Suspicion Score Pick your language before you start

Detection tools make mistakes too. HackerRank recommends a human review "so a false positive doesn't disqualify an honest candidate" (HackerRank). If you were flagged and did nothing wrong, ask the recruiter whether a person reviewed it.

What happens to people who cheat

  1. CodeSignal shows companies "Proctoring Rejected" and the reason (source).
  2. CodeSignal reports flagging 35% of proctored assessments in 2025 (CodeSignal blog).
  3. Hudson River Trading postings say it may end the interview, disqualify you, or rescind an offer (HRT page).
  4. The student who built a tool to cheat in technical interviews faced disciplinary proceedings at Columbia (CNBC).
  5. Interviewers probe the code in the next round. One told CNBC about candidates whose "code looked OK, but they couldn't describe how they came to the conclusion" (CNBC).

Retakes and cooldowns

Company or platform Rule Source
CodeSignal GCA 3 certified attempts per 180 days, at most 2 within 30 days. One score is shared with every company that asks CodeSignal
CodeSignal ICA 2 attempts per rolling 180 days, each with a new invite CodeSignal
CodeSignal score age Companies accept scores up to 6 months old by default (configurable to 3 years). Older than the limit means a fresh attempt CodeSignal
Amazon SDE II Not selected after the OA: "re-apply in six months". A passed OA may carry over to another SDE II role Amazon
Amazon university OA No retake rule published. Finish before the deadline; Amazon hires on a rolling basis Amazon
Google After a no, "wait at least a year" for the same type of role. Apply to up to 3 jobs every 30 days Google
JPMorgan Many assessments "may not be retaken for a designated timeframe". JPMorgan recommends no more than three summer internship applications JPMorgan
Expedia Up to 5 applications per 45 days Expedia
Capital One At most 5 active US applications Capital One page
Anthropic Re-apply after 12 months (official careers FAQ) Anthropic page

Tip: Plan your CodeSignal attempts. Take the GCA for your top company when you are ready, then reshare that score. Do not spend an attempt on a company you would not join.

Templates

Extension request

Where to send it:

  • Amazon: "the contact details provided in your OA email". For SDE II, you can also "request to receive your OA link at a later date in the Amazon.jobs Candidate Portal" (SDE II OA prep).
  • CodeSignal: the recruiter who sent the invite, asking for a new invitation. CodeSignal says "New invitation requests are not guaranteed".
  • Everyone else: the recruiter, or the reply-to address on the invite.
Subject: OA extension request: [Your Name], [Job ID]

Hi [Recruiter name or Recruiting team],

I received the online assessment for [Role, Job ID] on [date], with a deadline of [date].
Because of [one honest line: university exams on these dates / a medical issue / travel without reliable internet],
could I complete it by [a specific date, 3 to 5 days later]?

I want to give the assessment my full attention. Thank you for considering this.

Best,
[Name]
[Email] | [Phone]

Accommodation request

Subject: Assessment accommodation request: [Your Name], [Role]

Hi [Recruiter name],

I am scheduled to take the [platform] assessment for [Role]. I have [a documented condition /
an accommodation I receive at university] and would like to request [extra time of X% /
screen reader support / an alternative to the game-based section].
I can share documentation with your accommodations team if needed.

Thank you,
[Name]

Send it before you start the test. Amazon's route is its accommodations page. CodeSignal can extend session time and supports JAWS and Dolphin screen readers (CodeSignal accessibility).

Technical failure report

Subject: Technical issue during OA: [Your Name], [Job ID]

Hi [Recruiter name],

During my [platform] assessment for [Role, Job ID] on [date] at [time, time zone],
[what happened: the page froze on question 3 / my connection dropped for 6 minutes].
I [what you did: refreshed, rejoined, contacted support at (email) with ticket (number)].

Could I have a new link or a note added to my result? I am happy to retake it today or tomorrow.

Thank you,
[Name]

After the OA

  1. Goldman Sachs says to expect an update within three weeks. Other companies vary; waits of 1 to 3 weeks are normal in candidate reports.
  2. Do not read silence as a no for 2 to 3 weeks. Keep applying in the meantime. See application strategy.
  3. If you pass, the next round is usually a live coding screen. Start the 45-minute coding interview the same day.

Next: Code quality in OAs