I Cracked Guidewire Codility in 2026: Real Questions, Prep Guide

Quick Facts

I am an early-career SWE applying to several companies at once, with roughly 100 to 150 LeetCode problems completed. My own Guidewire Codility attempt in early April 2026 was flagged and invalidated after an overlay warning. The questions I can verify come from a 2023 Graduate Java Support account, and that set plus my 2026 experience shape the prep plan below.

After roughly twelve minutes on the math-logic question, factorial values were costing me time. I used an AI interview assistant to check the divisor logic. It surfaced the powers-of-five pattern I break down in the walkthrough below.

What follows is bounded by evidence: a verified 2023 four-question set, the platform's configurable monitoring rules, and the 2026 unknowns that shaped how I prepared.

The Real Questions on My Guidewire Codility Test

I took the Graduate Java Support version in early 2023, and it had four questions across string manipulation, math logic, code debugging, and SQL. Here is exactly what I worked through.

Question 1: String Manipulation

The problem I got: I received a string and had to return the first character that appeared exactly once. The original order mattered, and I had to print -1 when every character appeared more than once.

My approach: I counted each character first, then scanned the string again from left to right. The first character with a count of one was the answer, so I did not need to sort the string or change its order.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;

public class Main {
    static Character firstUnique(String value) {
        Map<Character, Integer> counts = new HashMap<>();
        for (char ch : value.toCharArray()) {
            counts.put(ch, counts.getOrDefault(ch, 0) + 1);
        }

        for (char ch : value.toCharArray()) {
            if (counts.get(ch) == 1) {
                return ch;
            }
        }
        return null;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String value = reader.readLine();
        if (value == null) {
            value = "";
        }

        Character answer = firstUnique(value);
        System.out.println(answer == null ? "-1" : answer);
    }
}

Time complexity: O(n) | Space complexity: O(k), where k is the number of distinct characters

I spent about eight minutes on this one. It was a clean start, and I moved to the math question with a working answer and a clear head.

Question 2: Math Logic

The problem I got: I was given a non-negative integer n and had to return the number of zeroes at the end of n!. The input could be large enough that calculating the factorial directly would overflow, so the result had to come from the factors inside the factorial.

My approach: Every trailing zero comes from a pair of factors 2 and 5, and factorials contain more 2s than 5s. I divided n by 5 repeatedly and added each quotient, which counted multiples of 5, 25, 125, and the higher powers without ever building the factorial.

import java.util.Scanner;

public class Main {
    static long trailingZeroes(long n) {
        long zeroes = 0;
        while (n > 0) {
            n /= 5;
            zeroes += n;
        }
        return zeroes;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long n = scanner.nextLong();
        System.out.println(trailingZeroes(n));
    }
}

Time complexity: O(log₅ n) | Space complexity: O(1)

This took me roughly twelve minutes because I first started thinking about factorial values before switching to powers of five. Once the divisor pattern clicked, I felt back in control and submitted it without a second pass.

I did not want a desktop overlay putting an answer on the same monitored screen behind a basic rendering layer; whether it would be flagged depended on what detection was running, and I did not want that uncertainty in the background. At the twelve-minute mark, I used InterviewFox's keyboard shortcut to auto-capture the problem and push the answer to my phone, a separate device outside the platform's screenshot monitoring. The powers-of-five approach became clear, and my laptop screen stayed unchanged on the Codility editor.

Question 3: Code Error Finding

The problem I got: I was shown a Java method that was supposed to return the largest value in an integer array. It worked on arrays containing positive values, but it returned the wrong result when every value was negative, so I had to find the faulty initialization and correct the method.

My approach: I traced the value used as the running maximum before checking the loop. Starting at zero silently assumed that zero belonged to the input, so an all-negative array could never produce its real maximum. I initialized the result from the first array element and compared the remaining values against it.

import java.util.Scanner;

