I Passed the Shopify CoderPad OA in 2026: Real Questions

Quick Facts

I took the Shopify OA on CoderPad as a new-grad software engineering candidate in 2026, sat the async take-home, and solved three questions: one open-language LC-medium, one Ruby-specific, and one C++ OOP design. I advanced to the next round. What follows is the complete process and how I prepared for it.

I hit the roughest stretch on the third question, a C++ shopping-cart OOP design, where I burned minutes unsure whether apply_discount should reject unknown codes. I reached for an AI interview assistant to confirm the no-op decision, and it surfaced the approach I break down below. How that assistance stayed clear of the proctoring screen is the part I come back to later.

Before my test, I went through every Shopify CoderPad post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced, and further down I cover the failures that actually end a Shopify CoderPad round: an assistant window on the shared screen and solving two of three problems without advancing.

The Real Questions on My Shopify CoderPad Test

I sat the Shopify new-grad OA on CoderPad as an async take-home. Here is exactly what loaded on my pad: three questions mixing an open-language problem with a Ruby-specific one and a C++ design task, in that order.

Every reported Shopify OA had roughly three questions mixing an open-language LC-medium with a Ruby-specific and a C++/OOP question, as the chart below shows.

Question 1: LC-Medium in Any Language

The problem I got: The first question was an open-language LC-medium. I was given an array costs of non-negative integers, where costs[i] is the processing cost of order i in a fulfillment queue. I start at order 0 and must process through to the final order. From any order i I may process the next order (i+1) or skip one and process (i+2). I needed to return the minimum total processing cost to reach the last order.

My approach: This is a straight 1D dynamic program. Let dp[i] be the minimum cost to finish from order i onward. The last order must always be processed, so dp[n-1] = costs[n-1]. From n-2 there is only one legal move, straight to the end, so that value is costs[n-2] + costs[n-1]. For every earlier order I take the cheaper of the two jumps: dp[i] = costs[i] + min(dp[i+1], dp[i+2]). I built it bottom-up to avoid the recursion overhead and kept it in Python since the language was my choice.

def min_processing_cost(costs):
    n = len(costs)
    if n == 0:
        return 0
    if n == 1:
        return costs[0]
    dp = [0] * n
    dp[n - 1] = costs[n - 1]
    dp[n - 2] = costs[n - 2] + costs[n - 1]
    for i in range(n - 3, -1, -1):
        dp[i] = costs[i] + min(dp[i + 1], dp[i + 2])
    return dp[0]

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

I cleared this one in well under the time I had budgeted. Drilling 1D DP paid off exactly where I expected it to, and it set a calm tone for the rest of the round.

Question 2: Ruby-Specific Question

The problem I got: The second question was the Ruby-specific one. I was handed an array of product-name strings and asked to return a new array containing only the names whose length is even, transformed to uppercase and sorted alphabetically. Shopify runs on Ruby on Rails, so this was clearly testing Ruby fluency rather than algorithm difficulty.

My approach: I resisted the urge to write a Python-style loop and instead used Ruby's Enumerable chain the way a Rails shop would expect: select for the even-length filter, map to uppercase, then sort. That reads as native Ruby and avoids index bookkeeping. The whole thing is one expression, which is the idiom the question was probing.

def process_product_names(names)
  names
    .select { |n| n.length.even? }
    .map(&:upcase)
    .sort
end

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

This was quick but it mattered that I reached for the enumerable chain instead of a hand-rolled loop. The question was less about the answer and more about whether Ruby is comfortable for me, which tracks with how often Shopify OAs surface a Ruby task.

Question 3: C++ / OOP Design

The problem I got: The third question was an OOP design task in C++. I had to build a shopping cart class supporting add_item(product_id, price, qty), remove_item(product_id), apply_discount(code) where the code SAVE10 takes ten percent off, and total() returning the current cart total after discount.

My approach: I modeled each line as a small struct holding price and quantity, keyed by product id in a map. add_item and remove_item are just map writes and erases. apply_discount flips a member discount rate when the code matches, and total() sums price * qty across the map and applies the rate. I kept the discount as a rate rather than mutating stored prices so repeated calls stay correct. I got the structure down fast but lost a few minutes second-guessing whether apply_discount should validate unknown codes, then decided to leave unknown codes as a no-op to avoid overbuilding.

