A store is ready to launch when a customer can find the right product, understand the offer, and pay for it, and the order that payment creates is correct. Test the shopping paths in preview. Then publish, place a real order, check what it created, refund it, and only then start sending customers. For every critical check, record the expected result, the actual result, the evidence, the owner, and the status. If pricing, tax, shipping, payment, or order recording fails, hold the launch and fix the cause.

This checklist assumes the store is already built and configured. If it isn’t, start with the complete online-store build sequence. This page is about the release: proving what works, finding what doesn’t, and making one person answerable for the go or no-go decision.

How a release works in Setka

Setka is our product, and its release sequence shapes the order of this checklist. Setka builds the whole store, including the cart and the shared shopping pages, inside the same platform that runs checkout, payments, and orders, so there is no separate theme or app layer to test against the commerce behind it. What you test in preview is what you publish.

  1. Preview. Every change creates a storefront-wide version. Record which version you are testing, run sections 1 to 3 against it, and publish only that version.
  2. Publish. Publishing makes the store reachable on your domain, and checkout starts accepting payment.
  3. Real order. Setka has no payment test mode yet, so run sections 4 to 6 on the published store with a real order you place and then refund from the Setka order.
  4. Launch. Start sending customers once no stop-ship issue remains.

If a later change breaks something, you can return to an earlier storefront version while you fix it.

Set up the test before you start clicking

Name one release owner. That person doesn’t have to run every test, but they decide whether a failed check blocks the launch and confirm that fixes were retested. Give each area to someone who understands it: catalog, storefront, payments, fulfillment, tax, and domain or search setup.

Copy the checklist below and use four statuses: not tested, pass, fail, and not applicable. “Looks fine” is not evidence. A preview URL, screenshot, screen recording, order reference, confirmation email, or a short note with the input and the observed output is. Never put full card details, passwords, or unnecessary personal data in the record.

Build a small test set that exposes real differences:

  • one typical full-price product;
  • the lowest- and highest-priced products;
  • a product with a long title or description;
  • a basket just below and just above each shipping threshold, if your rates change with order value;
  • at least two supported shipping destinations and one unsupported destination;
  • one eligible and one ineligible basket for each active promotion.

Before the live order, agree who pays, the maximum amount, and how the order will be identified. Refund it from the Setka order once the checks pass.

1. Verify product data, prices, and shopping paths

Compare the store with the catalog source, not one page against another. Confirm product names, descriptions, images, availability, prices, and any factual claims. Open several product pages, not only the most polished one. Check the lowest and highest prices on their own, because formatting and currency errors tend to show at the edges.

Then walk the navigation as tasks: “find the blue mug,” “go back to the main category,” “reach the cart from a product page.” Check the header, menu labels, category paths, footer links, the logo’s link home, and the policy and contact pages customers need before buying. A link that opens isn’t necessarily correct; check where it goes and what that page says.

Write the expected result before you record the actual one. “Selecting Ceramics opens the Ceramics category and shows the mug” is testable. “Navigation works” isn’t. If the cart or product presentation needs a deeper look, use the shopping cart UX guide rather than turning this release pass into a redesign.

2. Run a compact device matrix

Test on real phones when you can. Resizing a browser window finds obvious layout faults, but it doesn’t reproduce every keyboard, browser-bar, touch, or payment behavior. The mobile e-commerce UX checklist covers interaction detail; this matrix sets minimum launch coverage.

Device classMinimum coverageCritical observations
Small phoneCurrent iOS or Android deviceMenu, long titles, image crop, sticky actions, cart, checkout keyboard and errors
Large phoneThe other mobile operating system if availableProduct grid, quantity changes, address entry, payment return, confirmation
Laptop or desktopA current mainstream browserFull navigation, cart summary, checkout, policy links, confirmation
Second browserOne different browser engine where practicalLayout, form submission, payment hand-off, back-button behavior

On every device, follow the main path from homepage to category, product, cart, and checkout as far as preview allows, then finish it to confirmation on the published store during section 4. Rotate a phone once, increase the text size, and trigger at least one form error. Look for hidden controls, clipped text, horizontal scrolling, unusable keyboards, focus that disappears, and a checkout button covered by something else. This is a launch pass for mobile, not a full accessibility or performance audit.

