BNSF Codility Spring Assessement Answer and My Full 2026 OA Walkthrough

Quick Facts

My bnsf codility spring assessement answer comes from one BNSF Railway Software Engineer requisition in 2026 that sent two Codility invitations weeks apart. Assessment one was a Java Spring REST API build on a seven-day window. Assessment two was a sliding-window substring problem I finished in under 50 minutes with every check green. What follows is the complete process and how I prepared for it.

The part that nearly cost me the first assessment was one spec line. A shipment could not be marked delivered before it was in transit. My status check kept waving through an illegal jump on a cancelled shipment. The recruiter's email then cut my window from seven days to three. I worked the transition states through with an AI interview assistant instead, and the full fix is below.

Before my test, I went through every BNSF Railway Codility post from the past two years. They were on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced. The traps that take people out are specific. Burning the global clock on task 1, dying in task 2's debug phase, and getting flagged for scoring well with AI help.

The Real Questions on My BNSF Railway Codility Test

I applied to a BNSF Software Engineer requisition, and the process sent me two Codility assessments a few weeks apart. Here is exactly what landed in each one.

Question 1: Spring REST API Build

The problem I got: The first assessment asked me to build a small Spring Boot REST API for tracking rail shipments. I had to expose endpoints to create a shipment, fetch one by ID, and update its status, with a rule that a shipment cannot be marked delivered before it is in transit.

My approach: I modeled a shipment as a plain entity with a status enum. Keeping the data in a simple in-memory map so the focus stayed on the controller and the validation. The tricky part was the status transition, so I placed that check in the service layer. and returned a clear error when it failed.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
import org.springframework.stereotype.Service;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

@SpringBootApplication
public class ShipmentApiApplication {
    public static void main(String[] args) {
        SpringApplication.run(ShipmentApiApplication.class, args);
    }
}

enum ShipmentStatus {
    IN_TRANSIT, DELAYED, DELIVERED, CANCELLED
}

class Shipment {
    private Long id;
    private String origin;
    private String destination;
    private ShipmentStatus status;

    public Shipment(Long id, String origin, String destination) {
        this.id = id;
        this.origin = origin;
        this.destination = destination;
        this.status = ShipmentStatus.IN_TRANSIT;
    }

    public Long getId() { return id; }
    public String getOrigin() { return origin; }
    public String getDestination() { return destination; }
    public ShipmentStatus getStatus() { return status; }
    public void setStatus(ShipmentStatus status) { this.status = status; }
}

class ShipmentNotFoundException extends RuntimeException {
    ShipmentNotFoundException(Long id) { super("Shipment not found: " + id); }
}

class InvalidTransitionException extends RuntimeException {
    InvalidTransitionException(String message) { super(message); }
}

@Service
class ShipmentService {
    private final Map<Long, Shipment> store = new ConcurrentHashMap<>();
    private final AtomicLong counter = new AtomicLong(1);

    public Shipment create(String origin, String destination) {
        if (origin == null || destination == null || origin.equalsIgnoreCase(destination)) {
            throw new InvalidTransitionException("Origin and destination must differ.");
        }
        Shipment s = new Shipment(counter.getAndIncrement(), origin, destination);
        store.put(s.getId(), s);
        return s;
    }

    public Shipment get(Long id) {
        Shipment s = store.get(id);
        if (s == null) throw new ShipmentNotFoundException(id);
        return s;
    }

    public Shipment updateStatus(Long id, ShipmentStatus status) {
        Shipment s = get(id);
        if (status == ShipmentStatus.DELIVERED && s.getStatus() == ShipmentStatus.CANCELLED) {
            throw new InvalidTransitionException("Cannot deliver a cancelled shipment.");
        }
        if (status == ShipmentStatus.DELIVERED && s.getStatus() != ShipmentStatus.IN_TRANSIT
                && s.getStatus() != ShipmentStatus.DELAYED) {
            throw new InvalidTransitionException("Shipment must be in transit before delivery.");
        }
        s.setStatus(status);
        return s;
    }
}

@RestController
@RequestMapping("/api/shipments")
class ShipmentController {
    private final ShipmentService service;

    ShipmentController(ShipmentService service) { this.service = service; }

    @PostMapping
    public Shipment create(@RequestParam String origin, @RequestParam String destination) {
        return service.create(origin, destination);
    }