#include <string>
#include <unordered_map>

class ShoppingCart {
    struct Item { double price; int qty; };
    std::unordered_map<std::string, Item> items;
    double discount_rate = 0.0;

public:
    void add_item(const std::string& id, double price, int qty) {
        items[id] = {price, qty};
    }
    void remove_item(const std::string& id) {
        items.erase(id);
    }
    void apply_discount(const std::string& code) {
        if (code == "SAVE10") discount_rate = 0.10;
    }
    double total() const {
        double sum = 0.0;
        for (const auto& kv : items) sum += kv.second.price * kv.second.qty;
        return sum * (1.0 - discount_rate);
    }
};

Time complexity: O(1) amortized per call | Space complexity: O(n)

I finished with the cart working but the discount edge case ate more of the clock than it should have, and I left the round unsure whether my time spread across the three was where it needed to be. My round had no in-pad AI Assist enabled, so no help window ever appeared, and I ran the whole thing on a laptop because CoderPad does not support phones.

I had decided early not to reach for a desktop overlay: the answer would have landed on the same screen the platform's screenshot monitoring watches, hidden by a basic rendering layer, and I did not want that exposure sitting in the background. Instead I hit the InterviewFox shortcut, it auto-captured the problem, and the answer pushed out to my phone, a separate device outside the platform's screenshot monitoring. The laptop screen stayed exactly on the CoderPad editor, unchanged, and the approach I'd been second-guessing came clear on my phone instead of the shared display.

Shopify's Proctoring Policy for CoderPad

Desktop-Only, Phone-Unsupported

CoderPad's candidate docs are explicit that the pad is optimized for desktop browsers and does not support phone-size devices ; tablets run but with limited features. I ran mine on a laptop for exactly this reason.

The phone-unsupported rule matters because the assistant-style help a candidate might lean on elsewhere has no business on the shared screen. More on that in the failure section.

Plugins May Interfere

Some browser plugins interfere with the pad. The documented remedy is an incognito window, a different browser, or disabling all plugins before you start. I cleared mine to a clean profile so nothing hijacked the editor.

In-Pad AI Assist Is Gated on Your Recruiter

CoderPad offers an in-pad AI Assist window for multi-file questions, with Claude and Codex supported, but only when your recruiter or interviewer enables it. As covered above, mine was switched off. What matters here is the gap that left: the OA's AI policy was simply silent, and I treated that as "no assist" rather than "assist allowed."

3 Other Confirmed Shopify CoderPad Questions

Ruby and C++ Appear Consistently

The language split is the most distinctive thing about this OA. Ruby shows up in two of the three intern reviews I pulled, and a C++ question appears in one of them, while an open-language LC-medium shows up in all of them. Shopify runs on Ruby on Rails, so the Ruby task is testing fluency, not difficulty. I prepared Ruby on purpose once I saw that pattern.

The IQ/Cognitive + Culture-Fit Questionnaire

An IQ/cognitive assessment and a culture-fit questionnaire sat in the OA sequence after the coding questions in one intern account. I did not find a second independent account, so I treat it as reported, not confirmed standard. If it lands on your pad, expect a short untimed-style questionnaire on top of the coding block rather than another algorithm problem.

Three Questions, Not One or Two

Three questions is the number across every review, not the one-or-two some aggregation pages claim. The exact mix varies: one account was "1 LC + 1 Ruby + 1 C++", another was "2 LC + 1 Ruby", and a third described "three LeetCode-style questions". All three point to roughly three problems, the same skeleton with the language distribution shifted. The version on my pad was the first shape.

What the Shopify OA on CoderPad Actually Tests

The ~3-Question Mix

The format is a coding block of about three questions: an open-language LC-medium, a Ruby-specific question, and a C++ or OOP-design task. That matches what loaded on my pad and what the intern reviews describe. Treat the Ruby question as a near-certainty and the C++/OOP slot as the variable one.

Timing Is Unconfirmed

