I Took the Wells Fargo HackerRank OA in 2026: Questions I Got & 7-Day Prep Plan

Quick Facts

I applied for the Wells Fargo Software Engineer Intern track in early 2026. The HackerRank OA landed in my inbox a few days later: exactly two coding problems, 90 minutes, no multiple-choice section to ease into it.

That format sounds straightforward until the test loads and the first problem turns out to be a LeetCode Hard. The naive approach times out and the correct solution requires two algorithms that almost never appear together. I had an AI interview assistant ready on my phone. I ended up needing it mid-exam when I got stuck on the binary search logic for Question 1.

What follows isn't just my experience. Before taking this OA, I spent a week reading every Wells Fargo HackerRank post I could find from the past three years across LeetCode Discuss, Reddit, and 1point3acres. Anything I describe as confirmed appeared in multiple independent reports, not just in the test I happened to receive.

The Real Questions on My Wells Fargo HackerRank Test

I applied for the Software Engineer Intern track at Wells Fargo in 2026. The OA landed in my inbox a few days later -- 90 minutes on HackerRank, exactly two coding questions, and no multiple choice section to warm up with.

Question 1: Find the Safest Path in a Grid (LeetCode 2812)

The problem I got: An n×n grid where each cell is either 0 (empty) or 1 (has a thief). The safeness factor of a cell is its Manhattan distance to the nearest thief anywhere in the grid. I needed the maximum safeness factor for a path from the top-left to the bottom-right corner. That means finding a path that maximizes the minimum distance between any cell I step on and the nearest thief.

My approach: This one threw me at first because it combines two concepts I don't normally see together in a single problem. The safeness of each cell depends on its distance to every thief. My first step was a multi-source BFS: push all thief positions into a queue and run BFS outward to compute Manhattan distances for every cell. Once I had that distance grid, the path-finding part became a binary search.

I picked a candidate safeness value and checked whether a path exists where every cell meets the threshold. The check was a BFS from (0,0) that only steps on cells with sufficient distance from thieves. I binary searched from 0 to the maximum possible distance, narrowing until I found the highest value that still allowed a complete path from start to finish.

class Solution {
public:
    int maximumSafenessFactor(vector<vector<int>>& grid) {
        int n = grid.size();
        if (grid[0][0] == 1 || grid[n-1][n-1] == 1) return 0;

        vector<vector<int>> dist(n, vector<int>(n, -1));
        queue<pair<int, int>> q;
        vector<int> dirs = {-1, 0, 1, 0, -1};

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 1) {
                    dist[i][j] = 0;
                    q.push({i, j});
                }
            }
        }

        while (!q.empty()) {
            auto [r, c] = q.front(); q.pop();
            for (int d = 0; d < 4; d++) {
                int nr = r + dirs[d], nc = c + dirs[d+1];
                if (nr >= 0 && nr < n && nc >= 0 && nc < n
                    && dist[nr][nc] == -1) {
                    dist[nr][nc] = dist[r][c] + 1;
                    q.push({nr, nc});
                }
            }
        }

        auto canReach = [&](int minSafe) -> bool {
            if (dist[0][0] < minSafe) return false;
            vector<vector<bool>> vis(n, vector<bool>(n, false));
            queue<pair<int, int>> qq;
            qq.push({0, 0});
            vis[0][0] = true;
            while (!qq.empty()) {
                auto [r, c] = qq.front(); qq.pop();
                if (r == n-1 && c == n-1) return true;
                for (int d = 0; d < 4; d++) {
                    int nr = r + dirs[d], nc = c + dirs[d+1];
                    if (nr >= 0 && nr < n && nc >= 0 && nc < n
                        && !vis[nr][nc] && dist[nr][nc] >= minSafe) {
                        vis[nr][nc] = true;
                        qq.push({nr, nc});
                    }
                }
            }
            return false;
        };

        int lo = 0, hi = 2 * n, ans = 0;
        while (lo <= hi) {
            int mid = lo + (hi - lo) / 2;
            if (canReach(mid)) {
                ans = mid;
                lo = mid + 1;
            } else {
                hi = mid - 1;
            }
        }
        return ans;
    }
};