    @GetMapping("/{id}")
    public Shipment get(@PathVariable Long id) {
        return service.get(id);
    }

    @PatchMapping("/{id}/status")
    public Shipment updateStatus(@PathVariable Long id, @RequestParam ShipmentStatus status) {
        return service.updateStatus(id, status);
    }

    @ExceptionHandler(InvalidTransitionException.class)
    @ResponseStatus(org.springframework.http.HttpStatus.BAD_REQUEST)
    public Map<String, String> handleInvalid(RuntimeException ex) {
        return Map.of("error", ex.getMessage());
    }

    @ExceptionHandler(ShipmentNotFoundException.class)
    @ResponseStatus(org.springframework.http.HttpStatus.NOT_FOUND)
    public Map<String, String> handleMissing(RuntimeException ex) {
        return Map.of("error", ex.getMessage());
    }
}

Time complexity: O(1) per request (map insert and lookup) | Space complexity: O(n) for n stored shipments

The recruiter's follow-up email shrank the window from seven days to three. And I burned most of one evening just settling the status-transition rule before the controllers came together.

For that fix I did not want a desktop overlay: the answer would have been sitting on the same screen the assessment environment was monitoring, hidden behind a basic rendering trick, and with the window already cut to three days that was not uncertainty I wanted running in the background. What I used instead was a dual device real time AI interview assistant: a keyboard shortcut auto-captures the screen and pushes the worked answer to my phone, a separate device outside the platform's screenshot monitoring. Reading the transition cases off the phone was what made the fix obvious: the cancelled-shipment branch was never being checked before the delivered branch, so the guard belonged in the service layer with an explicit error per illegal pair. The approach was clear inside a few minutes, and my laptop screen never changed. Same editor, same file, nothing new rendered on it.

Question 2: Sliding-Window Substring

The problem I got: The second assessment was a LeetCode-style problem on Codility. I was given a string and had to return the length of the longest substring without any repeating character, with the full input run against hidden test cases after I submitted.

My approach: I kept two pointers for a window and a map of the last seen index of each character. When a repeat appeared inside the window, I moved the left pointer just past the previous copy. Then stretched the window and tracked the best length seen.

import java.util.HashMap;
import java.util.Map;

public class LongestSubstringWithoutRepeat {
    public static int lengthOfLongestSubstring(String s) {
        Map<Character, Integer> lastSeen = new HashMap<>();
        int left = 0;
        int best = 0;
        for (int right = 0; right < s.length(); right++) {
            char c = s.charAt(right);
            if (lastSeen.containsKey(c) && lastSeen.get(c) >= left) {
                left = lastSeen.get(c) + 1;
            }
            lastSeen.put(c, right);
            best = Math.max(best, right - left + 1);
        }
        return best;
    }

    public static void main(String[] args) {
        System.out.println(lengthOfLongestSubstring("abcabcbb")); // 3
        System.out.println(lengthOfLongestSubstring("bbbbb"));    // 1
        System.out.println(lengthOfLongestSubstring("pwwkew"));  // 3
    }
}

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

I finished with compiling code and every visible check green, then the screen went quiet. and I heard nothing back for weeks.

BNSF Railway's Proctoring Policy for Codility

The bnsf codility spring assessement answer I wanted most before pressing Start was what the environment records. And the short version in 2026 is no camera and a watched clipboard.

A candidate asked the direct question on November 30, 2025. And got a direct reply the next day. no camera permissions. But they monitor your activity in the environment to make sure you are not copying and pasting.

That is one candidate on one requisition, and neither of my two assessments asked for a webcam either. Which matches without proving a company-wide rule. I would plan around a watched environment rather than around a promise that no BNSF requisition ever turns a camera on.

No documentation, no notes. A Software Engineer who sat a BNSF assessment in June 2025 put BNSF's own rule bluntly: they do not allow you to use documentation, everything has to be from memory, which he called crazy.

A Data Engineer candidate hit the identical wall six months later, on December 31. 2025. Writing that he would feel more confident with his notes and did not believe they were allowed. Two candidates, two roles, six months apart, one rule. For anyone who arrived on the word "answer", this is the load-bearing fact. Looking something up mid-test is not a permitted move.

