Skip to content
Tutorials Center
My learning

Topics

Lesson 27 of 28 ยท Practice and Review

Interview Questions

Prepare for a BigCommerce developer interview: concise answers on the platform, REST and GraphQL APIs, apps and OAuth, webhooks, Stencil themes, headless and checkout.

A BigCommerce interview mixes two kinds of questions. Concept questions ask what something is ("what is a channel?", "what does the load callback do?"). Judgment questions ask what you would choose ("REST or GraphQL for this job?", "theme or headless?"). Good answers are short, name the trade-off and show you know where the platform ends and your code begins.

This lesson collects common questions with compact answers, grouped by topic and linked to the lessons that explain each idea. Details such as exact limits and field names change over time, so the answers stay general where precision would go stale; in an interview, say "I would check the current docs for the exact number" and move on. BigCommerce cannot run on this site, so real code is read-only, and the two runnable examples at the end are Node.js stand-ins: a verifier for the signed token an app receives on load, and a retry planner driven by rate-limit headers. Use the page by covering the answers, saying yours aloud and then comparing.

flowchart TD
    Q["Interview topics"] --> A["Platform<br/>SaaS, channels, editions"]
    Q --> B["APIs<br/>REST V2/V3, GraphQL"]
    Q --> C["Apps<br/>OAuth, callbacks, webhooks"]
    Q --> D["Themes<br/>Stencil, Handlebars, widgets"]
    Q --> E["Headless and checkout<br/>Catalyst, carts, checkout"]

The five areas that cover most BigCommerce interviews.

Platform

What does "SaaS commerce" mean for a developer?

BigCommerce hosts and operates the store: servers, scaling, security patches, PCI-relevant infrastructure and the checkout. You cannot change the platform's core code or run your own server-side code inside it. You extend it through APIs, webhooks, apps, themes and widgets, and run any custom back end yourself. The upside is little operational work; the cost is that every extension must fit the platform's contracts. See What Is BigCommerce Development?.

What is a store hash, and why does it matter?