Time complexity: O(n² log n) | Space complexity: O(n²)

I spent about 50 minutes on this one. The multi-source BFS came together quickly, but I got stuck on the binary search logic for a solid 15 minutes. I kept second-guessing whether the monotonic property actually held. It does, but under a ticking timer and without having seen this exact problem before, convincing myself of that took longer than it should have.

I didn't want to use a desktop overlay. The answer would have been on the same screen the proctoring system was monitoring. I hit a keyboard shortcut, the screen auto-captured, and the answer appeared on my phone. The approach was clear within seconds, and my laptop screen stayed on the code editor, exactly as it was before.

Question 2: Longest Substring With Character Limit

The problem I got: A string and an integer k. I needed to find the longest substring where each individual character appears at most k times within that substring. If multiple substrings have the same maximum length, return the one that appears first from left to right.

My approach: This was a sliding window problem with a frequency map, and the pattern felt familiar. I used two pointers -- left and right -- with an unordered map tracking how many times each character appeared in the current window. As I expanded the right pointer, I incremented the count for the new character. If a character's count exceeded k, I shrank from the left until every character was back within the limit.

The key insight was that the window only needs to shrink until the offending character drops to k. The other characters were already valid, so shrinking further would discard potential answers. I tracked the longest valid window's start position and length as the loop ran, then returned the substring at the end. Running through edge cases like empty strings and all-exceeding strings gave me confidence before I hit submit.

string longestSubstringWithLimit(const string& s, int k) {
    int n = s.size();
    int left = 0, maxLen = 0, startIdx = 0;
    unordered_map<char, int> freq;

    for (int right = 0; right < n; right++) {
        freq[s[right]]++;

        while (freq[s[right]] > k) {
            freq[s[left]]--;
            left++;
        }

        int len = right - left + 1;
        if (len > maxLen) {
            maxLen = len;
            startIdx = left;
        }
    }

    return s.substr(startIdx, maxLen);
}

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

This one felt comfortable. Sliding window problems follow a recognizable rhythm once enough of them are under my belt. The 40 minutes I had left after the first question gave me room to test edge cases thoroughly. The visible test cases all passed, which was a relief after the grind of Question 1.

Wells Fargo's Proctoring Policy for HackerRank

Wells Fargo uses HackerRank's built-in integrity features, but the proctoring environment is lighter than what I've seen on platforms like CodeSignal. No webcam monitoring, no screen recording, and no AI-powered surveillance appear in any candidate report for Wells Fargo specifically. The main things to know are copy-paste tracking and tab-switch detection.

This is a moderate proctoring setup: the employer gets a post-test report of integrity flags, not a live surveillance feed. Both full-screen enforcement and AI-powered Proctor Mode were introduced by HackerRank in 2026. Candidates who took this OA before those releases experienced an even lighter environment.

Copy-Paste Tracking Is Always On

Copy-paste tracking is built into every HackerRank test and cannot be disabled by the employer. The platform's post-test CSV report includes a Copy-Paste Frequency column. The plagiarism detection model analyzes any content that was pasted into the code editor. This means the platform logs every time code is copied from or pasted into the editor window. What the model actually flags and where the line falls between a harmless paste and a flagged one isn't obvious from the test interface—our breakdown of what HackerRank's copy-paste detection really catches walks through the exact behaviors that end up in the integrity report.

The practical implication is straightforward: pasting large solution blocks will register in the integrity report. Brief snippets like function signatures or standard library imports are less likely to raise flags. There is no published threshold for what triggers a review. HackerRank's support documentation confirms this tracking runs on every assessment across all companies.

Tab Switching and Full-Screen Enforcement

Tab-switch tracking is an employer-optional feature that logs when and for how long the candidate leaves the test window. Whether Wells Fargo enables it is unconfirmed, but tab-switch warnings are a known part of the generic HackerRank experience. A candidate accidentally swiped to a new screen with five minutes left and saw a message that the switch had been recorded.

Full-screen enforcement was added by HackerRank in April 2026. When active, it warns candidates who exit full-screen mode and can disable copy-paste entirely during the test. Since this feature is new and must be turned on by the employer, it is safest to assume any assessment taken after mid-2026 could include it.