3. Exercise every important cart state

Start with an empty cart. It should say that nothing is there and offer a sensible route back to products. Add one item, add a second, change a quantity, and remove each item. After every change, confirm product identity, unit price, quantity, subtotal, discount presentation, and the path to checkout.

Test refresh and the back button. Setka carts persist between visits, so leave the store, come back later, and confirm the cart still holds the same items. Try a quantity above stock or another invalid input if the interface allows it. You want a clear rejection or correction, not a broken total or a silent failure.

Record rounding and currency formatting exactly as shown. If discounts, shipping, or tax change the total later in checkout, the cart shouldn’t promise something checkout contradicts. A wrong product, price, quantity, or total is stop-ship.

4. Check live payment outcomes

Run this section after publishing, because that is when checkout accepts payment. Cover a successful payment and, where your Stripe payment methods let you do it safely, a failed payment and an abandoned one. The Stripe setup guide covers the account, currency, and payment methods; this section checks what Setka does with the result.

After a successful checkout, Setka should create a paid order, update inventory, send the customer a confirmation, and notify you. Check the order lines, quantities, discounts, shipping, tax, total, customer email, and delivery address.

After a failed payment, confirm that no paid order appears and that the customer gets a useful next step. After a canceled payment, check that the customer can tell what happened and get back to shopping. An unexpected paid status or a duplicate order isn’t something to reconcile yourself: stop, and send us the order reference at contact@getsetka.com.

5. Challenge shipping, tax, and promotions

Use addresses that cross each meaningful rule boundary: the main supported region, another supported region with a different rate, and an unsupported destination. Try postal codes or regions that are easy to confuse. Setka shipping rates depend on order value, not weight, so run your below- and above-threshold baskets to each destination, and test local pickup if you offer it. Confirm that the offered method, price, delivery wording, and eligibility match your approved shipping table. Don’t promise carrier services or delivery times you haven’t configured.

Tax needs an owner who understands the business’s actual obligations. In Setka you set tax by product type, so check one product of each type to each supported destination. Confirm that checkout says whether tax is included or added, and that rounding is consistent. This test checks the setup against a tax decision someone has already made; it doesn’t make that decision.

For each active promotion, test an eligible basket, an ineligible one, every boundary value, the schedule, any savings or per-order cap, and every combination you intend. Confirm the displayed reduction, the final total, and the customer message. If there’s no launch promotion, mark the section not applicable instead of creating one for the test.

6. Validate the domain and public discovery controls

Keep preview testing and domain testing apart. Before publishing, confirm the intended hostname, which form is primary, and who controls the domain and DNS account. After the cutover, test the root domain and the www form (in Setka you choose which is primary and how the other behaves), HTTPS, key internal links, the return from checkout, and a deliberately invalid URL. Setka issues the TLS certificate automatically, so a certificate warning after cutover points to a domain that isn’t fully connected yet; check its status in Setka. The custom-domain publishing guide covers the connection; take DNS values only from the current product screen.

Check crawl and index signals, not rankings. Confirm that public pages meant to be found load without a login, return the right page, and aren’t blocked from crawling or marked noindex by accident. Setka generates the sitemap and sets canonical tags automatically, so open the sitemap and check the canonical destination on a few key pages. Make sure no preview URL is being treated as the public store. After publishing, submit or inspect the live property in the search tools you use. The e-commerce SEO checklist covers the wider optimization work.

Stop-ship criteria: when not to launch

Don’t launch, or pause the cutover, when any of these is true:

  • a product can be bought with the wrong identity, price, quantity, currency, discount, tax, shipping charge, or total;
  • a supported customer can’t complete payment, or a failed or canceled payment leaves an ambiguous paid order;
  • a successful payment doesn’t create the expected paid Setka order, inventory update, or notifications;
  • checkout accepts a destination the business can’t serve, or rejects a supported destination that matters for launch;
  • essential legal, policy, contact, or fulfillment information is missing or materially false;
  • a critical path is unusable on a phone or browser you support at launch;
  • the public domain points to the wrong place, shows a certificate warning, or breaks the return from checkout;
  • public pages meant to be found are blocked by accident, or preview or private pages show up as canonical public pages;
  • nobody owns a failed critical check.

