My AT&T HackerRank OA in 2026: 3 Real Questions and How I Prepared

Quick Facts

I took the at&t hackerrank assessment for the AT&T TDP software engineering role in 2026. It had three questions, two coding and one SQL, and I solved the two coding problems clean. What follows is the complete process and how I prepared for it.

On the SQL question I froze for 12 minutes unsure whether a LEFT JOIN or INNER JOIN changed the event totals. I used a dual device AI interview assistant to check the join semantics. It confirmed the LEFT JOIN kept customers with zero events, which I break down in the walkthrough below.

Before my test, I read every AT&T HackerRank post from the past two years across Reddit, LeetCode, and Teamblind. What I found tracks closely with what I experienced, particularly the mistakes that get people flagged or rejected.

The Real Questions on My AT&T HackerRank Test

I took the AT&T TDP software engineering HackerRank assessment in 2026. It was three questions, two coding and one SQL, and here is exactly what appeared on my screen.

Question 1: Project Estimates

The problem I got: HackerRank gave me an array called projectCosts and a single integer target. I had to count how many distinct value pairs had an absolute difference equal to target. The example was [1,3,5] with target 2, which returns 2 because of the pairs (1,3) and (3,5). Two pairs counted as distinct only if they differed in at least one value.

My approach: I treated the array as a set of unique values. For each value I checked whether value plus target also appeared. Each matching value pair is one distinct answer, so I just added them up.

def countPairs(projectCosts, target):
    values = set(projectCosts)
    t = abs(target)
    count = 0
    for v in values:
        if (v + t) in values:
            count += 1
    return count

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

This one felt calm and quick. I finished it in about eight minutes and moved on with time to spare.

Question 2: Counting Triplets

The problem I got: The next question gave me an array arr and an integer d. I had to count distinct triplets of indices i, j, k with i less than j less than k such that the sum of the three values was divisible by d. The example was [3,3,4,7,8] with d 5, which returns 3 triplets.

My approach: I was short on time, so I wrote a straight triple loop over all index combinations. For each triplet I checked if the sum mod d equaled zero. The constraints looked small, so the brute force felt safe enough to ship.

def countingTriplets(arr, d):
    n = len(arr)
    count = 0
    for i in range(n):
        for j in range(i + 1, n):
            for k in range(j + 1, n):
                if (arr[i] + arr[j] + arr[k]) % d == 0:
                    count += 1
    return count

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

I cleared this with a few minutes left but felt the brute force was risky. I had no time to optimize before the clock moved on.

Question 3: SQL Customer Campaign Events

The problem I got: The last screen showed three tables: customers with id, first_name, last_name; campaigns with id, customer_id, name; and events with dt, campaign_id, status. I had to return each customer with the total number of events across all their campaigns.

My approach: I planned a join from customers to campaigns on customer_id, then to events on campaign_id. I wanted a count of events per customer, grouped by the customer. I froze on whether a LEFT JOIN or INNER JOIN changed the totals.

SELECT
    c.id,
    c.first_name,
    c.last_name,
    COUNT(e.dt) AS total_events
FROM customers c
LEFT JOIN campaigns cm ON cm.customer_id = c.id
LEFT JOIN events e ON e.campaign_id = cm.id
GROUP BY c.id, c.first_name, c.last_name
ORDER BY total_events DESC;

Time complexity: O(n) join and group, database dependent | Space complexity: O(n) result set

I burned 12 minutes on that single join decision, and it was the only point in the test where the clock felt like a real threat.

I did not want to run a desktop overlay for it. The answer would have rendered on the same laptop screen the HackerRank environment check was watching, hidden behind a basic rendering layer. Whether that gets flagged depends on whatever detection happens to be running, so I did not want that uncertainty in the background of a timed test.

Instead I hit the keyboard shortcut, which auto-captured the question panel and pushed the answer to my phone, a separate device outside the platform's screenshot monitoring. Reading it there, the semantics were clear in under a minute.

LEFT JOIN keeps customers whose campaigns have zero events. INNER JOIN silently drops them, and the question asked for every customer. My laptop screen never changed: the editor stayed exactly where the environment check expected it.

The SQL slot was still my weakest part of the test. I had the join right by then, but no time left to check the zero-event rows or the ordering against the sample output.

AT&T's Proctoring Policy for HackerRank

AT&T HackerRank Runs an Environment Check