Webcam and Advanced Proctoring Not Used by Wells Fargo

HackerRank offers three higher-tier proctoring features. Image Proctoring takes periodic webcam snapshots. AI-powered Proctor Mode detects face anomalies, gaze patterns, and objects. Desktop App Mode records the full screen with a synchronized timeline. All three default to off and must be explicitly enabled by the employer. If you're weighing whether any of these could still affect your session, the fuller picture of how far HackerRank's anti-cheat system actually reaches breaks down each layer beyond what the default-off assumption tells you.

I searched for any report of Wells Fargo candidates being asked to enable a webcam or encountering AI proctoring, and found nothing. No Reddit post mentions a webcam prompt. No LeetCode Discuss thread describes being flagged by gaze detection. No Blind post warns about screen recording.

This negative evidence, combined with the platform default of off for all three features, makes it nearly certain. Wells Fargo operates without webcam or AI surveillance on the HackerRank OA.

2 Other Confirmed Wells Fargo HackerRank Questions

The questions I got aren't the only ones in rotation. Other candidates reported different problems through the same period, and the topic patterns across reports make the question pool fairly predictable. These two problems appeared alongside the ones I received in a LeetCode Discuss thread documenting real Wells Fargo OA questions.

Permutation Cycles and LCM Problem

One problem asks: given an array representing a permutation of 1 through n, find the least common multiple (LCM) of all cycle lengths in the permutation, modulo 1e9+7. The solution requires three distinct components: detecting cycles within the permutation array, computing the LCM of those cycle lengths, and handling the modulo arithmetic correctly.

The standard approach uses a sieve for prime factorization, binary exponentiation for modular power calculations, and maximum prime power tracking across cycles to compute the final LCM. This is the most math-heavy problem confirmed in the Wells Fargo question pool.

It sits at the LeetCode Medium-Hard boundary mostly due to the modular arithmetic rather than algorithmic complexity. A full C++ solution was posted in the same LeetCode Discuss thread.

Binary Search Code Review

The Summer 2026 Intern OA on June 26, 2026 included a code review question rather than a from-scratch coding problem. The prompt showed a code fragment that was supposed to perform binary search, and the task was to identify what was wrong and fix it.

This format tests a different skill than writing algorithms from scratch. It requires reading unfamiliar code, spotting off-by-one errors or incorrect boundary conditions, and understanding binary search deeply enough to debug it under time pressure.

The candidate described the difficulty as medium level and passed the OA. Binary search appears frequently enough in the confirmed question pool. It appears both as a standalone topic and embedded in other problems, so treating it as a core pattern to master is justified.

Across all confirmed reports, the recurring topic pattern is consistent: arrays, strings, hash maps, two-pointer techniques, sliding window, and binary search. Graph algorithms, dynamic programming, and system design have not appeared in any verified Wells Fargo HackerRank question.

What Wells Fargo's HackerRank Test Format Actually Looks Like

For new grads and interns applying in 2026, the dominant format is 90 minutes with exactly 2 coding questions on HackerRank. This is what I received and what most candidates report. But the format isn't identical across every role and hiring cycle. Wells Fargo adjusts question count, duration, and content type depending on the position.

The intern coding-only format (90 minutes, 2 coding questions) has the highest confidence level. It is confirmed by both a June 2026 1point3acres report and Johnny Mai's 2026 new grad guide. A secondary intern variant appeared on Taro in October 2025: 7 multiple-choice questions plus 2 coding problems in 60 minutes. This format hasn't appeared in 2026 reports, suggesting it may be a deprecated track or tied to a specific internship program.

Experienced candidates face a different structure entirely. A December 2024 1point3acres post described receiving two separate OAs. The first was a 60-minute team-specific assessment the candidate described as "too easy" (finished in 15 minutes). The second was a 70-minute company-general assessment. This dual-OA format is relevant for experienced hires, though it hasn't been independently confirmed for 2026.

The HackerRank test interface itself is standard across all formats. The code editor provides syntax highlighting, a run button for testing against visible cases, and a submit button for final grading. Visible test case results appear immediately, green for pass and red for fail, but hidden test cases only run after submission.