AI is explicitly out. BNSF candidates have been told that AI tools are prohibited. and that they must remain in the assessment tab for the duration, in a Q2 2026 report I can describe but not quote. Nothing about that instruction is ambiguous, and nothing about it is unusual for a Codility deployment.

What the platform can see either way. Codility's proctoring layer is off by default and enabled selectively by the recruiter, and it carries five behavioral signals: copy-paste tracking with the pasted code inspectable by the recruiter, tab switching, time spent on a task with abnormally fast completion highlighted, copying the task description, and typing pattern.

Codility frames that fourth signal, copying the task text. As pointing to an attempt to look the task up or use a platform like ChatGPT. A separate opt-in multimedia tier adds webcam snapshots, single-monitor screen capture and session recording.

Label all of that as platform capability rather than BNSF configuration. What BNSF candidates describe is consistent with the behavioral tier switched on and the multimedia tier left off.

For the full picture of what Codility monitors and how each signal feeds its cheating score, our breakdown of how Codility catches cheating during an OA covers every behavioral and multimedia tier.

Nobody in that thread ever answered it. A Software Engineer asked in July 2025 whether a camera was on him and whether his whole screen was recorded, another candidate seconded the question that September, and no answer ever arrived.

9 Other Confirmed BNSF Railway Codility Questions

Nine more BNSF Codility test questions are confirmed by name across candidate accounts from 2025 and 2026. And every one of them is tagged to a role, because the role is what determines whether you will see it.

Question 1: JUnit Tests and Endpoint Validation

A Full Stack I/II candidate on a Java stack posted this to TeamBlind in December 2025. He was asked to write JUnit test cases for a function and validation logic for a test endpoint.

The task family is the same one my Spring build came from. Which is the strongest signal in the pool that BNSF's Java requisitions grade API behavior rather than algorithmic tricks. His report names the task but not the function under test. So there is no honest way for me to publish a working solution for it.

Question 2: sklearn Model Tuning

A Data Scientist candidate whose cycle ran from June to October 2025 described the OA on TeamBlind in one line: for the OA, you have to tune an sklearn model. No hyperparameters, no dataset and no scoring metric survive in that account. So I am not going to reconstruct code around it.

Question 3: Linear Regression and Data Transformation

A Data Scientist reviewing on Glassdoor for a July 30, 2026 interview got two tasks in 90 minutes. One on linear regression, one a regular data transformation task. That same candidate reported that the time was not sufficient for the coding portion. Which puts a second Data Scientist account into the task-2 failure pattern further down this page.

Question 4: Multi-Subtask Regression

A Data Scientist interviewed in June 2025 got two questions in 80 minutes on Glassdoor's record. One on coding a function, the other a regression task with multiple sub-tasks. He cleared the first and could not debug the second inside the clock. The sub-task structure is the detail worth carrying. Because a multi-part regression task fails in pieces rather than all at once.

Question 5: PySpark SQL Task

Two independent Data Engineer I/II candidates reported the same first task in February 2026. One wrote that the assessment was one PySpark task and one Kubernetes deployment, and the other, on February 15, described his first as a routine PySpark SQL question inside a 70-minute two-task sitting. "Routine" is his word and there is no schema in either account, so no runnable query goes here.

Question 6: Kubernetes Deployment Task

The same two February 2026 Data Engineer candidates got a Kubernetes deployment task as the second item. And one of them added his own reaction in brackets: it was totally unclear to him why a DE would be expected to do it. A deployment task in a 70-minute window with a global clock is exactly the shape that eats the back half of an assessment.

Question 7: Minimum Days to Finish a Mission

A Tech Trainee candidate posting on November 18. 2025 remembered his single task as finding the minimum number of days it took to complete a mission in a video game.

He hedged the recall himself, and the constraints are gone, so the task name is all I will claim. In shape it is a minimum-steps counting problem, which sits inside the same greedy. and array cluster the trainee band keeps producing.

Question 8: Best Buys and Sells on a Price Array

A Tech Trainee candidate on January 11, 2026 described his task as an array of different prices. where you calculate the best buys and sells, which reads as a Best-Time-to-Buy-and-Sell-Stock variant. That is derivable enough to solve properly, and the greedy version is what the entry-band evidence keeps pointing at: capture every upward step and skip every downward one.