The short identifier of a store, used in API URLs (https://api.bigcommerce.com/stores/{store_hash}/v3/...) and in the context of app callbacks (stores/{store_hash}). An app that serves many merchants uses it as the key to find the right token and data, so it must be part of every database row you keep per store.

What are channels and storefronts?

A channel is a place where products are sold: the default web storefront, a headless site, a marketplace or a point of sale. Products can be assigned to some channels and not others, and a channel can have its own sites and domains, which is how one store runs several storefronts. Headless storefronts also use a channel when they request a storefront token. See Platform Architecture.

How do you get a development environment?

A sandbox or trial store, an API account for scripts, the Stencil CLI for themes, and a tunnel such as ngrok if you test app callbacks locally. Keep secrets in environment variables, never in the repository. See Setting Up a Development Environment.

APIs

What is the difference between the V2 and V3 APIs?

V3 is the modern, consistent surface: JSON envelope with data and meta, predictable pagination and filters, batch operations. V2 is older and still the home of some resources, notably orders, and uses simpler arrays. A real integration usually mixes them, for example V2 for orders and V3 for catalog and customers. See Orders, Customers and the V2/V3 Split.

How do you authenticate to the REST API?

With an access token in the X-Auth-Token header, over HTTPS. Tokens come from a store-level API account (your own scripts) or from the OAuth flow of an app (every merchant who installs it). Each token carries scopes, so a token can only call what it was granted. See API Accounts, Tokens and Scopes.

How do you page through a large catalog correctly?

Request with page and limit, process data, and continue until meta.pagination.current_page reaches total_pages. Never assume that a short page means the end, because the server may apply its own maximum. Use include_fields and filters to reduce what you fetch. See The Catalog API (V3).

What are batch operations and what is their main trap?

Collection-level PUT or POST calls that handle many items in one request, with a per-endpoint cap on size. The trap is that the request can succeed while some items fail, so you must read the response body, retry only retryable items and design the job so repeating it is safe.

How do you handle rate limits?

Treat 429 Too Many Requests as normal. Read the rate-limit response headers (X-Rate-Limit-Requests-Left, X-Rate-Limit-Time-Reset-Ms and the quota/window pair) to slow down before the limit, wait at least the reset time after a 429, and retry transient failures with exponential backoff plus jitter. Do not hard-code limits, because they depend on plan and can change. The second stand-in below does this.

When do you choose GraphQL over REST?

Use the GraphQL Storefront API when a page needs a specific shape of public catalog and cart data in few round trips, which is typical for headless storefronts. Use REST for back-office work, bulk operations and anything the GraphQL schema does not offer. There is also an admin GraphQL API for account-level operations; check which resources it covers before relying on it. See GraphQL Storefront API and GraphQL Admin API and Choosing Between APIs.

What is a storefront token, and who may hold it?

A token for the GraphQL Storefront API, created through the REST API for a channel, with an expiry and a list of allowed origins. Because it is limited to public storefront data, it can sit in a browser-facing app; a token that impersonates a customer is more sensitive and belongs on the server. Never confuse it with an admin API token, which must never reach the browser.

Apps and OAuth

Walk me through installing a single-click app.

The merchant chooses the app; the platform redirects to your auth callback with a one-time code, the granted scope and a context (stores/{hash}). Your server validates them, POSTs to the platform's token endpoint with your client ID, client secret, the code and the redirect URI, and receives an access token for that store. You save the token under the store hash and render your app. See App Types and the OAuth Flow.

What do the load and uninstall callbacks do?

The load callback runs every time the merchant opens your app in the control panel; it receives a signed payload that identifies the store and the user. You verify the signature with your client secret before trusting anything in it. The uninstall callback tells you the merchant removed the app, so you revoke access, stop jobs and handle data according to your policy. See Building an App Backend.

How is the signed payload verified?

In the current flow it is a JWT signed with HMAC using your client secret. You must verify the signature, check the algorithm is the one you expect, and check the claims: the audience equals your client ID, the issuer is the platform, and the token has not expired. Only then do you trust the store and user inside. The first stand-in below does exactly this with node:crypto.

Where do you store access tokens?

Server-side, encrypted at rest, keyed by store hash, readable only by the code that needs them. They are credentials to a merchant's store. Never log them, never send them to the browser, and remove them on uninstall.

Webhooks: how do you build a reliable receiver?

Return a 2xx quickly after validating and queuing the work, do the slow processing asynchronously, and make the handler idempotent because deliveries can repeat and arrive out of order. The payload is a small notification (scope and ids), so fetch the current resource from the API instead of trusting the payload as the data. Platforms do not always sign webhook requests the way payment providers do, so register a destination header with a secret value and compare it in constant time. Failing endpoints are retried and can be deactivated. See Webhooks and Webhooks and Signatures.

Themes

What is Stencil?

BigCommerce's theme framework: Handlebars templates, SCSS, JavaScript bundled with Webpack, configuration in config.json and schema.json, and the Stencil CLI for local development (stencil init, start, bundle, push). Cornerstone is the reference theme most projects start from. See Stencil CLI and the Cornerstone Theme.

What is the page context?

The data object the platform gives each template: product, category, cart, customer, settings and theme settings, depending on the page type. Templates read it with Handlebars expressions and helpers. If you need extra data, you can request it through a GraphQL query in a page's front matter rather than calling APIs from the browser. See Handlebars Templates, Helpers and Page Context.

How do merchants customize a theme without code?

Through theme settings defined in the schema (colors, fonts, toggles), and through Page Builder, where merchants place widgets in regions. Developers define the widget templates and their settings schema. See Theme Settings, SCSS and JavaScript and Widgets, Regions and Page Builder.

How would you add third-party JavaScript to a store?

With Script Manager in the control panel when it is a snippet or tag, scoped to pages and categories of consent; or inside the theme when it is part of the product. Keep an eye on performance and privacy, because every script is a cost on every page.

Name three theme performance practices.

Ship less JavaScript and CSS (split by page type), use responsive images and lazy loading, and avoid blocking third-party scripts. Measure with real metrics rather than guesses. See Performance, Security and Launch.

Headless and checkout

When is headless a good idea, and when is it not?

It fits when you need a custom experience, an existing front-end team, content from other systems, or several brands on one catalog. It does not fit when the stock theme and widgets meet the need, because you take on hosting, caching, SEO, accessibility and every integration yourself. See Headless Storefronts.

What is Catalyst?

BigCommerce's open-source, Next.js-based starter for headless storefronts, using the GraphQL Storefront API. It is a starting point you own and change, not a hosted product.

How does a headless site hand off to checkout?

It creates a cart through the API, requests the cart's redirect URLs, and sends the shopper to the hosted checkout. This keeps payment, tax and compliance on the platform. See Carts and the Checkout API and Checkout Flow.

How can you customize checkout?

By settings in the control panel, by Checkout SDK or Checkout JS for a fully custom checkout app, and by providers for payments, shipping quotes and tax. Customizing the checkout is a heavy responsibility, because it touches payment and compliance. See Customizing Checkout and the Checkout SDK and Payment, Shipping and Tax Providers.

How would you test an app?

Unit-test handlers with the platform stubbed, run contract tests against recorded responses, and do end-to-end checks on a sandbox store. Test failure paths: expired tokens, 429 and 5xx responses, duplicate webhooks. See Testing Apps and Themes.

Stand-in 1: verify a signed load payload

This stand-in builds an HS256 JWT by hand and verifies it the way an app's load callback should. It is not the real platform token: the claims are simplified, and a real app should also use a vetted JWT library. It shows the checks that matter: signature (constant-time), algorithm, audience, issuer, expiry and the shape of the store reference.

Node.js Verify a signed load payload (HS256)

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with node:readline or process.stdin), it gets the next line from this box.