Language options include Python, Java, C++, JavaScript, C#, and the full HackerRank standard set. For our primary reader sitting down to a new grad or intern OA: expect 90 minutes and 2 coding questions.

How Wells Fargo's HackerRank Scoring Works

HackerRank grades on test case pass rate. The distinction between visible and hidden test cases is the most important thing to understand about how these OAs compute a score. Clicking the run button during the test executes code against a subset of visible test cases. The results appear immediately, showing pass/fail with the specific inputs and outputs to help with debugging.

After submitting, the code runs against a much larger set of hidden test cases, and those results determine the actual score.

Johnny Mai's 2026 guide estimated a ~30% OA pass rate and emphasized "correctness over optimization." That phrase matters. It suggests Wells Fargo's grading prioritizes getting the right answer over writing the most elegant solution.

A brute-force approach that passes every test case may outscore an optimized O(n log n) implementation that trips on a single edge case. Hidden test cases frequently target edge conditions: empty inputs, single-element arrays, boundary values, and large inputs designed to break naive implementations. Testing with those cases mentally before submitting is worth the time.

HackerRank's standard scoring is binary per test case: each case is either a pass or a fail, with no partial credit. Wells Fargo does not share numerical OA scores with candidates. The only signal after submission is a disposition outcome, an invitation to the next stage, a rejection, or silence.

No candidate has reported receiving a specific numerical score from Wells Fargo, and the platform itself does not expose the final score to test-takers after submission.

Why Candidates Fail the Wells Fargo HackerRank Assessment

Failing this OA isn't always about skill. The four most common patterns I found across community reports. These are: a gap between what appears during the test and what actually gets graded, time pressure on specific format variants, communication breakdowns after submission, and a cooldown mechanic that catches people by surprise.

Losing Easy Points on Hidden Test Cases

The biggest risk isn't solving hard problems. It's passing all visible test cases and failing hidden ones. HackerRank shows immediate green checkmarks for visible cases, and that feedback loop creates false confidence. A solution that handles every sample input may still break. Hidden tests include edge cases, large inputs that trigger timeout thresholds, and boundary conditions the visible set never exposes.

Johnny Mai's "correctness over optimization" framing makes sense in this context. A candidate who stops testing once the visible cases turn green and immediately submits is making the most common mistake in the OA.

HackerRank's hidden tests often include stress tests with maximum input sizes, empty arrays, single-element inputs, and values at the extreme ends of the problem's constraints. The difference between a solution that passes 6 of 15 cases and one that passes 15 of 15 can be as small as forgetting to handle a null check.

Running Out of Time on the MCQ Format

If Wells Fargo assigns the 60-minute MCQ-inclusive format, 7 multiple-choice questions plus 2 coding problems, time management becomes the primary threat. The math is unforgiving: at roughly 6.7 minutes per item, spending 3 to 5 minutes on each MCQ burns 21 to 35 minutes before touching any code.

That leaves somewhere between 12 and 19 minutes per coding question, which is tight for LeetCode Medium-level problems even for well-prepared candidates.

The candidate who reported this format in October 2025 described the experience as positive but did not receive an offer. There is no way around the time constraint on this variant. The only mitigation is being fast enough on the MCQ section to preserve coding time, but the unpredictability of the MCQ topic mix makes reliable budgeting impossible.

Ghosted After a Strong Submission

This is the psychological failure mode: submitting the OA, feeling good about the performance, and then hearing nothing for weeks or months. Candidates in this position don't know whether silence means rejection or slow processing.

The post-OA pipeline includes a resume screen. Wells Fargo evaluates your application as a whole after the assessment, not just based on the OA score, so a strong technical performance does not guarantee advancement.

Six-month lockout. If the OA result is a failure, the consequence is a 6-month cooldown before re-applying. A candidate received an email explicitly stating that their assessment "didn't qualify" and that "outcomes are valid for 6 months." Candidates who are unaware of this cooldown may continue submitting applications during the lockout window, getting auto-rejected without understanding why.

No verified reports exist of Wells Fargo candidates being flagged for AI tool use during the HackerRank OA. But the risk is structural: copy-paste tracking runs on every assessment, and HackerRank keeps adding detection layers. AI-powered Proctor Mode launched in July 2026 with face anomaly detection, gaze pattern analysis, and object recognition.

