The single biggest predictor of whether a Shopify project stays on budget isn’t the developer’s skill — it’s whether you handed them a complete brief on day one. A Shopify web development company can only move as fast as the decisions and materials you give it; every day spent waiting on a domain login, a missing logo file, or an undecided shipping policy is a day added to your timeline and, on hourly engagements, a day added to your invoice.
This guide is a practical, working checklist — a Shopify website checklist you can actually use, not just read — covering domain, hosting, brand assets, payment gateway, shipping, legal pages, analytics, SEO requirements, integrations, account access, and testing. It’s written for business owners about to brief a developer, freelancer, or agency, so the project starts with everything it needs rather than stalling.
By the end, you’ll have a single consolidated checklist you can hand directly to whoever builds your store, and a clear sense of what happens — in cost, time, and quality — if any of these pieces are missing when development starts.
Why This Checklist Belongs Before Development, Not After
There are two different checklists in a Shopify project, and conflating them is a common source of confusion. A pre-launch (go-live) checklist is a final quality check right before a finished store goes public — confirming everything built actually works. This checklist is different: it’s everything that needs to be decided and gathered before a single line of theme code gets written, so the build itself doesn’t stall waiting on you.
The mechanism is straightforward: a developer working on a fixed-price or hourly engagement can only build what’s been decided. When a decision (a shipping policy, a brand color, a domain login) isn’t ready, one of two things happens — the developer guesses and builds something you’ll likely ask to redo, or the project pauses and waits.
Both outcomes cost money. Unclear inputs are also exactly how scope creep starts: a vague starting point invites revision requests once real content and decisions finally show up mid-build, which is a slower and more expensive way to make the same decisions you could have made upfront.
Who Should Own This Checklist
Preparing this checklist is primarily the business owner’s responsibility, although a developer can provide guidance where needed. This distinction is worth making because it’s a common point of confusion.
A developer can advise on best practices (which shipping model tends to convert better, what a typical privacy policy covers). Still, they cannot decide your business’s shipping rates, write your brand’s About Us copy, or produce your product photography. Those are business decisions and business assets; a developer executes around them, but can’t originate them on your behalf.
Where a developer can genuinely help: technical setup steps like DNS records, staff account structure, and app configuration are reasonable to hand off once you’ve made the underlying decision. The dividing line is roughly this — if it’s a decision about your business (what you sell, how you ship, what your brand sounds like), it’s yours to make; if it’s a technical execution step implementing that decision, it’s reasonable to delegate.
Domain: What to Decide and Have Ready
Buying a Domain
Decide whether you’re buying a new domain through Shopify directly (simplest — DNS is configured automatically) or connecting a domain you already own through a third-party registrar (GoDaddy, Namecheap, IONOS, and similar).
DNS access and ownership.
If you’re connecting an existing domain, you need login access to whichever registrar holds it, and you need to know whether you personally control that login or whether an old freelancer, agency, or IT contact still does — this is worth confirming before the project begins, not discovering during launch week.
What actually needs to change.
Connecting a third-party domain means pointing your A record to Shopify’s IPv4 address (23.227.38.65) and your CNAME record (www) to shops.myshopify.com, per Shopify’s own documentation — changes typically take effect within two hours but can take up to 48 hours to fully propagate. If your domain has DNSSEC enabled, Shopify’s connection flow will flag it and require it to be disabled first, since Shopify doesn’t support DNSSEC.
Subdomains, redirects, and email.
If you’re migrating from an existing site, decide upfront whether old URLs need redirect mapping (covered in the SEO section below) and confirm your email (MX records) won’t be disrupted by DNS changes — email delivery runs on separate DNS records from your website, but it’s still worth explicitly confirming with whoever manages your domain before any changes are made.
Hosting and Technical Foundation
“Hosting” on Shopify isn’t something you set up separately — it’s included in your subscription, and Shopify manages the servers, SSL, and infrastructure.
What you do need to decide before development starts is which Shopify plan tier fits your business, since switching plans mid-project can affect available features your developer may already be building around.
Choose your plan before development starts.
As of 2026, core plans are Basic ($39/month, or $29/month annually), Grow ($105/month, or $79/month annually), Advanced ($399/month, or $299/month annually), and Shopify Plus (from roughly $2,300/month on a multi-year term).
Note that while the Basic plan does not include internal staff accounts for employees, external developers or agencies can access the store using Shopify Collaborator Accounts. This allows partners to work securely via their own dashboards without requiring the merchant to share owner credentials or upgrade their plan tier just for development access.
Staff account structure.
Decide who needs access and at what permission level before the developer starts, rather than sharing your owner login as a placeholder — this is expanded on fully in the Access and Credentials section below.
Store details.
Have your legal business name, business address, time zone, and default currency ready — these affect tax calculation, checkout display, and legal page content, and are annoying to change after products and settings are already built around them.
Brand Assets and Content: Prepare Everything Your Developer Will Need
In real Shopify projects, one of the biggest causes of delay isn’t development — it’s waiting on the client to provide content and brand assets. A developer can finish the technical build and then sit idle because product images, final copy, or brand files simply aren’t ready yet. Since this entire guide is about what to prepare before your developer starts, this is arguably the most underestimated section of this guide.
Logo files.
Provide your logo in SVG (scalable, ideal for web) and PNG (with transparent background), plus a separate favicon file — a developer needing to reconstruct or vectorize a logo from a low-resolution JPEG is a completely avoidable delay.
Brand colors and typography.
Exact hex codes for your brand palette and the specific font names (or licenses, if not a free/Google font) you want used — “use our brand blue” isn’t a specification a developer can implement precisely.
Product images and videos.
Final, edited photography and any product video — not placeholder images “to be swapped later,” since layout and image-handling code is frequently built around actual image dimensions and aspect ratios.
Product descriptions.
Final copy for every product, not draft text — copy length affects layout, and rewriting after a template is built often means revisiting spacing and design, not just swapping text.
Product variant matrices.
A complete mapping of product options (e.g., sizing, colorways, material variations) including SKU naming conventions and pricing deviations per variant. If your products feature complex variant relationships, this matrix must be finalized upfront so the developer can correctly build out structural filters and collection layouts.
Collection structure.
How products are grouped — this connects directly to the store architecture decisions covered in our companion guide to the full Shopify development process, and should be settled before, not during, development.
Homepage banners.
Final imagery and messaging for your homepage’s primary visual sections, sized and ready rather than “whatever stock photo works for now.”
About Us content.
Final brand story copy — this page is routinely the last one anyone writes, and routinely the one that delays a launch by itself.
Contact details.
Business email, phone number (if applicable), and physical address if you want it displayed — needed for both the contact page and, in many jurisdictions, your legal pages.
Social media links.
Final URLs for every platform you want linked in the footer or header.
A practical way to manage this: treat brand assets and content as their own project workstream running in parallel with development, with its own deadline — not an afterthought to gather “once the store is mostly built.”
Payment Gateway: What to Set Up in Advance
Shopify Payments is generally the default choice, since it avoids the extra third-party transaction fee (2.0% (Basic), 1.0% (Shopify), and 0.6% (Advanced) ) that applies when using an outside gateway. Setting it up requires business verification, and starting this process early avoids it becoming a launch-week bottleneck.
Business verification documents.
Per Shopify’s own documentation, expect to provide a government-issued photo ID, proof of business address, and — depending on your business structure — registration documents such as a business license, plus your EIN (or equivalent tax ID) and matching legal business name. For an LLC or corporation, Shopify typically requires information on individuals holding at least 25% ownership or executive roles.
Document requirements.
Shopify requires documents to be photographed (not scanned or screenshots), in color, with all four borders visible and no cropped or obscured details — submissions that don’t meet this standard are a common cause of avoidable delay. Review typically takes between 24 and 72 business hours once submitted, though some sources report it can extend to a few business days during high-volume periods.
Two-step authentication is mandatory.
Shopify requires two-step authentication to be active on your account to use Shopify Payments, specifically to help prevent misdirected payouts — enable this before you get to the payments setup step, not during it.
Currency and international payments.
Decide upfront which currencies you’ll display and settle in, since this affects both your Shopify Payments setup and any international shipping/tax logic your developer needs to configure.
Shipping: Rates, Zones, and Fulfillment Decisions
Rate model.
Flat rate (simplest, but can under- or over-charge on very light or heavy orders), calculated/carrier rates (accurate but requires a supported carrier account and, on lower plans, may need a third-party app), or free shipping above a threshold (a common conversion lever, but needs to be modeled against your margins first).
Shipping zones.
Domestic and international zones need to be explicitly defined — which countries you’ll ship to, and at what rate or restriction — before your developer configures checkout, since undefined zones typically default to blocking checkout for those regions entirely.
Fulfillment method.
Self-fulfilled (you pack and ship), third-party logistics (3PL), or dropshipping each imply different app and integration needs — a 3PL or dropshipping supplier usually requires an integration app connecting inventory and order data automatically, which needs to be scoped and accounted for in the Stage (Integrations) rather than discovered mid-build.
Legal Pages: What You Need Before Launch
A privacy policy is not optional for any store accepting payments and collecting customer data — every Shopify store does both by definition. Shopify’s built-in policy generator produces a basic starting template, but it’s a starting point, not a finished compliant document — it commonly lacks specific data retention periods, legal basis for processing under GDPR, and a full list of subprocessors (Shopify itself, your payment processor, shipping carriers), all of which are expected under GDPR’s Article 13 disclosures.
Core pages needed.
Privacy policy, terms of service, refund/return policy, and shipping policy — at minimum.
GDPR (EU customers).
Requires disclosing exactly what data is collected, the legal basis for processing it, named subprocessors, and a stated response timeframe for data requests (one month under GDPR). Cookie consent is a separate requirement from the privacy policy itself — under GDPR, non-essential tracking cookies are expected to be blocked until a customer actively opts in, which Shopify’s native cookie banner doesn’t fully handle by default.
CCPA (California customers).
Requires similar data-disclosure transparency, with a stated response timeframe of 45 days for data requests. In practice, most stores doing meaningful volume end up needing to cover both GDPR and CCPA requirements simultaneously, since customer location — not business location — determines which law applies.
Where these plug in.
Legal pages need to be linked in the footer and referenced at checkout (typically a checkbox or link near the order button) — this is a specific build requirement to brief your developer on, not just “pages that exist somewhere on the site.”
For anything beyond the basics — particularly if you sell internationally or use several tracking/marketing apps — a lawyer or a dedicated compliance tool is worth the cost; this section is meant to tell you what to prepare and ask about, not to substitute for legal advice.
Analytics: What to Set Up Before Development Begins
GA4 and conversion tracking.
Have your Google Analytics 4 property ready (or know you need one created) before development starts, so tracking can be installed and verified as part of the build rather than bolted on afterward.
Pixel access for ad platforms.
Meta Pixel, Google Ads conversion tracking, and TikTok Pixel (if relevant to your marketing plan) should be identified upfront — these are typically installed via Shopify’s native integrations or Google Tag Manager, and knowing which platforms you’ll actually use avoids installing tracking scripts for channels you never activate.
Why can’t this wait until after launch?
Analytics data from before tracking was installed can’t be recovered retroactively. If your developer builds the store first and tracking gets installed as an afterthought in week three, you’ve permanently lost visibility into your first weeks of real traffic and conversion behavior — exactly the period most useful for catching early problems.
SEO Requirements: What to Define Before the Build Starts
Target keywords and URL structure.
Decide your primary keyword targets for key collection and product pages before those pages are built, since URL handles and page structure are far more disruptive to change after launch than before.
Redirect mapping (migrations only).
If you’re moving from an existing site, a full list of current top-performing URLs mapped to their new Shopify equivalents needs to be ready before launch — this is one of the highest-risk points in a migration if left until after the new site goes live, since every day without proper redirects is a day of potential lost search rankings.
Metadata, sitemap, and structured data expectations.
Brief your developer explicitly on whether you expect custom title tags and meta descriptions per page (versus Shopify’s auto-generated defaults), and confirm Product schema markup is part of the build — Shopify doesn’t add rich product or organization schema automatically, so this needs either an app or developer implementation, and should be scoped as part of the project rather than assumed.
Integrations: Mapping Every Third-Party System in Advance
ERP, inventory, and accounting software.
List every system your business already runs on (QuickBooks, Xero, NetSuite, or similar) that needs to sync with Shopify — these integrations are frequently under-scoped at the outset, because their complexity often isn’t obvious until someone actually maps the data fields involved.
Email/SMS marketing platforms.
Klaviyo, Shopify Email, or similar — confirm which one you’re using before development, since some require specific app installation and account linking during the build.
CRM, help desk, and loyalty tools.
Any customer-facing tool beyond the storefront itself (Shopify Inbox, Gorgias, Smile.io, and similar) should be listed explicitly, even if it’s installed post-launch, so the developer knows what the store eventually needs to accommodate.
Why this matters as much as it does: undocumented integrations are one of the most common sources of mid-project cost overruns, precisely because they surface as a surprise rather than a planned line item — “oh, we also need this to talk to our warehouse system” found in week four costs far more to accommodate than the same requirement scoped in week one.
Account Access and Credentials You’ll Need to Share
Even when everything else is planned perfectly, projects frequently stall because the developer is sitting idle waiting for account access. A dedicated, consolidated list — prepared before development starts — turns this from a recurring bottleneck into a five-minute setup task.
- Shopify admin access (as a staff account, not the owner login — see below)
- Domain registrar login
- DNS access (sometimes the same as the registrar, sometimes separate if you use an external DNS provider like Cloudflare)
- Payment gateway account(s)
- Google Analytics
- Google Tag Manager
- Google Search Console
- Meta Business Manager
- Google Ads
- Email marketing platform
- ERP/CRM logins
- Shipping provider accounts
Two practices worth adopting as standard, not optional, before you hand any of this over:
Use staff accounts instead of sharing passwords wherever possible.
Shopify lets you add a staff account with scoped permissions — set exactly what a developer can see and touch, and revoke it instantly when the engagement ends, rather than sharing your owner credentials and hoping everyone remembers to change the password later. According to Shopify’s own documentation, staff members set up two-step authentication for their own individual account.
Note that critical payment actions — such as modifying bank payout routing or submitting primary corporate verification documents—remain strictly locked to the primary Store Owner identity, ensuring security even when temporary collaborator or staff permissions are granted for development work.
Enable two-factor authentication (2FA) wherever the platform supports it
Enable it not just on Shopify itself, but on your domain registrar, Google account, and payment gateway too. Shopify Plus stores can additionally require secure sign-in for all users, and Shopify’s own admin includes an activity log (Settings > Activity log) that records exactly what changed, who changed it, and when — worth checking periodically once a developer has access, simply as good practice.
Testing Checklist: What “Done” Should Mean
Define acceptance criteria in the brief itself, before development — not as a subjective judgment call after the fact. “Done” should mean a specific, agreed set of checks pass, not “looks finished to me.”
Functional testing expectations.
A complete test order using a real (test-mode) payment method, every automated email (order confirmation, shipping notification) verified to send and display correctly, and every discount code or promotional mechanism tested.
Cross-device and cross-browser expectations.
Specify which devices and browsers actually matter for your customer base (at minimum, current iOS Safari, Android Chrome, and desktop Chrome) rather than leaving “mobile-friendly” as a vague, unverifiable requirement.
Payment testing.
A full end-to-end test transaction confirming the payment gateway, tax calculation, and order confirmation all work together correctly — not just that the payment gateway is “connected.”
Who signs off, and against what.
Name the specific person responsible for final approval, and give them this same checklist as their sign-off criteria — this prevents “done” from being whoever stops finding new issues to raise, and turns it into a specific, closeable list.
Master Shopify Pre-Development Checklist
Everything above, consolidated into a single working list you can hand directly to whoever builds your store. Use it two ways: as a self-audit before your first developer conversation, and as a literal attachment to your project brief, so scope and expectations are documented in writing rather than assumed.
- Domain purchased or connected, with DNS/registrar access confirmed
- Shopify plan selected based on actual operational needs (advanced reporting, lower transaction rates, etc.)
- Logo files (SVG, PNG, favicon), brand colors, and typography specified
- Final product photography, video, and product descriptions ready
- Collection structure, homepage banners, About Us copy, and contact details finalized
- Payment gateway chosen, with business verification documents ready to submit
- Two-step authentication enabled ahead of Shopify Payments setup
- Shipping rate model, zones, and fulfillment method decided
- Privacy policy, terms of service, refund policy, and shipping policy drafted or ready to draft
- GDPR/CCPA disclosures and cookie consent approach confirmed if applicable
- GA4, Google Tag Manager, and ad platform pixels identified and access ready
- Target keywords, URL structure, and (if migrating) redirect mapping prepared
- Every third-party integration (ERP, marketing, CRM, shipping) listed explicitly
- All account access and credentials organized, using staff accounts and 2FA rather than shared owner logins
- Testing and acceptance criteria defined in writing, with a named person responsible for sign-off
If several items here feel genuinely hard to answer right now, that’s useful information in itself — it usually means the discovery and requirements-definition work covered in our companion Shopify development process guide hasn’t happened yet, and is worth doing before this checklist rather than in parallel with it.
What Happens If You Skip This Checklist
The consequences aren’t hypothetical — they follow directly from the mechanism.
Missing brand assets mean a technically finished store sitting idle for days or weeks waiting on photography and copy.
Undecided shipping rates mean a developer either guesses (and rebuilds later) or the project stalls at checkout configuration.
Missing legal pages mean either a rushed, generic policy thrown together at the last minute or a delayed launch. Analytics installed late means permanently losing visibility into your first weeks of real traffic.
Undocumented integrations discovered mid-build routinely cost more to accommodate than the same requirement scoped from day one.
None of these individually sink a project. Collectively, on a rushed brief, they’re the difference between a fixed-price quote that holds and one that turns into a stream of change orders — the same scope creep problem covered in our companion guide to hiring a Shopify developer or agency.
How This Differs From a Pre-Launch (Go-Live) Checklist
This checklist is about inputs — everything the business needs to decide and gather before development starts. A pre-launch checklist is about outputs — confirming the finished build actually works before removing the password page: functional QA, cross-device testing, analytics verification in production, and a final legal-page review, covered in full in our companion guide to the Shopify development process.
The two are sequential, not interchangeable: get this checklist right, and the pre-launch checklist becomes a genuine final check rather than the point where missing groundwork finally surfaces.
Final Verdict
Here’s the one-sentence test for whether you’re ready to brief a developer: if you can hand over this entire checklist filled out — not perfectly, but genuinely complete — on day one, you’re ready. If half of it says “we’ll figure that out later,” that’s not a reason to avoid hiring; it’s a reason to spend one more week on preparation first, because that week is dramatically cheaper than the same decisions made reactively once a Shopify development agency is already on the clock.
A well-prepared brief doesn’t just save money — it changes the entire working relationship. Developers do their best work executing a clear plan, not guessing at one. Get this checklist right, and the rest of the project — the actual development, covered stage by stage in our companion guide — becomes a matter of execution, not ongoing decision-making.
Ready to brief a developer but want a second set of eyes on your checklist first? Softhunters offers Shopify development services and project scoping support for businesses that want to start their build fully prepared.
Frequently Asked Questions
Q. What should I prepare before hiring a Shopify developer?
At minimum: your domain access, chosen Shopify plan, brand assets (logo, colors, photography, copy), a decision on payment gateway and shipping model, drafted legal pages, and a list of every third-party system that needs to integrate with the store. See the Master Checklist above for the complete list.
Q. Can my developer help me create this checklist?
A developer can advise on technical best practices and help execute decisions once you’ve made them, but the underlying business decisions — what to sell, how to price shipping, what your brand sounds like — have to come from you. Treat the developer as an implementer of decisions, not the originator of them.
Q. What happens if I don’t have legal pages ready before development starts?
Either the launch gets delayed while pages are drafted, or the store goes live with generic, incomplete policies that may not meet GDPR or CCPA disclosure requirements for your actual customer base — both outcomes are avoidable by preparing these pages, even in draft form, before development begins.
Q. Do I need analytics set up before the store is built?
Ideally yes. Analytics data from before tracking was installed can’t be recovered retroactively, so installing GA4 and any ad pixels as part of the build — rather than as a post-launch afterthought — protects your ability to see how your first weeks of real traffic actually behaved.
Q. How far in advance should I finalize my domain and hosting plan?
Before development starts. DNS changes can take up to 48 hours to fully propagate, and your Shopify plan choice affects available features (like native staff account limits or advanced analytics) that a developer may build around. Deciding these late risks either a delayed start or rework once the “final” plan turns out to be different from what was assumed.
