Building Shopify Apps in 2026: Remix, App Bridge, and GraphQL by Default

Shopify app development used to involve a lot of decisions: which framework, which auth library, REST or GraphQL, how to embed in the admin. In 2026 most of those decisions have been made for you, and the result is a far more coherent developer experience. The official app template is built on Remix, embedded UI runs through App Bridge, and the GraphQL Admin API is the default — with the REST Admin API relegated to legacy status and closed to most new apps. This post walks through the modern stack and the decisions that still matter.

The starting point: Shopify CLI and the Remix template

Everything begins with the Shopify CLI. A single command scaffolds a working app — auth, webhooks, an embedded admin page, and a local tunnel for development:

shopify app init
cd my-app
shopify app dev

The default template is a Remix application. Remix suits Shopify apps well because its loader/action model maps cleanly onto the request cycle of an embedded app: loaders fetch data from the Admin API on the server, actions handle mutations, and almost no API credentials ever touch the browser. The template ships with the @shopify/shopify-app-remix package, which handles OAuth, session storage, and webhook verification — the plumbing that consumed days of setup in earlier eras.

A typical authenticated loader looks like this:

export const loader = async ({ request }) => {
  const { admin } = await authenticate.admin(request);
  const response = await admin.graphql(`
    query {
      products(first: 10) {
        edges { node { id title status } }
      }
    }
  `);
  const data = await response.json();
  return { products: data.data.products.edges };
};

You are not locked into Remix — the CLI supports other stacks, and any framework that can complete OAuth and serve an embedded page works — but the Remix template is where Shopify's documentation, examples, and tooling investment are concentrated.

GraphQL is the default, not an option

The most consequential platform shift of recent years: Shopify declared the REST Admin API legacy, and new public apps are expected to use GraphQL. This is not just a policy change — the GraphQL API is genuinely more capable:

• Newer features are GraphQL-only. Product APIs supporting large variant counts, metaobjects, and many B2B capabilities never came to REST.
• Fewer round trips. One query fetches a product, its variants, its metafields, and inventory levels together instead of four sequential REST calls.
• Cost-based rate limiting. GraphQL rate limits are calculated from query cost rather than raw request counts, which rewards precise queries that select only needed fields.
• Bulk operations. For large datasets, bulk queries run asynchronously on Shopify's side and deliver a JSONL file, sidestepping pagination entirely.

The practical adjustment for REST-era developers is learning to think in selections and connections. Request exactly the fields you need, paginate with cursors, and lean on bulk operations for anything touching thousands of records.

App Bridge and Polaris: feeling native in the admin

Embedded apps render inside an iframe in the Shopify admin, and App Bridge is the bridge across that boundary. The modern version loads from Shopify's CDN, exposes web components and APIs for navigation, modals, toasts, and contextual save bars, and keeps session tokens flowing so every request to your backend is authenticated. Pairing App Bridge with Polaris — Shopify's design system — makes an app visually indistinguishable from the admin itself.

This matters commercially, not just aesthetically. Built for Shopify status, the quality bar that unlocks better App Store placement, requires apps to meet performance and UX standards that effectively assume App Bridge and Polaris usage. Merchants have learned to expect admin-native behavior; apps that bounce users to an external dashboard convert measurably worse in reviews and retention.

Extensions: putting logic where the merchant works

A modern Shopify app is rarely just an embedded page. Much of its value ships as extensions — sandboxed units that run in specific surfaces:

• Admin UI extensions add blocks and actions directly into product, order, and customer pages.
• Checkout UI extensions render custom fields, upsells, and content in checkout.
• Shopify Functions run server-side logic — custom discounts, payment and delivery customizations, cart validation — as WebAssembly modules executed by Shopify with strict performance budgets.
• Theme app extensions inject storefront blocks without editing theme code.

Functions deserve special attention. Because they execute inside Shopify's infrastructure rather than calling out to your server, they are fast and reliable in ways webhook-driven customization never was. Writing them means thinking in pure input/output terms: Shopify hands your function the cart state, your code returns operations, and there is no network access at runtime.

Webhooks, reliability, and the boring essentials

The unglamorous parts of app development still separate good apps from abandoned ones. Declare webhooks in your app configuration file so they are versioned with your code. Verify HMAC signatures on every delivery. Process webhook payloads asynchronously — acknowledge fast, queue the work — because Shopify retries slow endpoints and eventually removes subscriptions that keep failing. Handle the mandatory privacy webhooks (customer data requests and erasure) from day one, since App Store review checks them. And pin an API version explicitly, then schedule quarterly bumps; Shopify supports each version for a year, which is generous only if you actually use the time.

Where to go from here

The consolidated stack — CLI, Remix template, GraphQL, App Bridge, extensions — means a competent web developer can ship a working embedded app in days rather than weeks. The craft now lies in the domain problem: modeling merchant workflows, respecting rate limits at scale, and building extension experiences that feel like part of Shopify. Scaffold the template, get one GraphQL query and one Function working end to end, and you will have touched every load-bearing piece of modern Shopify app development.