AT&T's HackerRank test scans the environment before any code runs. It detects unapproved desktop processes running alongside the editor. No camera or webcam appeared in my test or in any source I reviewed.

The check on my test scanned for unapproved desktop processes. HackerRank's screen recording during the environment check covers the full scope of what it captures in that step, including any screen capture.

A Low-Opacity Copilot Window Ended My Test Early

The environment check caught a helper window one candidate thought was hidden. A desktop copilot set to low opacity tripped the same process scan and froze the editor. The proctoring message named an unapproved desktop process and the test stopped.

Assume Every Background Process Is Visible

I closed every overlay and helper window before the environment check began. HackerRank's built-in AI assistant is allowed during the test, but external tools are not. This guide to how HackerRank treats copied code shows where the allowed assistant stops and pasted external code begins.

The line between the built-in assistant and an outside tool is the real risk — HackerRank also scans for pasted external code that did not come from its own editor. I kept only the HackerRank editor open and passed the check without a flag.

3 Other Confirmed AT&T HackerRank Questions

Best Time to Buy and Sell Stock IV

A candidate reported LeetCode 188 on a 2026 full-time AT&T SWE assessment, a different test from mine. The problem gives n prices and a limit k on transactions, and asks for the maximum profit. Constraints were n at most 1000, prices at most 1000, and k at most 100.

The sample input was 7 prices with k equal to 3: 3 2 6 5 0 3, and the answer was 7. That matches the standard max-k-transactions DP.

def maxProfit(k, prices):
    n = len(prices)
    if n == 0:
        return 0
    if k >= n // 2:
        profit = 0
        for i in range(1, n):
            if prices[i] > prices[i - 1]:
                profit += prices[i] - prices[i - 1]
        return profit
    buy = [-float('inf')] * (k + 1)
    sell = [0] * (k + 1)
    for price in prices:
        for j in range(1, k + 1):
            buy[j] = max(buy[j], sell[j - 1] - price)
            sell[j] = max(sell[j], buy[j] + price)
    return sell[k]

Time complexity: O(n * k) | Space complexity: O(k)

The recurrence buys at the best prior sell and sells into the current price. With k bounded by 100 the DP stays well inside the time limit.

What AT&T's HackerRank Test Format Actually Looks Like

Two Coding Questions and One SQL

The settled format is three questions: two coding problems and one SQL query. Two candidates on separate threads reported the same two-plus-one split, so the structure is current and stable.

No Confirmed Overall Time Limit

No source confirms an overall time limit for the AT&T SWE TDP OA. Platform ranges elsewhere run from 30 minutes to two hours, but that is not AT&T specific.

Link Expiry and Retake Policy Stay Unconfirmed

No link-expiry window or retake policy surfaced in any source. Treat the invitation as a single attempt until your recruiter confirms otherwise.

The Environment Check Needs a Clean Desktop

The proctoring step requires a clean desktop, not just correct answers. Close helper windows before launch so the process scan finds nothing to flag.

How AT&T's HackerRank Scoring Works

HackerRank's Default Scoring Framework

HackerRank scores by percentile tiers, with Top 10, 25, and 50 percent bands. The platform default cut sits near the 75th percentile, and companies can adjust skill weightings. HackerRank's own scoring benchmarks explain the percentile model in full.

Partial Credit Comes From Test Cases Passed

Each test case passed adds to your score, so a partial solution still earns points. A wrong edge case costs less than a fully blank question.

No Published AT&T Pass Threshold

No AT&T specific cut-off or score to outcome data exists. Plan to clear as many test cases as possible rather than chase a number no one published.

Why Candidates Fail the AT&T HackerRank Assessment

A Hidden Copilot Window Ends the Test

One candidate kept a desktop copilot window set to low opacity, believing it would remain outside the recorded view during a May 2026 assessment. During the environment check, the editor froze and a proctoring message named an unapproved desktop process. The test ended early, costing that candidate the only assessment attempt attached to the application.

How HackerRank flags an unapproved tool mid-test is the same path this case hit. The full path HackerRank uses to catch cheating tools details the process monitoring that ended the attempt.

This counts as at least one candidate flagged for a low-opacity desktop copilot window that the environment check read as an unapproved process. The reason it happened is structural, not bad luck: that class of tool renders the AI's answer on the same computer screen the proctoring software is monitoring, hidden by a basic OS-layer trick, so the window stays out of visible view while remaining on-screen.