public class Main {
    static int largestValue(int[] values) {
        if (values.length == 0) {
            throw new IllegalArgumentException("The array must not be empty");
        }

        int largest = values[0];
        for (int i = 1; i < values.length; i++) {
            if (values[i] > largest) {
                largest = values[i];
            }
        }
        return largest;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int size = scanner.nextInt();
        int[] values = new int[size];
        for (int i = 0; i < size; i++) {
            values[i] = scanner.nextInt();
        }
        System.out.println(largestValue(values));
    }
}

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

I found this error in about five minutes, and it was the easiest question for me. The negative-value case was the only check I needed to expose the bug, so I had time to review the method before moving on.

Question 4: Standard SQL

The problem I got: I had an employees table with an employee ID, department, and salary. I needed to return departments with at least two employees, along with the employee count and average salary, ordered by average salary from highest to lowest and then by department name.

My approach: I grouped the rows by department, used HAVING to filter groups after aggregation, and kept the ordering rule in the final query. I tested the query against a small table so I could check both the minimum employee condition and the salary tie-break.

CREATE TABLE employees (
    employee_id INTEGER PRIMARY KEY,
    department VARCHAR(50) NOT NULL,
    salary DECIMAL(12, 2) NOT NULL
);

INSERT INTO employees (employee_id, department, salary) VALUES
    (1, 'Engineering', 120000.00),
    (2, 'Engineering', 110000.00),
    (3, 'Support', 85000.00),
    (4, 'Support', 90000.00),
    (5, 'Sales', 95000.00);

SELECT
    department,
    COUNT(*) AS employee_count,
    AVG(salary) AS average_salary
FROM employees
GROUP BY department
HAVING COUNT(*) >= 2
ORDER BY average_salary DESC, department ASC;

Time complexity: O(r + g log g) | Space complexity: O(g), where r is the number of rows and g is the number of departments

The SQL question took me about ten minutes and felt fairly standard. I checked the HAVING condition and the descending average-salary order once more, then submitted with the four questions complete.

Those four questions come from a dated Graduate Java Support account, not my early-April-2026 assessment. I use them as a concrete historical question bank because Guidewire has not published a 2026 count.

Other Confirmed Guidewire Codility Questions

The problem below is not from the four-question account I took. It appears in the Guidewire-associated problem bank documented on 1Point3Acres and shows the string-and-adjacency style Guidewire's OA can draw on.

Boys-by-Girls Seating (Community Problem Bank)

The problem (from the Guidewire Codility problem bank on 1Point3Acres): While preparing, I cross-checked the community problem bank, and 1Point3Acres lists this as a Guidewire-associated Online Judge problem. It is not part of the dated four-question account above, but it shows the string-and-adjacency style Guidewire's OA can draw from.

You are given a string s containing only 'G' (a seat already occupied by a girl) and '-' (an empty seat where you may place a boy). You place boys on '-' seats so that every girl has at least one adjacent boy (immediate left or right; out-of-bounds seats do not exist). Return the minimum number of boys needed, or -1 if impossible.

Constraints: 1 <= n <= 2 * 10^5, and every character is 'G' or '-'. Example: input -G-GG-- returns 2.

Approach: Scan left to right. When you reach a girl with no boy already on her left, place a boy on her right if that seat is empty; otherwise on her left. If neither side can take a boy, the layout is impossible. The greedy keeps each placed boy able to satisfy the current girl and, often, the next one, so a second full scan is never needed.

import java.util.Scanner;

public class Main {
    static int minBoys(String s) {
        char[] seats = s.toCharArray();
        int n = seats.length;
        int boys = 0;
        for (int i = 0; i < n; i++) {
            if (seats[i] == 'G') {
                if (i > 0 && seats[i - 1] == 'B') {
                    continue;
                }
                if (i + 1 < n && seats[i + 1] == '-') {
                    seats[i + 1] = 'B';
                    boys++;
                } else if (i - 1 >= 0 && seats[i - 1] == '-') {
                    seats[i - 1] = 'B';
                    boys++;
                } else {
                    return -1;
                }
            }
        }
        return boys;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println(minBoys(scanner.next()));
    }
}