Even without a confirmed Wells Fargo enforcement case, the detection infrastructure exists and continues to improve. The exposure is built into the platform. Any external tool use during a proctored assessment leaves traces. The gap between "nobody has been caught yet" and "the system does not detect" is a gap candidates fill at their own risk.

Desktop overlay tools render the AI's answer on the same screen the proctoring system is monitoring. The hiding is done at the OS rendering layer, a basic trick. Whether the current version of that monitoring actively catches it isn't something you can verify, and the detection capabilities keep improving.

InterviewFox works differently: the answer goes to my phone, a physically separate device that no screenshot or session recording can reach by design.

How to Prepare for the Wells Fargo HackerRank in 7 Days

I planned a targeted week of practice leading up to my OA. Looking back at what actually showed up on the test, the calibration was close to right. The confirmed question pool points to a narrow set of high-frequency topics.

Seven days of focused work on the right patterns beats two months of unfocused LeetCode grinding. Here is exactly what I'd repeat, organized by topic priority based on confirmed question frequency across all sources.

Days 1–3: Arrays and Strings

Arrays and strings are the highest-frequency topics across every confirmed report. Johnny Mai's topic map, the LeetCode Discuss questions, and the 1point3acres code review problem all center on these. Target 6 to 8 LeetCode Easy and Medium problems per day. Focus on array manipulation (slicing, rotation, prefix sums), string parsing (character frequency maps, substring operations), and combinations of the two.

The sliding window string problem from my exam and the permutation cycles problem from the confirmed pool both start with array and string fundamentals. Skip dynamic programming, graph algorithms, and system design entirely: none of these appear in the confirmed Wells Fargo OA question pool.

LeetCode's company-tagged problems for Wells Fargo can serve as a secondary filter. But the tags alone are not comprehensive enough to rely on without supplementing from the topic patterns confirmed here.

Days 4–5: Hash Maps, Two-Pointer, and Sliding Window

These patterns show up at moderate frequency across reports and form the backbone of the medium-difficulty questions. Target 4 to 6 problems per day. Mix hash map problems (frequency counting, lookup optimization), two-pointer (sorted array traversal, pair finding), and sliding window (fixed and variable window size).

The exact problem I received in Question 2 uses the sliding window plus hash map combination, so practicing that intersection specifically is worth the time.

Practice edge cases deliberately during these two days. Empty inputs, single-element arrays, and large inputs that would break O(n²) solutions are exactly the kind of hidden test cases that separate a pass from a fail. Binary search appears in confirmed questions (the code review problem from 1point3acres), so include 1 to 2 binary search problems for coverage.

I used the Prep Agent on my phone to generate a practice schedule calibrated to these exact patterns. The topic clustering it suggested matched what later appeared on the test. I'd sent InterviewFox's Prep Agent the confirmed question patterns through WhatsApp ahead of this week. The drill plan it returned grouped everything by the exact topics that community reports flagged as high-frequency.

Days 6–7: Mock Exam and Time Management

Simulate the real OA with constraints that match the actual exam. Pick 2 unseen LeetCode Medium problems, set a 90-minute timer, and code them in an environment without IDE assistance: no autocomplete, no inline documentation, no external reference tabs.

Practice the full submit-then-review flow. Run against visible cases, fix failures, submit when all visible cases pass. Then step back and anticipate where hidden cases might fail before the timer expires.

On Day 7, repeat the simulation with a harder set. Include one LeetCode Hard problem, such as LeetCode 2812 or an equivalent multi-source BFS plus binary search combination. This prepares you for the possibility that the OA serves a hard question first.

The goal is not a perfect score. The goal is building the muscle of working under time pressure. You need to manage the visible-to-hidden test case gap and know when to move on from a stubborn edge case instead of burning 20 minutes on it.

What Happens After You Submit the OA

The period after clicking submit is the least documented part of the Wells Fargo application pipeline. The ambiguity is what causes the most anxiety. Here is what the community reports actually say about what comes next, how long it takes, and what each outcome looks like.

The Typical Post-OA Pipeline

