Learn Shopify development after Academy: a free 6‑week plan

Run Shopify's own theme on your own store and know where every file lives before you write any Liquid.

• Create a dev store: in the Dev Dashboard go to Stores, Create store, Dev, and tick Generate test data. Or run shopify store create dev --with-demo-data.
• Install Shopify CLI with npm install -g @shopify/cli@latest, and the Shopify Liquid extension for VS Code (Theme Check is built in).
• Clone Horizon and run shopify theme dev --store your-store. Open the preview URL it prints.
• Trace the product page: templates/product.json lists the sections, the sections live in sections/, their blocks in blocks/. Write down which file renders the price.

Done when: Horizon runs on your dev store, the code is in a Git repo, and you have a one-page map of its folders.

Read and change Liquid in a real theme, using the filters production code depends on.

• Learn the filters you will use every day: money for every price, image_url with image_tag for every image, t for every piece of customer-facing text, and default for fallbacks.
• Practise if, unless, case, for with limit, assign, capture and the {% liquid %} tag.
• Use render for snippets and pass variables in explicitly. include is deprecated.
• Make three small changes to Horizon on your dev store, one commit each. For example: a low stock message when variant.inventory_quantity is under 10.

Done when: Three small, working changes to a real theme, each in its own commit.

Know which object holds the data you need, and where custom data belongs.

• Work through product, variant, collection, cart, customer, request and settings in the Liquid reference. Note which ones exist on which page.
• Show the price and availability of product.selected_or_first_available_variant instead of the first variant.
• Define a product metafield in Settings, Custom data, fill it on two products, and read it in Liquid with product.metafields.namespace.key.

Done when: A product page that shows specs from metafields, with nothing hardcoded.

Build something a merchant can add, move and edit in the theme editor without calling you.

• Write a section with a {% schema %}: settings, blocks and a preset, so it shows up in Add section.
• Read how Horizon uses theme blocks in blocks/ and renders them with {% content_for 'blocks' %}.
• Put the section's CSS and JS in {% stylesheet %} and {% javascript %}. One of each per file, and no Liquid inside them.
• Move every string the customer sees into locales/en.default.json and output it with t.

Done when: A section with blocks that you add, reorder and edit from the theme editor.

Add the kind of feature stores hire for, without slowing the store down.

• Add to cart without a page reload: post to /cart/add.js and ask for the cart sections in the same call with the sections parameter (bundled section rendering, up to five sections).
• Build cart URLs from window.Shopify.routes.root so they keep the customer's language and region.
• Give every image widths and sizes through image_tag. Lazy-load images below the fold, never the main image at the top.
• Run shopify theme check and a Lighthouse report on your product page. Fix what they find.

Done when: Add to cart updates the cart count without a reload, and Theme Check reports no errors.

Work the way a team works: in Git, reviewed, previewed, never edited live.

• Connect a branch to an unpublished theme with the Shopify GitHub integration (Online Store, Themes, Add theme, Connect from GitHub). Edits in the theme editor come back as commits.
• Or push from the CLI: shopify theme push --unpublished creates a new theme in the library that you can preview and share.
• Run shopify theme check in CI on every pull request, so errors are caught before review.
• Ask an AI tool to write a section, then review it like a pull request: raw prices, hardcoded text, invented filters, missing empty states. Check every filter against the Liquid reference.

Done when: A public repo, a shared preview of your theme, and one written review of AI-generated code.

A real app, open in your store's admin, that you can find your way around.

• Run shopify app init and pick the React Router template, which Shopify recommends for most apps.
• Run shopify app dev and install the app on your dev store.
• Find the routes in app/routes, the config in shopify.app.toml, and where the template stores sessions.
• Install the Shopify AI Toolkit if you use an AI coding agent, so it reads the current docs instead of guessing.

Done when: Your app opens inside your dev store's admin and the code is committed.

Read and write store data, asking for only the access the app needs.

• Set the app's access scopes in shopify.app.toml. Ask for the fewest that do the job.
• Write one query and one mutation against the GraphQL Admin API, and check both against the reference.
• Add a table to the app's own database and a page in the app that uses it.
• Commit before you let an agent change anything, so every change it makes is a diff you can read.

Done when: A page in your app that reads store data and saves something of its own.

Put the app's feature where it belongs: the admin, the storefront or checkout logic.

• Decide where the feature runs: a theme app extension for the storefront, a Function for discount or checkout logic, or the app's own pages for the admin.
• Generate it with shopify app generate extension and preview it with shopify app dev.
• Subscribe to a webhook in shopify.app.toml. Apps in the App Store must also handle the three compliance webhooks: customers/data_request, customers/redact and shop/redact.

Done when: One extension or Function working on your dev store.

Release the app the way you would for a client, and know what you released.

• shopify app deploy creates an app version (a snapshot of the app's configuration and extensions) and releases it. Add --no-release to create the version without releasing it.
• Releasing a version doesn't deploy your web app. Host it yourself and point the app's URLs at it.
• Write a README: what the app does, the scopes it asks for and why, and how to run it.

Done when: A released app version on your dev store and a repo someone else could run.