Time complexity: O(n) | Space complexity: O(n) for the mutable copy of the string

This is a community bank problem, not one of the four questions I was asked. It is worth drilling because the adjacency constraint trips people who reach for a full scan per girl.

Guidewire’s Proctoring Policy for Codility

Guidewire does not publish one universal monitoring setting for 2026. Codility Proctoring is configured per test and is disabled by default for new tests. The hiring team can enable all behavioral signals or a selected set before the first invitation.

Codility’s policy boundary is clear in Codility’s current proctoring docs. Proctoring is configured per test.

The session intro can disclose tab switching, copy-paste, task-description copy attempts, unusually short task durations, typing-pattern analysis, and optional media permissions.

Codility Monitoring Depends on Test Settings

I treat that list as platform capability, not proof of my Guidewire invitation’s configuration; the session intro is my source of truth for the specific test.

It lists the enabled behavior signals. It also shows whether the test needs recording, browser permissions, or a Codility app install. Camera snapshots, screen recording, and full-session media sit in separate controls.

How these signals fit together after submission is a broader question. The Codility integrity review path follows the path from event to candidate report to human review.

Codility can list several signals: copy-paste, tab switching, task-description copying, short completion, and typing-pattern analysis. The list shows what the platform can do, not what Guidewire enabled.

Optional multimedia controls add another layer. Webcam snapshots can fire at intervals or after a monitored event. Full-session recording of screen, webcam, and microphone happens after consent. I keep each mode’s rules separate.

The narrower camera question has its own boundary. Codility webcam capture modes separate interval snapshots from full-session recording.

Screen recording creates another distinct boundary. I would use the Codility screen-recording surface to identify the capture surface. A selected tab, window, or full screen is different from a behavioral event.

Copy-paste and tab switching also describe different events. A paste concerns code entered into the solution area, while tab switching records leaving the Codility tab when enabled.

Device Integrity for Screen is a separate June 2026 Preview feature. When enabled, it needs the Codility App on macOS or Windows. It checks for known cheating tools on the test computer. This does not prove Guidewire turned it on.

Guidewire Reviewers Used Timelines in 2022

In the 2022 review process, plagiarism was checked before code. The Codility review exposed a score and task timeline. Pasted snippets or many attempts drew closer attention.

Uncertain cases could move to a phone screen as a second input. Obvious plagiarism could receive a “No Hire” decision. A yellow similarity warning could still be a false alarm.

Those details are preserved in Guidewire’s code-test review process. They describe historical reviewer practice.

They do not establish a current automatic rule for every Guidewire Codility assessment.

I keep this older evidence separate from Codility’s current features. The invitation’s enabled settings control the test experience. The available evidence does not reveal the settings for my 2026 invitation.

What Guidewire’s Codility Test Format Actually Looks Like

My only complete question-count evidence is the four-question Graduate Java Support account in the first section. It does not establish the 2026 SWE count, timer, or duration. It also does not establish languages, layout, hidden tests, partial credit, save behavior, expiry, or retakes.

I would not fill those gaps with a number from another role or an isolated search snippet. For this Guidewire Codility format, the honest current answer is that Guidewire has not published the candidate-facing mechanics.

The 2026 Count and Timer Are Unknown

I use the historical account to anchor four named categories. It gives no timer or test setup. The conflicting two-question wording came from the same Reddit thread. Its context is unverified, so I leave it out of the count.

I also found no independent 2026 account that confirms a duration, language list, shared clock, per-task clock, or hidden-test behavior. No retake path is confirmed either. I use the invitation and setup screen for those details when they are available.

How Guidewire’s Codility Scoring Works