Only the untouched token is accepted. A token signed with another secret, or with changed claims, fails the signature check; an alg: none token is rejected before any claim is trusted; expiry and audience are checked after the signature, because claims of an unverified token mean nothing. Interviewers often ask about the alg: none trap, and the answer is the one in the code: decide the algorithm yourself instead of believing the header.

Stand-in 2: plan retries from rate-limit headers

This stand-in answers "how do you handle rate limits?" with a pure function: given a response status and headers, it returns how long to wait, or null when the request should not be retried. It uses the header names from Orders, Customers and the V2/V3 Split; the numbers are invented and the backoff policy is a common choice, not a platform rule.

Node.js Plan the next wait from status and headers

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with node:readline or process.stdin), it gets the next line from this box.

A 429 with a reset header waits for exactly that reset plus a small margin; without the header it falls back to exponential backoff. A 503 backs off more with each attempt, capped at five seconds, with jitter so many workers do not retry together. A 401 or 404 is never retried, because the same request will fail again. A success with one request left in the window pauses until the reset, which prevents the 429 in the first place.

Check your understanding

Quick check ยท 5 questions

of 5 answered You scored / 5 ยท perfect!

  1. 1. Your app receives a signed payload when the merchant opens it. What must you do before trusting the store and user inside?

    Anyone can send a request to your URL. Only a valid signature, made with a secret that you and the platform share, proves who the payload comes from.
  2. 2. A batch update returns 200. What is the correct next step?

    Batch endpoints can partially fail. The body tells you which items need attention.
  3. 3. Which choice best describes when to use headless commerce?

    Headless trades convenience for control. It is worth it when the control is needed.
  4. 4. A webhook is delivered twice. How should your handler behave?

    Duplicates are normal. Acknowledging stops retries, and a dedupe key prevents repeated side effects.
  5. 5. Why is a 401 response not retried by a well-behaved client?

    Retries are for transient conditions such as 429 and 5xx. Authentication errors need a fix, not a repeat.

Summary

  • BigCommerce is SaaS: you extend it with APIs, webhooks, apps, themes and widgets, and run your own back end for anything else.
  • Know the V2/V3 split, correct pagination, batch partial failure and rate-limit handling with backoff.
  • Know the app lifecycle: auth callback and code exchange, signed load payload verification, uninstall cleanup, secure token storage.
  • Webhook receivers must be quick and idempotent, and fetch fresh data instead of trusting the notification.
  • Stencil themes use Handlebars, settings and Page Builder widgets; headless storefronts use GraphQL and hand off to hosted checkout.
  • In an interview, name the trade-off, and say you would verify exact limits in the current documentation.

Next: BigCommerce Cheat Sheet