"Expert" is the most overused word in developer hiring. Every freelancer profile and agency case study uses it. This guide strips it back to 7 verifiable signals so you can tell the difference between a developer who markets themselves as an expert Shopify® developer and one who actually is.
Junior vs mid vs expert: the actual differences
Junior Shopify developer: Understands Liquid templating, can customize existing themes, knows how to install and configure apps, follows documentation reliably. Does not independently architect solutions. Needs code review on anything beyond standard customization.
Mid-level Shopify developer: Can build custom theme sections from scratch, write section schema, add JavaScript for interactive components, and complete a basic API integration. Will hit walls on complex problems: Plus-specific capabilities, edge cases in webhook infrastructure, performance optimization beyond surface-level.
Expert Shopify developer: Has shipped work across the full Shopify stack — theme builds with measurable performance results, custom apps with production webhook infrastructure, checkout extensions and Shopify Functions for Plus merchants, integrations with ERP-class systems. Knows the failure modes because they have seen them in production. Knows when Shopify is the wrong tool and says so.
The gap between mid and expert is not years. It is exposure to complexity and the judgment that comes from recovering from production failures.
7 signals of an expert Shopify developer
Signal 1: Plus production work
Ask for specific Plus stores shipped in the last 18 months. An expert can name them, describe the Plus-specific capabilities built, and explain what decisions they made that were specific to Plus rather than standard Shopify behavior.
If the developer has only worked on standard stores, they are not an expert for Plus-tier work regardless of their tenure. Standard Shopify and Plus share a codebase but the work is fundamentally different.
Signal 2: Shopify Functions in production
Shopify Functions are server-side logic running at Shopify's infrastructure level, written in Rust or AssemblyScript. They are the replacement for the old script editor and are now the only way to build certain discount, shipping, and payment customizations on Plus.
Ask: "Have you shipped a Shopify Function? What was it doing, and what were the edge cases?"
An expert has an immediate, specific answer. A developer who says "we use apps for discounts" is not current for Plus-level customization work.
Signal 3: Checkout UI Extensions
Checkout.liquid was deprecated for Plus merchants in 2024. The replacement is Checkout UI Extensions — React-based components that extend the checkout flow at defined extension points. Ask: "What checkout extensions have you built and what did they add to the checkout experience?"
Real experience means knowing the extension points available, the React component model, the testing constraints during development, and the limitations of what can be customized within Shopify's extensibility model.
Signal 4: A real Hydrogen migration story
An expert who has worked on headless development will have a specific story: "We moved a client from Online Store 2.0 to Hydrogen because of a specific performance constraint. Here is what we discovered about edge caching behavior on their traffic pattern."
Contrast this with: "We recommend Hydrogen for most serious projects." The latter is a sales pitch, not experience.
Signal 5: Theme performance results with specific numbers
Ask for the Core Web Vitals on a live store they built. LCP under 2.5s on mobile, INP under 200ms, CLS under 0.1. Ask how they achieved them: image format and compression choices, lazy-loading strategy, third-party script management, font loading approach.
A developer who cannot produce these numbers has either not measured them or has not consistently hit targets. Both are problems for a project where performance is in scope.
Signal 6: Deep Liquid architecture patterns
Mid-level developers write Liquid that works. Expert developers write Liquid that is maintainable, efficient, and consistent with Shopify's section rendering model.
Ask: "Walk me through how you structure a complex theme section — schema, Liquid, JavaScript — to make it fully editable in the theme editor without breaking the layout."
An expert can walk through this from memory because they have done it many times: schema settings design, section groups, predictable spacing contracts, avoiding JavaScript that breaks theme editor live preview.
Signal 7: Knowing when NOT to recommend something
The strongest expert signal is restraint. Ask: "Tell me about a situation where a client wanted Hydrogen (or a custom app, or a major rebuild) and you talked them out of it."
An expert who answers with a real example — "we evaluated their traffic patterns and performance budget and determined an Online Store 2.0 theme with proper image optimization would hit their LCP target without the infrastructure complexity" — is showing you something more important than technical skill: judgment that favors your outcome over their contract value.
Interview questions that surface real expertise
Use these 5 questions to separate genuine expertise from polished marketing:
- "Tell me about a Shopify integration you built that broke in production. What failed and what did you change?"
- "Walk me through how you would approach migrating a 50,000-SKU WooCommerce store to Shopify Plus. What are the riskiest parts of the process?"
- "What does your process look like for setting and hitting a performance budget on a new theme build?"
- "For a Plus merchant with complex B2B pricing rules, how would you approach discount logic — Shopify Functions, apps, or something else? Why?"
- "What is something you have seen standard Shopify agencies get wrong on Plus projects?"
The last question is particularly revealing. An expert has opinions formed by seeing failures — their own and others'. A developer with no answer has not been close enough to complex work to form them.
The production failure question (question 1) is also high-signal. A developer who has never recovered from a real production failure has not been in high-stakes engagements. The answer should describe a specific failure mode, how it was detected, and what architectural change prevented recurrence.
Mid-level developers misrepresented as experts: the common patterns
Knowing what expert looks like also means knowing what mid-level-misrepresented-as-expert looks like. Common patterns:
Years of experience substituting for depth. "5 years of Shopify experience" is a marketing statement. It says nothing about what complexity that experience covered. A developer who spent 5 years doing theme customizations on small stores is a very different profile from one who spent 3 years on Plus migrations and integration work. Ask about project types, not tenure.
Agency portfolio without individual attribution. Agencies build portfolios. Individual developers sometimes present the agency portfolio as their personal work. Ask specifically: "Which part of this store did you build? What was your role on the project?" A developer who cannot answer this clearly did not build the store.
Demo stores instead of production. A demo built for a pitch has no third-party scripts, no real image assets, no legacy app conflicts, and no real user traffic. Ask for the PageSpeed Insights URL of a live store, not a staging link.
Technical vocabulary without depth. Some developers have learned to use words like "server-side rendering," "edge caching," and "hydration" without understanding them. Ask them to explain a decision they made using that concept on a real project. The follow-up question ("what was the tradeoff you were making?") separates vocabulary from understanding.
What to look for in a 2-week paid trial
The fastest way to validate expertise is to assign a well-scoped piece of real work at the contracted rate before committing to a longer engagement.
For a 2-week trial, the right scope is something meaningful but bounded: a specific theme section with full schema and editor compatibility, a webhook listener with failure handling and retry logic, or a checkout extension with 1-2 defined behaviors.
During the trial, evaluate not just the output but the process:
- Did they ask the right questions upfront or barrel ahead with assumptions?
- Did they write Liquid/Apex/JavaScript that a future developer can read and modify?
- Did they handle the edge cases you did not explicitly specify?
- Did they communicate blockers immediately or surface them at the end?
Expert developers are identifiable within 2 weeks. Mid-level developers who misrepresented their seniority are also identifiable within 2 weeks, before you have committed to a 6-month engagement.
The Sapota team includes expert Shopify developers with production Plus work, shipped Shopify Functions, live checkout extensions, and measurable Core Web Vitals results. The 2-week paid trial is built into every engagement. Talk to the team here.
