Skip to content
Tutorials Center
My learning

Topics

Lesson 1 of 55 ยท Orientation

What Is a Shopify App?

Learn what a Shopify app is, the difference between public and custom apps, where apps show up (admin, storefront, checkout, POS) and how development stores work.

Shopify gives every merchant a store with products, orders, customers, a checkout and a theme. What it deliberately does not give them is every feature they might ever want: a loyalty program, a bulk editor, a custom discount rule, a connection to their accounting system. Those features come from apps. A Shopify app is a program, written by you or someone else, that is installed on a store and extends it through Shopify's APIs and extension points.

This track teaches you to build such apps. In this first lesson you will get the vocabulary straight: what kinds of apps exist, where they appear to merchants and shoppers, what Shopify does for you, and what you must build yourself. Nothing here needs an account yet. The code that talks to Shopify cannot run on this site, so every lesson shows the real code in read-only blocks and pairs it with a small runnable stand-in that models the idea in plain JavaScript. We will always say which is which.

An app is a small server plus a few pieces on Shopify

Most apps have two halves.

  • Something you host. A web server with a database. It stores your own data (settings, logs, subscriptions) and calls Shopify's APIs. You choose the language and hosting provider. Shopify's current template uses Node.js, React Router and Prisma, and we will use it in this track.
  • Something Shopify hosts for you. Extensions. These are small pieces of UI or logic that you upload to Shopify, and Shopify runs them inside the admin, the theme, the checkout or the point-of-sale app. Discount rules written as Shopify Functions also run on Shopify's infrastructure, not yours.

A simple app might be only the first half (a nightly job that syncs inventory). Another might be only the second half (a function that adds a volume discount). Most useful apps mix both. Lesson 2, App Architecture at a Glance, draws the whole picture.

App types

The word "app" covers a few different distribution models. Here are the ones you need to know.

Type Who installs it Typical use Listing
Public app Any merchant A product you sell to many stores Listed in the Shopify App Store (after review), or installable through a link
Custom app One merchant Work for a single client Never listed; installed by a link or created in that store
Merchant-owned app The merchant who built it A store's own internal tooling Not listed

Shopify has changed where and how you create these several times, and the names in dashboards shift. The stable idea is the distinction between many stores and one store. Public apps need to work for any store and pass app review. Apps for a single store skip the listing and review, which makes them a good place to start. Distribution and the exact screens are the part of the platform most likely to change, so check the official help when you create your first one.

Merchants can also create a small app straight from their store admin for their own scripts, without any hosted server (it gives them an access token). We focus on apps with a proper app setup because that is what you build as a developer, and it is the model Shopify designs most of its tooling for.

Where apps appear

An app can show up in several places. Each place is called a surface.

  • Admin. The merchant's back office. Your app can have its own embedded pages (an iframe inside the admin), small extensions on product or order pages, and actions in menus.
  • Online store (theme). App blocks and app embeds let a merchant place your widget (reviews, a size chart, a banner) in their theme without editing code.
  • Checkout. Extensions add upsells, custom fields or messages, and Shopify Functions change discounts, shipping options and validation.
  • Customer accounts. Extensions in the order status and account pages.
  • Point of sale (POS). Extensions for staff using Shopify POS in a physical shop.
  • No UI at all. Background apps that only listen to webhooks and call APIs.
flowchart LR
    APP["Your app"] --> A["Admin<br/>embedded pages and actions"]
    APP --> T["Online store<br/>app blocks and embeds"]
    APP --> C["Checkout<br/>UI extensions and Functions"]
    APP --> P["POS and customer accounts"]
    APP --> B["Background<br/>webhooks and API calls"]

One app can reach several surfaces at the same time.

The accounts and stores you need