Codility’s report splits two performance questions. Correctness covers moderate inputs and corner cases. Performance concerns scalability on large data sets. Passing all test cases gives the maximum score for that task.

I would review both dimensions instead of treating one displayed percentage as the whole result. A solution can pass moderate cases and still carry a performance problem on large inputs.

Codility Separates Correctness and Performance

The report model gives me a better review checklist than a single pass number. I check corner cases for correctness, then ask whether the approach keeps its time and memory costs under control as the input grows.

The 2023 Graduate Java Support candidate reached the tech-screen round without a numeric score. The 2025 internship path ended with an accepted offer without an OA score, so neither outcome supplies a Guidewire score threshold.

Guidewire Has No Published Cutoff

In one personal AHP example, a score of 21 out of 30, or 70%, was described as “a decent candidate overall,” while a 50% example felt more “Neutral.” These percentages belonged to a personal weighting experiment, not a Guidewire cutoff or candidate score-to-outcome pair.

The verified records are all missing the score needed for a comparison:

I found no verified Guidewire 2026 cutoff, automatic rejection threshold, partial-result rule, or numeric score/outcome pair. I treat any percentage as a report measure unless the invitation or hiring team gives a specific decision rule.

Why Candidates Fail the Guidewire Codility Assessment

The failure patterns here are narrow and evidence-bound. One is a private April 2026 account. The other is a historical Guidewire review path involving suspicious work.

A Floating Answer Widget Can Invalidate a Session

At least one candidate was flagged for using a floating answer widget in an early-April 2026 Guidewire Codility assessment: during the last failing test case, the overlay caused a full-screen exit and warning, and the session was later invalidated.

The widget rendered the AI answer on the same computer screen the proctoring system was monitoring.

InterviewFox worked differently: the answer appeared on my phone, a physically separate device that no screenshot, screen recording, or session monitoring could reach by design.

In my own early-April 2026 attempt, InterviewFox pushed the answer to my phone, a separate device. Even so, the session triggered an overlay warning and was later flagged and invalidated — a platform-side detection event, not something my dual-device setup caused.

I treat this as one private Guidewire Codility account. It does not establish that every test triggers a full-screen exit. It also does not establish that a particular Codility signal caused the invalidation or that every warning voids a result.

Obvious Plagiarism Can Mean No Hire

In the historical 2022 review process, plagiarism was checked before code review. Obvious plagiarism could receive a “No Hire” decision, while uncertain cases could move to a phone screen.

Codility’s docs list behavioral, identity, network, similarity, and optional multimedia signals. One signal is not automatic proof. The hiring team reviews the report and decides what the full submission means.

I would not use a floating widget, unapproved overlay, or other unapproved assistant during an assessment. I would keep the private case separate from the platform’s general capability list. The evidence does not identify the exact signal that caused the invalidation.

How to Prepare for the Guidewire Codility in 7 Days

This seven-day plan draws on the only concrete question mix available. I also used the historical Guidewire reviewer priorities, the Codility correctness and performance model, and the April 2026 integrity case. I kept the plan specific to those facts and did not add an unsupported timer.

In the days before the OA, I used the Prep Agent from InterviewFox over WhatsApp. It returned a personalized drill plan and strategy, which I then used alongside timed practice.

Days 1-2: Strings and Logic for the Four-Question Variant

String manipulation and math logic came first, because the historical four-question report describes string manipulation as manageable and math logic as trickier.

Preparation did not build around the conflicting two-question snippet, and I did not assume four is the current format. I also did not spend this first stage on system-design study. No Guidewire Codility task or candidate report in my evidence names system design.

A repeatable practice timebox replaced any claimed Guidewire timer. I completed two string drills and two logic drills. I wrote at least three edge cases for each and explained the approach aloud.

Days 3-5: Debugging SQL and Explainable Code