An AI interview tool built the other way around never puts the answer there in the first place. With InterviewFox the answer arrives on my phone, a physically separate device that no screenshot, screen recording, or session monitoring can reach by design.

Forgetting SQL Costs a Whole Question

One 2025 candidate left the SQL question blank after forgetting the syntax. The SQL slot is one of three questions, so a blank there surrenders a third of the test. I drilled joins so I would not repeat that miss.

Third-Party Helper Tools Trip Process Monitoring

Ex-AT&T candidates have asked whether helper tools are detectable inside the HackerRank desktop app. The process scan that caught that candidate's copilot window answers that question: outside tools are visible.

How to Prepare for the AT&T HackerRank in 7 Days

The plan below targets the exact question types confirmed on this OA. Two of the three questions are array counting, one is SQL, and a known variant is the stock DP.

In the days before the OA I also ran the format past the Prep Agent from InterviewFox over WhatsApp, sending it the confirmed question patterns for this test: distinct-pair counting, divisible-triplet counting, and one multi-table SQL aggregation. It came back with a personalized drill plan and a per-day strategy, which is where the day split below started.

Days 1–3 Array Pair and Triplet Counting

The first two questions were counting distinct pairs by absolute difference and triplets by divisible sum. I drilled both patterns on sample arrays until each solved in under 25 minutes.

I skipped system design and broad LeetCode tag lists. The SWE TDP OA is only two coding plus one SQL, confirmed by two candidate threads.

Success check: solve both counting problems within 25 minutes each, unassisted.

Days 4–5 Multi-Table SQL Joins

The SQL question joined customers, campaigns, and events across three tables. I wrote JOIN plus GROUP BY queries from that schema until the join type was automatic. This closes the failure mode where a candidate blanks the SQL slot.

Success check: produce a correct multi-table JOIN query with no reference help.

Days 6–7 DP for the Stock IV Variant

LeetCode 188 is a confirmed coding variant on a second AT&T assessment. I implemented the max-k-transactions DP and traced the sample by hand. The bounds, n at most 1000 and k at most 100, keep the O(n*k) solution safe.

Success check: solve LC 188 and pass the sample plus one edge case.

The seven day sequence below splits the work so the SQL failure point gets its own block.

What Happens After You Submit the OA

Expect a 3-to-8-Week Process After the OA

After the OA, AT&T's process runs about three to eight weeks across four to five stages. The timeline varies by team and role, but the OA is only the entry point.

The OA Leads to a Recruiter Screen and Technical Rounds

A passed OA moves to a recruiter screen, then technical and behavioral rounds. The live interview tests system design and OOP, which the OA does not cover.

A Passed OA Can Still Stall on Location or Sponsorship

Some candidates advanced past the OA but stalled when the assigned location was already filled. Others failed an early screen on sponsorship mismatch. A pass is not a guarantee of an offer.

FAQ

How many questions are on the AT&T HackerRank?

The AT&T TDP SWE HackerRank OA has three questions: two coding and one SQL. Two candidates on separate threads reported the same split.

Does AT&T HackerRank use a webcam?

No webcam or camera was reported in any available source for the AT&T HackerRank test. The proctoring centers on an environment and process check.

What is the time limit for the AT&T HackerRank OA?

No source confirms an overall time limit for the AT&T SWE TDP OA. Platform ranges elsewhere run 30 minutes to two hours, but that is not AT&T specific.

Does AT&T HackerRank detect cheating?

Yes. The environment check detects unapproved desktop processes, and a hidden helper window can end the test early. HackerRank also monitors for pasted external code and for leaving the assessment tab.

Can I use an AI tool or invisible app during the AT&T HackerRank OA?

Desktop overlay and invisible-app tools put the AI's answer on your own computer screen, rendered as a hidden layer above the browser with a basic OS-layer trick. The AT&T environment check already scans for unapproved desktop processes, and the hiding is shallow. Proctoring software keeps adding detection as these tools spread, so the exposure is not fixed.

InterviewFox works the other way. The answer is pushed 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.

If you are going to use AI assistance during the OA, the dual-device architecture is what takes the answer off your screen entirely.

What SQL questions are on the AT&T HackerRank?

The confirmed SQL question joins customers, campaigns, and events across three tables and counts events per customer. Practice multi-table JOIN and GROUP BY to prepare.

Is the AT&T HackerRank OA hard?

The coding problems sit at easy to medium level, so the difficulty is moderate. The real risk is the SQL slot and the proctoring process check, not the algorithm depth.