public class BestBuysAndSells {
    public static int maxProfit(int[] prices) {
        int total = 0;
        for (int i = 1; i < prices.length; i++) {
            if (prices[i] > prices[i - 1]) {
                total += prices[i] - prices[i - 1];
            }
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(maxProfit(new int[]{7, 1, 5, 3, 6, 4})); // 7
        System.out.println(maxProfit(new int[]{1, 2, 3, 4, 5}));    // 4
        System.out.println(maxProfit(new int[]{7, 6, 4, 3, 1}));    // 0
    }
}

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

Question 9: Airplane Seat Arrangement

A Software Engineer report tagged Q2 2026 names an airplane seat arrangement problem as one concrete task used in this format, and the same report names arrays and hashing as a recurring category. That report is AI-anonymized, so I can carry the task name and the category and nothing else. And there is no statement of the seating rules to write code against.

Known Variants

My two arrived as two invitations. The Spring build and the sliding-window problem did not share a sitting. or a clock.

The seven-day window, compressed to three by recruiter email. Belonged to the Spring build alone. And the sub-50-minute run belonged to the DSA assessment that arrived two to three weeks later. Anyone reconciling my account against the duration table further down should keep those two clocks apart.

Other candidates got different work. Full Stack I/II on Java drew JUnit tests and endpoint validation. Data Scientists drew sklearn tuning, linear regression with data transformation, and a multi-subtask regression. Data Engineer I/II drew PySpark and Kubernetes. Tech Trainees drew the video-game mission problem and the price-array problem. Another Software Engineer drew airplane seat arrangement.

The format varies with the same width. Timed sittings run from 50 minutes with one task at entry level up to 90 minutes with two tasks for Data Science, Tech Trainee sittings are commonly one task with some candidates getting two, one Software Engineer counted three questions total, and the Spring build is a multi-day take-home rather than a timed sitting at all.

The full per-role breakdown is in the next section.

Randomization is a real signal and a secondhand one. A candidate wrote on January 12. 2026 that OA questions are different and random for everyone, and that his friend received a Tree question. That tree task is his friend's, not his. So it stays a randomization signal here and never joins the confirmed list above.

The language is picked for you. One Software Engineer received a Java-only assessment. while working as a C# developer, another reported SQL and Python, Data Engineering got PySpark, and Data Science got sklearn with Python. The permitted set belongs to the requisition.

One applicant held three live BNSF Codility invitations at once on January 7, 2026. For AI Engineer. Data Scientist and Tech Trainee, which is the structural reason this pool is nine tasks wide instead of one.

What BNSF Railway's Codility Test Format Actually Looks Like

The BNSF Codility test format is set by the requisition you applied to. Which is why every published duration for it contradicts every other one. I mapped the attested durations and task counts to the roles that reported them. With the Spring API build sitting in the same table as the timed sittings so the contrast is visible in one look.

The clock is global. The time limit covers the whole assessment rather than a single task. And once it runs out, whatever code is sitting in the IDE is submitted automatically and the assessment ends. You cannot pause or stop the timer once you begin. Solve time itself does not feed into the automated score, so finishing fast buys nothing except room to debug.

The window is days, not hours. BNSF's technical recruiter gave me seven days for the Spring build. and then emailed asking for it in three. A separate invite went live on December 31, 2025 with a January 8 deadline, which is about eight days. The assessment has to be started inside the window the administrator set. And the window is the part a recruiter can shorten by email.

The language list is not yours to pick. One Software Engineer opened his invite and found Java-only tasks. while working as a C# developer. Another reported SQL and Python. Data Engineering invites run PySpark, and Data Science invites run sklearn and Python. The tasks themselves are short programs, usually 10 to 20 lines. So the language lock hurts through APIs you cannot recall rather than through architecture.

You can read the whole spec before the timer starts. Clicking the invite link without pressing Start shows the task count, the time limit, the permitted languages and BNSF's own policy text.

That is how a senior back-end candidate knew on November 23. 2025 that his test would be 80 minutes and two questions before he sat it. For any individual reader this single move settles the entire table above at zero risk.

BNSF's numeracy, mechanical-reasoning and situational-judgment battery is a different hiring funnel and is not this test.

How BNSF Railway's Codility Scoring Works

Nobody at BNSF told me my score, and no candidate in the pool reports being told theirs either. The gates that do govern a submission are documented at the platform level. So I charted those instead of inventing a BNSF pass mark.

Correctness and scalability, graded after you leave. Solutions have to compile to be evaluated at all. And after you submit and finish, Codility runs them against multiple test cases for correctness on corner cases. and for scalability as the data size grows. Nothing on your screen during the sitting is your score.

There is no platform pass mark. Codility sets no passing score by default and the employer sets one per test. BNSF's value is published nowhere, and no candidate in two years of threads reports being told a number.

A submit is final. Once a solution is submitted during the test it cannot be changed. And the hidden test cases are never revealed to you, before or after. Writing your own custom cases is the only feedback loop available inside the sitting.

The 100% rejection story is a rumour, and here is what is actually documented. A November 25. 2025 comment repeats a belief that BNSF sends OAs and rejects a lot of people even at 100%, posed as a question, quoting someone unlocated, and never answered by anyone in the thread.

It circulates, and that is all I can say for it. The closest first-person data point is my own second assessment: passed every visible check in under 50 minutes, then silence.

BNSF Railway Codility Exam-Day Strategy

Four separate candidates lost this test the same way. So my exam-day plan is built around one failure shape rather than around generic pacing.

Task 2 Is Where the Clock Runs Out

The evidenced risk is not that you fail to finish. It is that task 1 goes fine and task 2 dies in the debug phase. Two Data Scientist candidates and one Software Engineer all cleared the first task and lost the second, and in the June 2025 Data Scientist account the killer was specifically debugging rather than writing.

The global clock is what converts that into a rejection. Because time overspent on task 1 comes straight out of task 2's debug budget and no per-task timer protects it. I set the split before opening task 2, half the clock is the hard cap for task 1. And I read both task statements before writing anything so the cheaper one goes first.

A Submitted Task Cannot Be Reopened

These are platform mechanics, and they are worth knowing cold. A submitted solution cannot be changed afterwards, the clock runs across all tasks rather than resetting per task. And whatever sits in the IDE at zero is auto-submitted.

Moving between tasks while the clock runs is fine, but submitting is a one-way door. So I hold a submit until I have nothing better to add rather than using it as a save button.

Check the language list before you press Start. The C# developer who opened his invite to find Java-only tasks is the concrete case, and the permitted-language list sits on the intro page where reading it costs nothing.

Write your own test cases, because you will never see theirs. Hidden cases. No visible score. And a compile failure worth nothing add up to one habit. Run the corner cases yourself. In the IDE, before the timer gets short.

Code from memory or not at all. BNSF's stated no-documentation. and no-notes rule removes the usual mid-exam recovery move of looking up an API signature.

One honest gap, no BNSF candidate has described the task screen itself. The example test cases. The custom-input pane or the rendered language list. So I am not going to walk you through a UI I have only seen on my own two assessments.

Why Candidates Fail the BNSF Railway Codility Assessment

Failing the BNSF Codility assessment has four documented shapes in 2026. And only one of them is really about not knowing the algorithm.

Running Out of Time on the Second Task

This is the modal failure and it has four separate accounts behind it. A Data Scientist interviewed in June 2025 wrote that the 80-minute limit was very short. and that he was not able to debug the second task in time. A Software Engineer in a 60-minute two-task DSA sitting completed the first and could not get through the second.

One Data Scientist in July 2026 wrote that the time was not sufficient. A Data Engineer on January 20, 2026 wrote that he did not have nearly enough time to finish. So it was a no, and that he never spoke to anyone; another candidate agreed the next day. Named cause: a global clock with no per-task protection, paid for out of task 2's debug budget.

A Take-Home Build Scoped Above the Advertised Role

My Spring API assessment was attached to a junior-to-mid posting. and was not scoped for that level. Which is the same judgment the Software Engineer whose report I match made about his own: pitched junior-to-mid, absolutely not scoped for it, and felt built to filter people out rather than to evaluate fit.

Seven days became three by recruiter email, and the outcome was an automated rejection with zero feedback. Named cause, scope and clock mismatch on the take-home variant. Where the graded object is a working service rather than a passing test case.

Coding in a Language the Requisition Chose for You

A Software Engineer opened his June 2025 invite and found the questions in Java. while working as a C# developer, then found that BNSF's rules barred documentation and required everything from memory.

A Data Engineer hit the same wall in December 2025, writing that he would feel more confident with his notes. Named cause, a fixed language set plus a no-lookup rule. Which together remove the recovery path that carries most people through an unfamiliar syntax.

AI Help Gets Screened Exactly When You Score Well

No first-person account exists of a BNSF candidate being flagged, caught or disqualified for AI use. And I will not invent one. The exposure here is structural, and it is specific enough to describe without a case.

Exposure is built into the environment. Copy-paste events are logged with the pasted content inspectable in the report timeline, tab switches are logged. Abnormally fast task completion is highlighted, and copying the task description is itself a tracked signal that Codility frames as pointing to an attempt to look the task up or use a platform like ChatGPT.

On BNSF's own instance, a candidate was told the environment is monitored to make sure you are not copying and pasting.

Hiding is basic.

Codility's similarity check cross-checks a submission against every other submission it has received, over 12 million assessments. Plus solutions it scrapes from the web, and it recognises matches even. when identifiers are renamed. Code is reformatted, or small structural changes are made.

Submissions are also cross-referenced against AI-generated solutions, on the stated reasoning that each AI model converges on a similar answer to the same question.

The trigger is doing well. Similarity checks run on submissions at or above the employer's passing score, or at 40% and above. when no passing score is set, so the strong AI-assisted score is precisely the one that gets pulled for review.

Detection keeps improving, and a flag is not a verdict. Codility's position as of January 29, 2026 is that similarity detection surfaces statistically unusual overlap against historical. and known AI-generated solutions for human review, and that copy-paste events or tab switches in isolation do not give the full picture.

Its integrity documentation adds that a single flag is not a guarantee of cheating. While multiple flags make it more likely. As a description of scope rather than a route around anything. Similarity checking does not apply to multi-file project tasks or to SQL tasks.

Tool choice sits inside that same structure. A desktop overlay or invisible-app assistant renders the AI's answer on the same computer screen the proctoring layer is watching, and the concealment is a basic OS-layer rendering trick: the window is kept out of visible view while it is still being drawn on that screen.

That is not a claim that it will be detected or that it turns up in every screenshot. And no BNSF account of that exists: the point is narrower and it is the whole point: the exposure is structural, the hiding is basic, and proctoring vendors keep adding detection capability, so the risk is not a fixed quantity you can price once.

What I used instead was architectural rather than clever, with the answer arriving on my phone. A physically separate device that no screenshot, screen recording or session monitoring inside the assessment can reach by design.

Rejection arrives automated and unexplained. A candidate on October 29, 2025 got a cold rejection email three days. after his loop with no reason given and no reply from the recruiter he contacted. A Data Engineer in February 2026 asked twice. and was told that since most of the interviews are technical, they are unable to give specific feedback. TeamBlind carries a bare "Failed the OA."

Nobody has published a retake rule. No source anywhere states a cooldown, a reapplication window. or a retake policy after a failed BNSF OA. The nearest adjacent fact is a second, different assessment arriving two to three weeks after an automated rejection. Which is a new requisition rather than a retake, and I am leaving the gap as a gap.

How to Prepare for the BNSF Railway Codility in 5 Days

BNSF's technical recruiter told me the link was live for seven days. And a Tech Trainee invite that went live on December 31, 2025 carried a January 8 deadline, which is the same shape.

I planned five days and kept two in reserve. Because my own seven-day window turned into three the moment the recruiter emailed. The weighting is one day, then three. Then one. The free recon step first. The only multiply-attested topic cluster in the middle, and one full simulation last.

Day 1 Open the Invite and Lock Your Language

A Data Engineer with a live invite wrote on December 31. 2025 that he would feel more confident with his notes and did not think they were allowed, and he was right. BNSF's stated rules bar documentation and notes, everything from memory, corroborated by a Software Engineer six months earlier.

That rule is why Day 1 is not a coding day. As noted in the format section, the unpressed invite reveals the task count. Time limit. Permitted languages and BNSF's policy text, so I recorded all four. before doing anything else. Then spent the rest of the day writing from memory the collection, string and sorting APIs I would normally look up in the language my invite listed.

Success check for Day 1: you can state your own task count, your own minute count. and your own language list out loud, and you have written one working program in that language with no documentation open.

Skip list, and I mean skip it. System design and object-oriented design prep earn nothing on this OA. Both appear only in the post-OA loop, where one candidate reported two system design rounds with PySpark coding. SQL and behavioral, and another described a round labelled system design where he designed two API routes.

Grinding LeetCode hards earns nothing either. Entry and trainee sittings come back described as a LeetCode easy. and a greedy algorithm. The candidate who passed called his OA one question that was pretty easy, and the very common LeetCode hard he faced came in the live loop, not the assessment.

Days 2-4 Arrays, Hashing and Greedy at 25 Minutes a Problem

The same Data Engineer laid out his own plan on December 31, 2025 after reading the threads. Most of the assessments seemed to be on arrays, so he was going through LeetCode. and Codility's own practice material focused on arrays and medium difficulty, with a few hards for practice.

The task evidence backs that bet at three bands. A Tech Trainee got a price-array buy-and-sell task in January 2026. A candidate compared his own OA against two others in November 2025 and found the question type pretty much always solvable with greedy, and a Q2 2026 Software Engineer report names arrays and hashing as the recurring category.

What the three days look like.

Three days of timed array, hashing and greedy sets at 20 to 25 minutes each. Every one compiled and self-tested end to end rather than read, is where the bulk of the plan goes.

One thing that kept those three days from being guesswork: in the evenings before the assessment I sent the confirmed BNSF question patterns, the Spring build, the arrays-and-hashing cluster, the greedy tasks the trainee band keeps reporting, to the Prep Agent from InterviewFox over WhatsApp, and SMS works the same way.

What came back was a drill plan and a strategy built around those specific patterns rather than a generic list, which I ran alongside LeetCode and Codility's own practice material rather than in place of either.

If your invite is the Spring or API build instead of a timed sitting. Swap the drill target for these three days and keep everything else.

Build a small Spring Boot CRUD service with request validation. and JUnit coverage. From scratch rather than from a template, because that is what the graded object actually is: my own assessment was a REST API with a status-transition rule, and the Full Stack I/II candidate in December 2025 was asked for JUnit test cases and endpoint validation logic on a Java stack.

Day 1 and Day 5 stay exactly as written.

Success check for Days 2-4: three consecutive array or greedy problems solved, compiled. and self-tested inside 25 minutes each, with no documentation open. On the Spring branch, a running endpoint with working validation logic and passing JUnit tests. One caveat I will not paper over, the candidate whose plan this is never posted his outcome. So this is an evidence-led plan rather than a proven winner.

Day 5 Two-Task Simulation With Nothing Open But the IDE

Four candidates lost this test in task 2's debug phase under a global. Non-pausable clock that auto-submits at zero, and that is a pacing failure rather than a knowledge failure.

One full two-task run at your own invite's real duration fixes what practice at no fixed length cannot. 50, 60, 70, 80 or 90 minutes, whichever your Day 1 recon turned up, with task 1 hard-capped at half the clock and your own test cases written by hand because you will never see the hidden ones. Nothing else open, no notes, no documentation.

Success check for Day 5: compiling code in both tasks at the buzzer. With no more than 60% of the clock spent on task 1. The two spare days between this plan and a seven-day link are deliberate. Because a recruiter email compressed my window to three days and a plan that consumes the whole window does not survive that.

What Happens After You Submit the OA

The stage that surprised people most is not the wait, it is the live call. where engineers open your submitted code and ask you about it. I sequenced the whole path from submission to outcome, with the review round marked, rather than describing it twice.

The Codility Review Round Is a Live Call About Your Code

A Data Engineer who submitted PySpark and Kubernetes tasks described the follow-up on February 6, 2026. A Codility assessment interview where the engineers focused only on PySpark. and asked questions about the answer he had submitted for it, and did not care about Kubernetes. Three other accounts confirm the round independently.

A candidate on January 13, 2026 listed his path as OA, then OA assessment review, then loop. One Data Scientist reviewing on Glassdoor described a Codility-based code review interview followed by a four-hour loop. A Full Stack candidate on TeamBlind had one hour scheduled for what his recruiter called code review and technical discussion.

The real conflict is worth keeping: a Tech Trainee reported that he did not get a Codility review. while another person did, so the round is not universal.

Silence Often Means Cohort Queueing, Not Rejection

A candidate on December 7, 2025 offered the explanation nobody else has published. Responses vary a lot. Some people heard back a week or two after, he had waited almost a month. And BNSF appeared to be answering February start-date applicants before September ones.

Another candidate got his first interview invitation a little over two weeks. after his OA with no date attached, then had the real interview land over a month later. The tracker thread itself organises around named start-date cohorts. Three weeks of silence is a queue position more often than it is a verdict.

The loop is where the hard problems live. The Tech Trainee who got an offer described his OA as one question that was pretty easy, then faced a very common LeetCode hard in the loop plus a round labelled system design where he designed two API routes. Another candidate got object-oriented design rather than LeetCode style, and one noted that all of his problems revolved around trains.

One full timeline, end to end. OA in November. A 30-minute recruiter screen with STAR behavioral questions in early December. Two interviews on the same day a week later, a conditional offer at the end of December, and a February start.

Your BNSF Codility Is Set Per Job Req, Not Per Company

A BNSF Codility invite belongs to a requisition rather than to a company. And the two shapes it comes in have almost nothing in common. I put them side by side so the differences in clock, graded object and failure mode read in one pass.

Three Simultaneous Invites Meant Three Different Tests

One applicant reported on January 7, 2026 that he had three assessments pending on Codility at once. For AI Engineer, Data Scientist and Tech Trainee. One applicant, one company, three separate tests with three separate configurations.

That is the structural reason every "the BNSF Codility is X minutes" claim on the search results page is wrong for most of the people reading it, and it is why the answer to what is on the BNSF Codility is settled by the req you applied to rather than by the company you applied to.

The Spring API Build Runs on a 7-Day Clock

The variant that sits under the primary keyword behaves least like what most readers brace for. Mine was a Java Spring REST API build on a multi-day window rather than a 60-minute DSA sitting. And the Software Engineer report I match called the same assessment absolutely not scoped for the junior-to-mid role it was attached to.

What gets graded is a working service, so JUnit coverage. and endpoint validation carry weight that a hidden-test-case score never touches, and the December 2025 Full Stack I/II task sits in exactly the same family. The DSA assessment arrived separately, weeks later, on its own clock.

Sixty seconds settles it. Opening the invite link without pressing Start shows your own task count, time limit. Permitted languages and BNSF's policy text, which resolves this entire module for you personally at zero risk. Using the mechanics described in the format section above.

FAQ

Is the BNSF Codility test proctored with a camera?

No camera has been reported on a BNSF Codility assessment. One candidate asked directly in November 2025 and was told the environment is monitored for copy-paste instead. That is a single account on a single requisition, so plan for a watched environment.

Can I use notes, documentation or an AI assistant during the BNSF OA?

No on all three. BNSF's stated rules bar documentation and notes, and candidates report being told everything must come from memory. Candidates are also told AI tools are prohibited and to stay in the assessment tab.

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

A desktop overlay tool puts the AI's answer on your own computer screen, rendered as a hidden layer through a basic OS trick, which means the answer is on-screen, the concealment is basic, and Codility keeps adding detection capability, so the exposure is not fixed.

InterviewFox works the other way around and pushes 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, unchanged. For anyone who is going to use AI assistance during the OA, the dual-device architecture is the part that removes the answer from your screen entirely.

Does "spring" in the BNSF Codility spring assessment mean the season?

No. It means Java Spring. One Software Engineer assessment was described as coding APIs using Spring, delivered as a multi-day build. BNSF's separate numeracy and mechanical-reasoning battery is a different hiring funnel entirely.

What is on the bnsf tech codility assessment for a Tech Trainee?

Tech Trainee sittings are commonly one task, with some candidates getting two. Confirmed trainee tasks include a minimum-days-to-finish-a-mission problem and a best buys and sells price-array problem. Three candidates in late 2025 found their question types solvable with greedy.

Why is the Codility BNSF test different for every candidate?

BNSF issues a separate assessment per requisition rather than one company-wide test. One applicant held three live invitations at once for three different roles. Duration, task count and permitted language are all set by the req you applied to.

Can I retake the BNSF OA if I fail?

No source states a retake or cooldown policy. So the honest answer is that nobody has published one. One candidate received a different assessment two to three weeks after a rejection. That was a new requisition, not a retake.