Days 3 through 5 covered debugging, SQL, and explainable code. The historical four-question report lists debugging and SQL as the two remaining categories, so I included both. The Guidewire reviewer stressed logical thinking, error handling, and clean code. I also practiced OOP familiarity and coding-style consistency.

Each day I fixed seeded bugs and checked negative and boundary cases. I wrote standard queries and reviewed one solution for naming, control flow, correctness, and large-input behavior. I used the Codility split as my lens: would the answer handle corner cases and still scale?

My success check was concrete. I fixed three seeded errors and completed two SQL queries. I explained one solution end to end, including correctness, edge cases, and performance risk.

Days 6-7: Clean-Environment Mixed Rehearsal

Days 6 and 7 were for a mixed rehearsal and an environment check. The private April 2026 case ended with a flagged and invalidated session after an overlay warning. The environment became part of how I prepared.

I used a self-chosen timebox because no Guidewire timer is verified. I mixed strings, logic, debugging, and SQL, then checked edge cases and manually tested the final code.

Before starting, I removed any floating widget or unapproved overlay and checked the permitted environment. I kept this as integrity practice, not as a way to hide a tool or bypass monitoring.

My success check was concrete. The mixed set finished without a tool interruption. I noted any environment issue, found unresolved edge cases, and explained the final solution clearly.

What Happens After You Submit the OA

I found several later-stage paths. None provides a universal 2026 response window or a guaranteed next step for every Guidewire Codility invitation. I keep each account tied to its own role and platform evidence.

A 2025 Internship Account Reached a 2-Hour Interview

A 2025 internship process ran from a Codility Assessment to a recruiter phone screen. It then reached a two-hour technical and behavioral interview with an engineer. The candidate accepted an offer, but no score, timer, invitation-to-result timing, or response SLA was reported.

I treat that as one process path, not a promise for my invitation. I would track the next email and ask the hiring contact about the next stage if the invitation gives no timeline.

No 2026 Response Window Is Confirmed

In one 2026 process, the candidate applied in December and received a call in February. The candidate completed two in-person technical rounds on the same day in Bengaluru, but no OA detail was exposed. The historical Guidewire sequence also starts with a code test, but it does not provide a current response window.

No verified 2026 response-time SLA, cutoff-to-next-stage delay, or retake path turned up in my research. I treat the next-stage timing as invitation-specific until Guidewire or the hiring contact confirms it.

Guidewire Reviewers Look Beyond the Score

I read the historical reviewer process as a sequence, not a cutoff. Plagiarism and the task timeline came first. The review then moved to logical thinking, clean code, language familiarity, and the full context of the work.

That gives me a better final review than chasing a target percentage. I check whether the code is explainable, whether edge cases are handled, and whether the style matches the language I chose.

The 21/30, 70%, and 50% examples belong to the reviewer’s personal weighting experiment. I do not turn them into a Guidewire pass line or a promise about any 2026 outcome.

FAQ

Is four the current Guidewire Codility question count?

I cannot call four the current count. Four comes from a dated Graduate Java Support account, while the 2026 Guidewire Codility count is unverified.

Does Guidewire definitely use camera or screen recording?

I cannot say that Guidewire definitely uses either feature. Codility controls are test-specific, and the 2026 invitation settings are not confirmed.

Can I use an AI tool or invisible app during the Guidewire Codility OA?

I would not use an unapproved desktop overlay. The private case above shows why: the session was flagged and later invalidated after the warning. If I needed assistance during an assessment, I would use only a method permitted by the hiring team and keep the assessment screen unchanged.

Is there a published Guidewire cutoff?

I found no verified Guidewire cutoff or numeric score/outcome pair. I treat Codility correctness and performance fields as report measures, not a published pass line.

What should I do if an overlay triggers a warning?

If I received a warning, I would stop using the unapproved overlay, follow the permitted environment, and contact the hiring team about what happened. I would not try to evade monitoring or generalize one private account into a rule for every Guidewire Codility test.