CONTENTS

    My AT&T HackerRank Online Assessment (OA): What Actually Happened

    avatar
    Peter Liu
    ·September 28, 2026
    ·15 min read
    How to Pass the AT&T HackerRank Online Assessment (OA) in 2026

    I finished the AT&T HackerRank Online Assessment feeling better about the coding than the SQL, which was slightly embarrassing because I had spent most of my preparation worrying about algorithms.

    After submitting, I opened a blank editor and tried to recreate the part of the SQL query I kept thinking about. Without the assessment in front of me, the issue looked obvious: I needed to count events without making customers disappear. During the test, though, I had managed to turn that into a much bigger decision than it needed to be.

    The coding questions had their own version of the same problem. I recognized the general patterns quickly, but I nearly carried an assumption from the first question into the second. In one problem, repeated values did not create new answers. In the other, they absolutely did.

    That is probably the most useful thing I can share about this OA. It wasn’t simply a matter of recognizing a hash-map problem or remembering how a join works. I had to notice exactly what the question was asking me to count, then make sure my implementation followed that definition.

    The three question themes discussed below—distinct pairs, divisible triplets, and customer campaign events—come from a published AT&T assessment account. The smaller examples and explanations are my own reconstructions, not copies of the original test inputs.

    Key Takeaways From My AT&T HackerRank OA

    • The coding problems looked more familiar than they actually were. Recognizing the pattern helped, but the treatment of duplicates changed between questions.

    • SQL was not a section I could safely leave until the end. I needed time to check customers with no events, grouping, and the required output.

    • My biggest improvement came from testing small counterexamples. A five-element array told me more than repeatedly running the sample.

    Before I Started, I Was Too Focused on the Coding Questions

    My preparation had become a little unbalanced. I was spending most of my time on arrays, strings, and the problems I could finish with an “Accepted” result. SQL felt like something I already knew well enough to handle when it appeared.

    That was a convenient assumption.

    A public AT&T TDP internship account describes the format as two algorithm questions and one SQL question. That matches the structure behind this recap, but it is one reported configuration rather than a rule for every AT&T applicant.

    I also found candidates with different experiences. In a campus-recruitment discussion, an applicant described four OA questions covering bit manipulation, dynamic programming, graphs, and SQL; another participant explicitly identified their corresponding round as HackerRank. AT&T Israel’s official TDP page, meanwhile, specifies a three-hour HackerRank assessment.

    So I would keep the role and location attached to any experience you read. A US internship report, an India campus process, and an Israel graduate program are not interchangeable just because they all mention AT&T.

    For the version I’m discussing here, this was the progression:

    Question theme

    What the task involved

    What needed the most attention

    Project estimates

    Count distinct value pairs with a target difference

    Repeated values and the definition of “distinct”

    Counting triplets

    Count index triples whose sum is divisible by a number

    Keeping repeated values and avoiding repeated work

    Customer campaign events

    Aggregate events across related tables

    Preserving zero-event customers and counting the right rows

    I highly recommend checking out Linkjob AI -- it's a real-time, secure, discreet, and efficient AI interview assistant. It stands out among similar products in the tech and interview space. It can help you bypass detection and generate personalized coding answers on the fly, which really eases your interview anxiety.

    My First AT&T Coding Question: I Had to Decide What “Distinct” Meant

    The first pattern involved an array of project costs and a target difference. I needed to count distinct pairs of values separated by that difference.

    My initial thought was straightforward: compare values, find matches, increment the answer. Then I stopped at the word distinct, because that could mean two different things.

    Were we counting pairs of positions in the array, or pairs of values?

    Here is the smaller example I used afterward to make the distinction obvious:

    projectCosts = [2, 2, 5, 5, 8]
    target = 3

    There are two distinct value pairs: (2, 5) and (5, 8). But there are six matching pairs of indices, because the repeated copies of 2 and 5 create multiple ways to select the same values.

    Once I separated those interpretations, the positive-target case became much cleaner. I could keep the unique values and check whether value + target existed. Checking only in that direction also avoided counting a pair twice.

    The relevant practice problem is K-diff Pairs in an Array. Its wording makes the same distinction: different positions are required to form a pair, but repeated appearances of the same value pair do not create additional unique answers.

    The Follow-Up I Checked Afterward: What About a Target of Zero?

    This was one of the things I revisited without the timer.

    A set is enough for the positive-target version, but zero needs another look if the constraints allow it. For [4, 9], there is no valid pair of different positions with equal values. For [4, 4, 9], there is one distinct zero-difference pair: (4, 4).

    I needed occurrence counts to tell those cases apart.

    I’m not saying every AT&T version includes zero. My point is that I had to read the allowed inputs instead of assuming the technique I recognized automatically covered all of them. That is the sort of gap I can miss when a question feels easy early.

    The Triplet Question Looked Similar, but My First Assumption No Longer Worked

    The second task also involved counting combinations from an array, which briefly made me more confident than I should have been.

    This time, the relevant objects were three indices, i < j < k, whose values added up to a multiple of the divisor. Repeated values at different positions still counted.

    I caught the difference by shrinking the problem again:

    values = [1, 1, 2, 2, 3]
    divisor = 3

    There are four valid index triplets containing a 1, a 2, and the 3. Removing duplicates would leave only [1, 2, 3] and reduce the count to one.

    The same operation that simplified the first problem would have broken the second.

    That was the point where I stopped thinking of the OA as “two counting questions.” The questions were testing different definitions, and I needed to keep those definitions separate.

    My First Version Was Easy to Understand, but I Didn’t Want to Ignore Its Cost

    Three nested loops gave me a useful baseline. I could enumerate each index triple exactly once and check whether its sum was divisible by the required number.

    The problem was the amount of repeated work. A cubic solution can look perfectly fine on a short example without telling me much about the largest permitted input.

    When I revisited the solution, I fixed the middle index and kept counts of remainders from earlier elements. For each later index, I could calculate which earlier remainder would complete a divisible sum:

    needed = (-(values[j] + values[k])) % divisor

    The timing of the update was important. I added the current middle element to the stored counts only after checking the later elements. That kept every stored index before j and avoided reusing the same position.

    This approach reduces the work to quadratic time, assuming average constant-time dictionary operations. The extra storage holds the remainders already encountered rather than every possible triplet.

    I was much more comfortable with the idea after checking it against the simple three-loop version on small inputs. The slow version wasn’t wasted effort; it gave me a reference answer while I was working out the faster one.

    The SQL Question Was Where I Started Second-Guessing Myself

    The SQL task connected customers, campaigns, and events. Customers could own campaigns, and campaigns could have multiple events. The required result was a customer-level event total.

    I understood the relationship quickly. What slowed me down was deciding which customers should remain in the result when the relationships had no matching rows.

    The reported schema used these tables:

    customers(id, first_name, last_name)
    campaigns(id, customer_id, name)
    events(dt, campaign_id, status)

    There wasn’t an event ID in that description, so I shouldn’t quietly add one and write a solution that assumes it exists.

    I started with the obvious chain from customers to campaigns to events. Then I tested the case I had almost ignored: a customer whose campaign had no events.

    An inner join would drop that customer. A left join preserves the left-side row and produces nulls for the missing right-side values. For a task requiring every customer, that distinction determines whether the result is complete.

    The Small Test Table That Made the Query Easier to Reason About

    Afterward, I built a tiny example instead of trying to reason about a large result:

    Customer

    Situation

    Expected event count

    Alex Lee, customer 1

    Two campaigns, five events altogether

    5

    Jamie Fox, customer 2

    One campaign with no events

    0

    Alex Lee, customer 3

    A different customer with one event

    1

    Sam Park, customer 4

    No campaigns

    0

    That table tested three things at once: zero events, no campaigns, and two customers sharing a name.

    For this worked example, the query was:

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

    The selected columns and ordering above are for this example. In an assessment, I would follow its output specification rather than copy those choices automatically.

    Why I Didn’t Use COUNT(*)

    Choosing a left join didn’t finish the problem.

    COUNT(*) counts the joined rows, including the placeholder row that preserves a customer without a matching event. Counting e.campaign_id instead counts matched event rows: a matched campaign ID is non-null, while the placeholder is null. SQL aggregate documentation distinguishes counting rows from counting non-null values in an expression.

    I also didn’t want to count the timestamp without checking whether it could be null. And I needed the customer ID in the grouping so two people with the same name didn’t become one customer.

    This was what bothered me after submission. The query could be short, run without an error, and still represent the wrong thing.

    The Filter That Could Make the Same Mistake Come Back

    During review, I changed the exercise to count only successful events while still displaying every customer.

    Putting WHERE e.status = 'success' after the left join would remove customers without a matching successful event. For that particular requirement, I put the condition in the event join instead:

    ON e.campaign_id = cm.id AND e.status = 'success'

    Conditions in an outer join and conditions applied afterward do not always preserve the same rows. PostgreSQL’s examples show this difference directly.

    I didn’t need to memorize a more complicated query. I needed to think about the rows that remained after each step.

    The SQL Videos That Fit This Part of the Recap

    The resource I’d place beside these notes is Socratica’s SQL Joins Explained. It covers the join types behind the issue above rather than pretending to provide an AT&T answer key.

    For the three-table part specifically, there is also a visual walkthrough of joining multiple SQL tables.

    That is a useful next step when the individual joins make sense but chaining customers, campaigns, and events still feels confusing.

    I would use the small customer table above while watching. If changing the query makes Jamie or Sam disappear, I can immediately see why the result no longer satisfies the example.

    Going Back Through the Questions Was More Useful Than Another Last-Minute Rewrite

    For the first question, I needed to know whether repeated input values inflated the answer. For the second, I needed to know whether I had accidentally removed valid combinations. For SQL, I needed to know whether missing records produced zero or vanished from the result.

    HackerRank explains that hidden tests can check boundary values and other scenarios implied by the constraints. Depending on the test configuration, their debug output may not be available. That makes deliberately chosen counterexamples more useful than waiting for a hidden failure to explain itself. Hackerrank Candidates Knowledge Base

    I also checked the output details. HackerRank’s database guidance tells candidates to follow the required formatting, precision, and ordering. A query that calculates the right totals can still return something different from the requested result.

    That is a familiar theme in the Datadog HackerRank test experience: finishing an implementation and checking the assessment’s actual requirements are not quite the same stage. The company-specific formats differ, but the testing habit carries over.

    The Reddit Thread That Made Me Feel Better About a Non-Perfect Result

    After an OA, it is very easy to start looking for someone with exactly your score.

    I found a useful comment in an AT&T TDP discussion on Reddit. A full-time applicant said they missed one test case and still received an invitation to schedule the first interview. In the same discussion, candidates confirmed that SQL had appeared in their OAs, while one person said their later interview did not include SQL.

    That doesn’t establish a cutoff, and it doesn’t mean a particular number of failed cases is safe. It does show why I wouldn’t treat one imperfect result as an automatic rejection.

    I also stopped thinking of three questions as necessarily three equal pieces of the score. HackerRank notes that individual test cases may have specific score allocations. The number of questions alone doesn’t establish their weighting.

    Leaving a question unfinished can clearly hurt. Saying it always costs exactly one-third of an AT&T assessment goes further than the evidence supports.

    Other AT&T Candidates Had a Broader OA Than This One

    The campus thread I mentioned earlier is worth reading in full because it adds something the three-question recap doesn’t cover.

    The original poster described bit manipulation, dynamic programming, a graph problem, and SQL. Another participant confirmed a HackerRank round with the same pattern. Later in the thread, a different candidate described a technical interview involving linked-list implementation, sorting, word-frequency counting, Java concepts, and resume questions. Those later questions were not the original poster’s OA.

    That is exactly where online question lists become misleading. Someone combines all the comments and suddenly the “AT&T HackerRank test” supposedly contains everything from SQL aggregation to Java string pools.

    I found it more useful to keep the stages separate. The OA gives me information about what I may have to implement independently. The later interview reports tell me what I may need to explain or adapt while another person is asking follow-ups.

    For another company’s coding-and-SQL coverage, the J.P. Morgan HackerRank assessment experience is a related read.

    What Happens After the AT&T HackerRank OA?

    The first thing I did after finishing was not particularly productive: I started mentally grading my own performance based on the questions I felt least certain about.

    What was more useful was writing down why I had chosen each approach. That mattered because candidates have reported being asked about their assessment again.

    In an older AT&T TDP technical interview thread, one intern applicant described reviewing the OA, debugging an algorithm, and answering object-oriented design and optimization follow-ups. Another former intern described discussing and running a take-home assignment in the technical round.

    That gave my review a purpose beyond worrying about the score. Could I explain why a set was appropriate in one place, why counts were necessary elsewhere, and why the SQL join preserved the right customers?

    AT&T’s official 2024 TDP overview lists a technical assessment, prescreening, technical interview, and behavioral interview before a potential offer. It is a broad description of that program, not a universal promise about the sequence for every location.

    A TDP-Specific Video for the Stages After the OA

    This AT&T interview-process video focused on the Technology Development Program is a third-party overview rather than an official current assessment specification. I would use it for broader interview context, not to determine my question count, deadline, or permitted tools.

    The useful transition after the OA is from “can I finish this independently?” to “can I explain it clearly to someone else?” Those are related skills, but they don’t feel identical under pressure.

    Waiting for an Update Was Its Own Kind of Distraction

    The waiting threads were relatable, but I had to stop using them as a calendar.

    In a January 2026 AT&T TDP SWE internship discussion, one candidate said they heard back nine days after their final interview, while another said about a month. Other people were waiting after the OA or an earlier interview. Those are different starting points, so combining them into one response-time estimate would be misleading.

    One participant said following up through the support address in the invitation helped their application move forward. I’d treat that as a useful individual experience, not proof that every delayed application has been forgotten.

    The practical thing was to keep the confirmation email, follow the timeline I had actually been given, and continue with other applications. Refreshing Reddit didn’t produce any new information about my own result.

    The Webcam and Time-Limit Questions Need a Regional Answer

    I saw enough conflicting advice here that I wouldn’t rely on a blanket statement that AT&T uses no camera or always gives a particular time limit.

    AT&T Israel’s official TDP page specifies a three-hour HackerRank assessment and requires the camera to be on, one screen, fullscreen mode, and Chrome or Edge. Those requirements apply to that program. They do not automatically describe a US internship assessment.

    HackerRank also offers different integrity modes, including browser controls, additional proctoring, and a desktop-app mode. Platform capabilities are not the same thing as the configuration selected for every employer test.

    The separate guide to HackerRank detection and proctoring covers the broader platform topic. For the actual attempt, I’d still use the invitation to confirm setup and allowed resources.

    A genuine technical interruption is another separate issue. HackerRank says the hiring company controls retake permission, so the right contact is the inviting recruiter. The HackerRank retake guide explains how that differs from retrying a certification test. Hackerrank Candidates Knowledge Base

    Two Essential Rules to Avoid Detection Risk

    1. Your test must run on a webpage — not in a desktop testing client. Check how your assessment is conducted before you start. Desktop testing clients may monitor, detect, or block external applications.

    2. Don’t open Settings or toggle Linkjob AI during the test. Finish setting up Linkjob AI before you begin. During the test, do not click Settings or press Cmd/Ctrl + \ to show or hide the app.

    As long as you follow these two rules, you can confidently use Linkjob app during online tests with zero risk.

    FAQ About the AT&T HackerRank Online Assessment

    How many questions are in the AT&T HackerRank OA?

    One public TDP account describes two algorithm questions and one SQL question. A separate campus discussion describes four questions and identifies HackerRank in the replies. The format is not established as identical across all applications.

    What questions appeared in the assessment discussed here?

    This recap uses three reported themes: distinct pairs with a target difference, divisible-sum index triplets, and customer-level event aggregation. The examples and explanations were reconstructed rather than copied from an assessment.

    Does AT&T include SQL in its HackerRank assessment?

    SQL appears in multiple candidate reports, including the TDP Reddit discussion linked above. That makes it worth checking in your invitation, but it is not proof that every AT&T role uses SQL.

    How long is the AT&T HackerRank test?

    Follow your invitation. AT&T Israel’s TDP specifies three hours; that should not be generalized to other regions or recruitment tracks.

    Do I need a perfect score to move forward?

    I couldn’t verify a universal AT&T cutoff. One Reddit participant reported missing a test case and still receiving a first-round invitation, but an individual result does not establish the threshold for another assessment.

    Focus Your Preparation on Key HackerRank OA Topics

    Will AT&T ask about my OA in a later interview?

    It has happened. Historical candidates have reported assessment reviews, debugging, object-oriented design, and optimization questions in subsequent technical interviews.

    What should I do if the test has a technical problem?

    Report the issue promptly to the recruiter who sent the invitation, including the error and when it occurred. The employer decides whether to authorize another attempt.

    Related HackerRank Experiences

    Datadog HackerRank Test: Coding, SQL, and Candidate Experiences

    J.P. Morgan HackerRank Assessment Questions and Experience

    HackerRank Retake: What Happens When You Need Another Attempt

    Why People Choose Linkjob AI

    Smoother interviews, coding challenges cleared, and job offers landed. See how users describe their experience with Linkjob AI—in their own words.