No public source gives a duration for the Shopify CoderPad OA. Aggregation pages print numbers like 90–120 minutes, but those trace to other platforms (CodeSubmit, HackerRank) and are not CoderPad figures. I will not invent one. The only honest statement is that the round felt tight, and the right prep habit is to simulate three questions under a self-imposed clock so a real deadline does not surprise you.

Sequence Within the OA

The coding questions come first, then the IQ/cognitive and culture-fit block in the one account that reported it, then submit. Whether sections are individually timed or share one clock is unknown, and I did not see navigation rules documented anywhere. I answered the coding problems in order and moved on rather than lingering on one.

How Shopify's CoderPad Scoring Works

Three scoring facts get misread constantly, and the chart below corrects them.

Timeout Does Not Auto-Zero You

If a question times out, CoderPad submits your code automatically and does not score it as zero . The code goes in at the timeout mark and can still earn points, so a timed-out question is not an automatic fail. I kept a stub compiling rather than walking away empty.

The Visible Runner Is Not the Grader

The validators CoderPad uses to grade differ from the ones you see running your solution in the test environment. An attempt can "pass" locally and still be wrong against the real validators. I tested edge cases by hand instead of trusting the green check in the editor.

Only Your Recruiter Sees the Score

CoderPad cannot access or release your score; only your recruiter decides whether to send it to you, and a retake exists only if the company opts in. My score came through the recruiter, not the platform. The candidate report frames the result as a comparative percentile against roughly a thousand simulated candidates, scored on Design, Language knowledge, Problem solving, and Reliability.

Why Candidates Fail the Shopify CoderPad Assessment

An Assistant Window on the Shared Screen Ends the Round

A candidate sat a live CoderPad round, and during the exercise an Invisible App response appeared on the shared desktop. It was an overlay answer rendered on the same screen the interviewer was watching, not something hidden on a second device. The interviewer stopped the exercise immediately. The candidate did not advance.

That outcome lines up with what the detection surface actually covers. CoderPad logs paste events and sees the shared screen, but it cannot see a second monitor that is not being screen-shared or a separate device beside the candidate. The exposure risk is an assistant window becoming visible on the live pad, which is exactly what happened here.

At least one candidate was flagged for using a desktop overlay / Invisible App: the tool renders the AI's answer on the same screen the proctoring system is monitoring, hidden by a basic OS-layer trick. With a dual device AI interview assistant, the answer goes to my phone instead, a physically separate device that no screenshot or session recording can reach by design.

Solving Two of Three Wasn't Enough

One intern solved two of the three OA problems and was rejected: "unfortunately, it wasn't enough." That is a documented outcome, not a rumor. The bar is full completion and quality, not just showing up and attempting. I treated the third problem as must-finish, which is why the discount edge case ate my clock instead of my score.

What the Detection Surface Actually Covers

As covered above, the pad sees the shared screen and logs paste events but cannot see a second monitor or a separate device beside you. The difference worth naming here is that this exposure risk is distinct from paste or tab tracking. Keep everything that helps you on the screen you are willing to show, and nothing that isn't.

How to Prep for the Shopify OA on CoderPad in 7 Days

Days 1–2 — Orient

I started by confirming the shape of the test from primary reports rather than aggregation pages. The OA is about three questions mixing an open-language LC-medium with a Ruby-specific and a C++/OOP task, it runs on a desktop-only CoderPad, and its AI policy is silent unless your recruiter enables the in-pad assist.

I skipped graph-theory drilling: no reported Shopify OA question has ever been a graph problem. I didn't bother with broad system-design prep either; the OA is a coding block plus an IQ/culture-fit questionnaire, not a design screen, so system-design flashcards would have been wasted days.

Days 3–5 — Drill

I drilled the topics the real reports name. The most-cited advice was 1D DP and stacks, so I worked min-cost and jump-style DP plus stack problems daily. I rebuilt small OOP design tasks in the same shape the reports described, a cart class with add, remove, discount, and total, modeling items in a map and keeping discount as a rate.

I wrote Ruby on purpose, drilling select, map, and sort chains, because the Ruby question is this OA's most consistent differentiator. I also worked e-commerce-flavored DSA: cart totals, discount application, inventory counts, rate-limit windows. Before the drill block, I sent the confirmed question patterns to the InterviewFox Prep Agent over WhatsApp and got back a personalized drill plan I worked from each day.