Minor copy or spacing defects can go to a post-launch backlog only when they don’t change a product promise, a price, a legal meaning, a navigation path, or the ability to buy. Record that decision. “We noticed it” is not a resolution.

Printable online store launch checklist

Print this section or copy it into the release record. Add an evidence link or reference for every critical pass.

Test setup

  • Release owner and go/no-go decision time are named.
  • Catalog, storefront, payment, fulfillment, tax, and domain owners are named.
  • Test products, addresses, promotion cases, devices, and browsers are listed.
  • Test-order budget, payment method, data-handling rules, and cleanup plan are agreed.
  • The exact storefront candidate or preview version is recorded.

Products, prices, and navigation

  • Representative product names, descriptions, facts, images, and availability match the catalog source.
  • Lowest, highest, full, and promotional prices display correctly with the intended currency.
  • Long titles and descriptions remain readable.
  • Homepage, header, category, product, cart, footer, policy, contact, and logo links reach the intended destinations.
  • A new visitor can complete the top three find-a-product tasks without assistance.

Mobile and browser coverage

  • Main journey passes on a small real phone.
  • Main journey passes on a large phone or second mobile operating system.
  • Main journey passes on desktop or laptop.
  • Critical checkout path passes in a second browser engine where practical.
  • Menus, images, text, forms, errors, and checkout actions remain visible and usable.
  • Rotation, increased text size, and an on-screen keyboard do not block the critical path.

Cart

  • Empty cart explains the state and offers a route back to products.
  • Add, remove, and quantity-change actions produce the expected item lines and totals.
  • Multiple items, refresh, back-button behavior, and a return visit do not corrupt the cart.
  • Invalid or unavailable quantities are rejected or corrected clearly.
  • Subtotal, discount, tax, and shipping expectations do not contradict checkout.

Checkout, payment, and order

  • Successful payment creates a paid Setka order and updates inventory.
  • Product lines, quantities, discount, shipping, tax, total, customer, and address are correct in that order.
  • Customer confirmation and merchant notification arrive with accurate facts.
  • Live test order is refunded from the Setka order.
  • Failed payment does not create an authoritative paid order and offers a useful next step.
  • Canceled payment leaves the customer in an understandable shopping state.
  • No scenario creates an unexplained duplicate paid order.

Shipping, tax, and promotion

  • Main supported address receives the approved shipping options and price.
  • Each materially different supported zone or rule boundary is tested.
  • Unsupported destination is blocked with useful language.
  • Delivery promises match the fulfillment plan.
  • Approved tax treatment passes for representative products and destinations.
  • Tax inclusion, addition, and rounding are communicated consistently.
  • Eligible, ineligible, boundary, invalid, and expired promotion cases behave as approved, where applicable.
  • Promotion totals remain consistent from cart through the paid order.

Domain, crawl, and index checks

  • Intended hostname and responsible domain/DNS owner are recorded.
  • Root and www forms behave as intended after cutover.
  • HTTPS, important internal links, checkout return, and invalid-URL behavior pass.
  • Public pages intended for discovery load without authentication.
  • Intended public pages are not accidentally blocked from crawling or indexing.
  • Canonical and sitemap destinations are checked.
  • Preview or private URLs are not presented as the canonical public store.
  • No stop-ship issue remains open; accepted minor issues have owners and due dates.

Test-order record

Use one row per attempt, including failures and cancellations. Never paste payment credentials into the record.

FieldRecord
Test ID and date/time
Tester and environment/version
Device, OS, and browser
Product(s), quantity, and expected subtotal
Promotion input and expected result
Destination and expected shipping method/rate
Expected tax treatment and amount
Expected grand total
Scenario: success, failure, or cancellation
Order reference/status
Customer confirmation evidence
Merchant notification evidence
Actual result and discrepancy
Owner, severity, and retest date
Final status: pass, fail, or accepted minor issue

Run the preview checks against the version you intend to publish, publish it, then finish the domain and payment checks before you send the first customer. Every critical item needs a recorded pass or a not-applicable decision from the release owner.

Not built yet? Start your Setka store and run this checklist against its first preview.