After submission, the OA enters a review queue. The next stage for candidates who pass is typically a HireVue on-demand interview. This means either pre-recorded video responses to set questions, or a text-based format where answers are typed rather than spoken.

A candidate in the Summer 2026 cycle received an "on-demand text interview" invite, confirming that text-based variants exist alongside the traditional video HireVue format.

Some candidates skip HireVue entirely and move straight to a recruiter phone screen, though this seems less common. After HireVue come technical interviews and a potential Superday, but that is beyond the OA's scope. The key thing to know is that the OA is one filter in a multi-stage process, not the final gate.

How Long You'll Actually Wait

The wait times range from 1 to 2 weeks on the fast end to multiple months on the slow end. One candidate described a fall application yielding a January response as "standard." Another received the OA offer from Wells Fargo but not the actual HackerRank link for an extended period afterwards. There is no fixed SLA.

Wells Fargo evaluates your application as a whole after the OA, meaning your resume and application materials get evaluated alongside your test performance. The review queue timing depends on where your application falls in the hiring cycle.

Campus hires and CODE cohort members may follow faster, more structured timelines coordinated through university career centers, but general-pool applicants should expect an indeterminate wait. The one actionable takeaway: do not pause other applications waiting for Wells Fargo to respond.

What a Pass, Fail, or Ghost Looks Like

A pass typically generates an email invitation to the next stage, a HireVue or a recruiter call. A fail may trigger a generic rejection email, or complete silence. The indeterminate silence is the most commonly reported outcome and the most frustrating: candidates do not know whether they are still under review or silently rejected, sometimes for months.

The 6-month cooldown after a failed OA means re-applications during the lockout window are futile. After 4 or more weeks of silence, the safe assumption is that the application is either in a slow queue or effectively ghosted.

The practical move is to continue applying elsewhere and treat a Wells Fargo response as a bonus when it arrives, not as a timeline to plan around. If a rejection eventually comes through, note the date: the 6-month clock starts from that point, not from the day of submission.

FAQ

Where can I find more Wells Fargo HackerRank questions?

The LeetCode Discuss thread linked in the confirmed questions section above is the best single source of real problem descriptions. Reddit's r/csMajors subreddit also has active threads during each hiring cycle, though the questions vary by season. 1point3acres had a detailed June 2026 intern OA report.

What programming languages can I use on the Wells Fargo HackerRank?

HackerRank's full standard language set is available: Python, Java, C++, JavaScript, C#, Ruby, Go, and several others. There is no language restriction specific to Wells Fargo. Pick the language you code fastest in under time pressure.

How long is the Wells Fargo HackerRank test?

The dominant format for interns and new grads in 2026 is 90 minutes with 2 coding questions. A less common variant with 7 MCQs plus 2 coding questions runs 60 minutes. Experienced hires may receive separate role-specific and company-general assessments at 60 and 70 minutes respectively.

Do I need a webcam for the Wells Fargo HackerRank?

No. Zero candidate reports mention a webcam requirement for Wells Fargo specifically. HackerRank's webcam-based Image Proctoring and AI Proctor Mode features both default to off and must be explicitly enabled by the employer. All available evidence points to Wells Fargo not using webcam surveillance.

Can I use an AI tool or invisible app during the Wells Fargo HackerRank OA?

Desktop overlay tools render AI answers directly on the monitored screen. The hiding operates at the OS rendering layer, so the AI output and the test session share the same display surface.

InterviewFox works as a dual device AI interview tool: the answer appears on a separate phone screen, physically removed from whatever the proctoring system is recording. By taking the answer off the monitored screen entirely, dual-device mode eliminates the structural risk that desktop overlays carry.

What score do I need to pass the Wells Fargo HackerRank OA?

Wells Fargo does not publish a passing threshold, and candidates do not receive numerical scores. The estimated pass rate is ~30% (single source, 2026). Scoring is based on test case pass rate, with hidden test cases weighted the same as visible ones. No partial credit is confirmed.

Can I retake the Wells Fargo HackerRank if I fail?

Not immediately. Wells Fargo enforces a 6-month cooldown after a failed OA. A candidate received an explicit email stating that assessment outcomes "are valid for 6 months." Re-applying during the cooldown period will result in auto-rejection.