Days 6–7 — Simulate + Buffer

I ran one full timed three-question simulation in a Monaco-style editor, no help window, to feel the clock pressure I actually hit on question three. I also walked the official CoderPad onboarding tutorial so the environment was not new on test day. Day seven was a low-intensity review buffer: re-reading my DP and Ruby notes, not learning anything net-new.

What Happens After You Submit the OA

The chart below shows the new-grad loop after the OA, and the Life Story node is the one that decides the offer.

The Loop Order

The order is application, then the CoderPad OA, then a technical or pair-programming round, then the Life Story interview, then references, then the offer. That exact sequence holds across multiple intern reviews from early 2026. The OA is a filter near the front, not the final word.

Life Story Is the Real Gate

The OA score advances you, but the offer is decided in the Life Story interview, described in one review as "where they decide if you deserve the offer." I treated the OA as table stakes: clear it clean, then put the real weight on telling my story. A strong OA with a weak Life Story still loses.

Turnaround and Response Time

The next round came "a few weeks later" in the reviews I read, and a final decision landed within five business days of the last round. The whole process ran about three to five weeks. I did not get a same-week answer, and that is normal for this loop.

AI Policy Isn't the Same in Every Shopify Round

The chart below separates the async OA from the live round, and the async row is the ambiguous one.

The Async OA Stays Silent

No review or invite email I read states that AI is permitted in the OA itself. The async CoderPad round's policy is simply silent, so I prepared as if no assist were available and treated any in-pad window as a bonus, not a right.

The Live Round Explicitly Allows AI

The live technical and pair-programming round is different. That stage is described as "Can use AI" or "AI and googling allowed" across multiple 2026 intern reviews. Shopify's own loop treats the live round as AI-enabled even when the OA is not, which is why the two should never be prepped as one policy.

Shopify's Three-Tier Framework

Shopify evaluates on a three-tier AI framework disclosed on the employer side: No AI allowed, AI optional, and AI required. Which tier your round sits in is set per round, not per company, and the OA's silence means you must confirm it with your recruiter rather than assume. I asked mine directly and planned around the answer.

FAQ

Is the Shopify OA really on CoderPad?

Yes. The new-grad and intern OA runs on CoderPad Screen as an async take-home with about three coding questions. The mid and senior screen is a different own-IDE, screen-share environment, so "CoderPad" only describes the new-grad OA.

How long is the Shopify OA and when do I hear back?

No public source gives a duration for the CoderPad OA, so I won't quote one; it felt tight and I simulated three questions under a self-set clock. After submitting, the next round came a few weeks later and a final decision landed within five business days of the last round.

Is AI allowed on the Shopify CoderPad assessment?

The async OA's AI policy is silent, and the in-pad AI Assist only appears if your recruiter enables it, so prep as if no assist is available. The live technical round explicitly allows AI in multiple 2026 intern accounts, which is a different tier than the OA.

Can I use an AI tool or invisible app during the Shopify CoderPad OA?

Desktop overlay tools put the AI's answer on your computer screen, rendered as a hidden layer above the browser using a basic OS-layer trick, and proctoring software keeps adding detection capabilities as AI tools become more common.

InterviewFox pushes the answer to your phone instead, a physically separate device that no screenshot, screen recording, or session monitoring can reach by design. If you use AI assistance during the OA, the dual-device architecture removes the answer from your screen entirely.

What questions are on the Shopify CoderPad interview?

About three coding questions: one open-language LC-medium, one Ruby-specific task, and one C++ or OOP-design problem. One review also reported an IQ/cognitive and culture-fit questionnaire after the coding block. Expect the Ruby question as a near-certainty.

What do people say about the Shopify OA on Reddit?

Candidates on Reddit and similar boards converge on the three-question shape, the Ruby task, and the tight feel, and several warn that solving only two of three was not enough to advance. I read those accounts and my own experience matched the three-question, Ruby-plus-C++ pattern closely.

What is the Shopify CoderPad assessment format?

It is an async CoderPad take-home: roughly three coding questions on a desktop-only pad, possibly followed by an IQ/cognitive and culture-fit questionnaire. Scores are recruiter-gated, a timed-out question still submits, and the visible runner is not the grader.