Before you can build, you will set up these (the details come in Tooling and Setup):

  • A developer account (historically called a Partner account). You create and manage apps there. Shopify now centers app management in the Dev Dashboard, where each app gets an ID and a client secret.
  • One or more development stores. These are free, non-live stores for testing. You can fill them with test products and orders, and place test orders that cost nothing. A development store is where your app runs while you build it.
  • The Shopify CLI, a command-line tool that creates your app from a template, runs a tunnel to your laptop, and deploys your configuration.

Keep your development store away from real customer data. The whole point is that it is a safe sandbox.

What the platform does for you

Think of what building a custom checkout, hosting a store, and handling logins would cost. Shopify takes on a lot:

  • Merchant identity. The merchant is already signed in to the admin. Your embedded app can rely on that session instead of building a login page. Chapter 2 explains how.
  • Installation. Merchants approve the scopes (permissions) your app asks for, and Shopify records the install.
  • Data and APIs. Products, orders, customers and inventory live on Shopify. You read and change them through the GraphQL APIs.
  • Hosting for extensions and functions. You upload them; Shopify serves them.
  • Billing. You can let Shopify charge merchants for your app and pay you a revenue share. Look at App Pricing Models and Billing Options later.
  • Events. When something changes in the store, Shopify sends you a webhook.

What you still own is your own server, your database, your uptime, your support, your privacy compliance and the quality of your app.

Read-only: what an app looks like to Shopify

An app is described by a configuration file in your project. This is real platform configuration, shown read-only (do not worry about each line yet; App Configuration with shopify.app.toml explains it):

TOML
name = "Stock Notes"
client_id = "your-client-id-from-the-dashboard"
application_url = "https://stock-notes.example.com"
embedded = true

[access_scopes]
scopes = "read_products,write_products"

[webhooks]
api_version = "2026-10"

  [[webhooks.subscriptions]]
  topics = ["app/uninstalled"]
  uri = "/webhooks/app/uninstalled"

The file says where your app lives, what it is allowed to touch, and which events it wants. Everything else you build hangs off this contract.

A runnable mental model

We cannot call a real store here, so the first stand-in models the platform's central idea: a merchant installs an app and grants it scopes. Every API call is checked against what was granted. The data store, scopes and callApi function are all fake, but the rule is the real one: an app can only touch what the merchant approved.

JS Install an app and call the API

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

No output.

The "Editor App" asked for two scopes but the merchant approved only one, so its write call is denied. In a real app Shopify enforces this on its servers, which is why you request only what you need. Managed Installation and Access Scopes covers this properly.

Choosing the surfaces: a second stand-in

When you plan an app, a useful first question is "where does the merchant or shopper need to see this?" This small helper maps needs to surfaces. It is only a planning aid, but it encodes the real division of labor.

JS Which surfaces does my idea need?

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

No output.

Notice that the volume discount needs two parts: the logic (a function that runs on Shopify) and a settings page (hosted by you). Many real apps look like that.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. Which part of a typical app does Shopify host for you?

    You upload extensions and functions and Shopify runs them. Your embedded pages, database and jobs run on your own hosting.
  2. 2. What mainly separates a public app from a custom app?

    The key difference is distribution. Public apps must work for any store and go through review if listed. Custom apps are made for one merchant.
  3. 3. What is a development store for?

    A development store is a free, non-live store where you can create test data and place test orders while building.
  4. 4. A merchant approves only read_products for your app. What happens when it tries to write a product?

    API access is limited to the scopes the merchant granted, so a write call without a write scope fails.

Summary

  • A Shopify app extends a store through APIs and extension points. Many apps have a server you host plus extensions Shopify hosts.
  • Public apps serve many merchants and go through review when listed; custom and merchant-owned apps serve a single store.
  • Surfaces include the admin, theme, checkout, customer accounts, POS, and background-only apps. One app can use several.
  • You build in a development store with a developer account and the Shopify CLI.
  • Shopify gives you merchant identity, installation, APIs, extension hosting, billing and webhooks; you own your server, data and compliance.
  • The runnable examples in this track are stand-ins that model the ideas; the Shopify code is shown read-only.

Next: App Architecture at a Glance