Dmitry Reznik

Written by: Chief Technology Officer

Dmitry Reznik

Updated: 13.11.2026

31 min read

An eCommerce defect rarely affects just one screen. A failed payment callback can create a paid order with an “unpaid” status. A pricing error can spread from the product page to the cart, invoice, and refund. An inventory delay can let several customers buy the last available item.

The commercial stakes are substantial. Baymard Institute calculates an average online cart abandonment rate of 70.22%. Not every abandoned cart is caused by a defect, but checkout errors, unexpected totals, broken forms, and payment failures create avoidable losses at the most valuable point in the customer journey.

Meanwhile, mobile can no longer be treated as secondary. Adobe reported that mobile devices generated 56.4% of US online revenue during the 2025 holiday season. Testing also needs to extend beyond purchase completion: the National Retail Federation estimates that 19.3% of online sales were returned in 2025.

This guide explains how to test an eCommerce website from product discovery through payment, delivery, and returns. It also includes a reusable eCommerce test plan, sample test cases, and a release checklist.

What is eCommerce testing?

eCommerce testing is the process of verifying that an online store works correctly, securely, and consistently across its customer-facing interfaces, back-office systems, and third-party integrations.

It covers more than checking whether users can open a product page and click “Buy.” A complete transaction can involve:

1.

The storefront displays the right product, price, and stock level.

2.

Search or navigation helps the customer find the product.

3.

The cart calculates quantities, promotions, tax, and shipping.

4.

Checkout collects and validates customer information.

5.

A payment service authorizes or declines the transaction.

6.

The store creates one – and only one – order.

7.

Inventory is reserved or reduced.

8.

A warehouse or fulfillment platform receives the order.

9.

The customer receives accurate confirmation and tracking messages.

10.

Refunds, cancellations, and returns update every connected system.

An eCommerce application can appear functional while this chain is already broken. For example, the customer may see a successful payment page even though the order management system never received the payment confirmation.

That is why effective eCommerce testing verifies both the visible user journey and the data exchanged among the storefront, payment provider, tax service, CRM, ERP, warehouse, shipping carrier, analytics platform, and notification services.

Why eCommerce testing matters

Testing protects several business outcomes at once:

  • Revenue: Customers must be able to find products, complete checkout, and pay without preventable interruptions.

  • Margin: Incorrect discounts, shipping fees, tax, refunds, or currency conversions can make valid orders unprofitable.

  • Customer trust: Duplicate charges and disappearing orders damage trust more severely than minor visual defects.

  • Operational accuracy: Inventory, fulfillment, and financial records must match the customer-facing order.

  • Scalability: The store must remain usable during promotions, product launches, and seasonal traffic spikes.

  • Compliance and security: Payment and personal data require appropriate technical and organizational safeguards.

  • Retention: Account, delivery, support, and return flows influence whether a customer buys again.

The most useful testing priority is therefore not “test every page equally.” It is “protect the flows where defects create the greatest financial, operational, or reputational impact.”

What to test on an eCommerce website

Product catalog and product pages

The catalog is the source of the information customers use to make buying decisions. Test:

  • Product names, descriptions, images, videos, and specifications.

  • Prices, sale prices, tax-inclusive prices, and currency formatting.

  • Size, color, configuration, subscription, and bundle variants.

  • Stock status for every variant – not only the parent product.

  • Product availability by location, customer group, or sales channel.

  • Category assignments, breadcrumbs, and related products.

  • Product URLs, canonical tags, and structured data.

  • Image zoom, galleries, and media loading on mobile devices.

  • Reviews, ratings, and moderation rules.

  • Price and inventory synchronization with ERP or inventory systems.

Pay particular attention to scheduled price changes and promotions. A campaign starting at midnight should use the intended business time zone, not necessarily the server’s time zone.

Search, filtering, and sorting

Search has to support the way customers describe products, which may not match the names used in the catalog.

Test:

  • Exact and partial product names.

  • SKU, brand, category, and attribute searches.

  • Common misspellings, synonyms, plurals, and alternative wording.

  • Search suggestions and recent searches.

  • Zero-result behavior.

  • Filters used individually and in combination.

  • Filters after changing categories or search queries.

  • Price, popularity, rating, and newest-first sorting.

  • Pagination and infinite scrolling.

  • Out-of-stock products in search results.

  • Localized searches and special characters.

  • Recently updated products and search-index synchronization.

A useful search test does not stop at “results appeared.” It verifies whether those results are relevant, available, correctly priced, and consistent with the selected filters.

Shopping cart

The cart is a calculation engine as much as it is a page. It should be tested through the UI and at the API level.

Verify that customers can:

  • Add the correct product variant.

  • Change quantity within available stock limits.

  • Remove an item or restore it when supported.

  • Save items for later.

  • Retain the cart after refreshing or reopening the browser.

  • Merge a guest cart with an existing account cart.

  • Use the cart across supported devices.

  • See updated prices when a promotion starts or expires.

  • Receive an understandable message when stock changes.

  • See accurate subtotals, discounts, tax, shipping, and totals.

Include concurrency tests. If two customers attempt to purchase the final unit, the system should follow a defined inventory-reservation rule instead of silently accepting two unfulfillable orders.

Checkout

Checkout testing should cover happy paths, validation failures, navigation behavior, and interrupted sessions.

Test:

  • Guest and registered-user checkout.

  • Prefilled customer information.

  • Required and optional fields.

  • Address validation and autocomplete.

  • Billing and shipping addresses that differ.

  • Country-, state-, and postal-code-dependent fields.

  • Available delivery methods and estimated dates.

  • Tax recalculation after an address change.

  • Order total recalculation after changing delivery.

  • Terms, consent, and marketing preferences.

  • Browser refresh, Back, and Forward actions.

  • Session expiration.

  • Recovery after losing connectivity.

  • Prevention of repeated order submission.

  • Confirmation page and confirmation messages.

Baymard’s research also estimates that large eCommerce sites could achieve an average 35.26% conversion-rate improvement through checkout design changes. That figure refers to usability improvements rather than software defects alone, but it illustrates why checkout testing should combine functional checks with usability research and analytics.

Payments

Payment testing must verify the entire payment state machine, not just the success screen.

Cover:

  • Successful authorization and capture.

  • Authorization without immediate capture.

  • Soft and hard declines.

  • Incorrect card details.

  • Expired cards and insufficient funds.

  • 3-D Secure authentication.

  • Digital wallets.

  • Buy now, pay later options.

  • Bank transfers or cryptocurrency, where supported.

  • Payment timeouts.

  • Customer cancellation on the provider’s page.

  • Delayed, missing, and duplicate webhooks.

  • Duplicate clicks on the Pay button.

  • Partial and full refunds.

  • Partial capture.

  • Voids and cancellations.

  • Currency conversion and rounding.

  • Payment success followed by order-creation failure.

  • Order creation followed by payment failure.

Every retryable payment request should have a documented idempotency rule. If a customer refreshes the page or the application retries after a timeout, the system must not create duplicate charges or orders.

Insight from a DeviQA project: For Shops, a platform for selling digital products, the QA team tested actual sandbox payment flows using Stripe test mode and BitPay Testnet rather than manually changing an order to “paid” in the admin panel. The project accumulated more than 500 end-to-end test cases and approximately 75% regression coverage. The practical lesson is simple: changing a database status does not test a payment integration. Real sandbox flows expose redirects, signatures, callbacks, timing, and status transitions that a shortcut cannot reproduce.

Customer accounts

Test registration, authentication, and account management as connected workflows:

  • Registration with valid, duplicate, and malformed details.

  • Email or phone verification.

  • Login, logout, and session expiration.

  • Password reset and expired reset links.

  • Multifactor authentication, where applicable.

  • Social login.

  • Address book management.

  • Stored payment methods.

  • Order history and invoice downloads.

  • Reordering.

  • Subscription management.

  • Account deletion and data export.

  • Access control between different customer accounts.

  • Session behavior across devices.

A user must never be able to access another customer’s addresses, invoices, orders, saved cards, or personal information by changing an identifier in a request.

Promotions, coupons, and loyalty programs

Promotional logic often produces defects because multiple rules interact.

Test:

  • Fixed and percentage discounts.

  • Product-, category-, and brand-specific offers.

  • Minimum-spend thresholds.

  • Buy-one-get-one promotions.

  • Free shipping.

  • New-customer and single-use codes.

  • Customer-segment restrictions.

  • Start and expiration times.

  • Coupon usage limits.

  • Promotion stacking and exclusions.

  • Loyalty points earned and redeemed.

  • Discounts applied before or after tax.

  • Discounts on partially returned orders.

  • Rounding in different currencies.

  • Removing a product that made the cart eligible.

Include negative scenarios. A valid code should be rejected when its product, customer, date, location, or order-value conditions are not met – and the message should explain why.

Shipping, delivery, and returns

The customer journey does not end when the payment succeeds.

Test:

  • Shipping rates by destination, weight, value, and delivery method.

  • Delivery restrictions for particular products or regions.

  • Multiple warehouses and split shipments.

  • Store pickup and collection points.

  • Estimated delivery dates.

  • Label creation.

  • Carrier integration failures.

  • Tracking-number generation and updates.

  • Partial shipment.

  • Customer and merchant cancellation.

  • Lost or failed delivery statuses.

  • Return eligibility and return windows.

  • Full and partial returns.

  • Exchanges.

  • Refunds to the original or alternative payment method.

  • Inventory updates after returns.

  • Return fraud controls.

  • Customer notifications at every relevant stage.

According to the NRF, retailers expected 15.8% of total sales and 19.3% of online sales to be returned in 2025. Returns therefore deserve their own end-to-end scenarios rather than one basic refund test.

Insight from a DeviQA project: Soapbox supports multi-storefront inventory, order processing, warehousing, and shipping. DeviQA created more than 2,500 test cases and automation scripts, pushed documented coverage above 90%, and reduced regression testing from approximately one and a half weeks to three days. In fulfillment-heavy products, organizing tests around order states and integration boundaries is more maintainable than organizing them only by UI pages.

Mobile storefronts and applications

Test responsive websites and native applications on representative real devices, operating systems, screen sizes, and network conditions. Cover touch interaction, keyboard behavior, rotation, deep links, app interruptions, biometric authentication, and mobile wallets.

Mobile tests should include the complete purchasing journey. A responsive home page is not meaningful if an address form is hidden by the keyboard or a payment redirect cannot return the user to the app.

For a more detailed process, see our guide on how to test mobile applications.

Admin, analytics, and back-office workflows

Many customer-facing failures begin in administrative systems.

Verify:

  • Product and variant creation.

  • Bulk imports.

  • Price and inventory updates.

  • Promotion configuration.

  • Order editing and cancellation.

  • Manual refund permissions.

  • Role-based access.

  • Audit logs.

  • Fraud-review queues.

  • Customer-support actions.

  • Analytics events and revenue attribution.

  • Consent-dependent tracking.

  • ERP, CRM, tax, and warehouse synchronization.

Analytics should be treated as a testable product feature. A successful order that is recorded twice in analytics can distort revenue, campaign attribution, and conversion data even when the customer sees no error.

Types of testing for eCommerce

Testing type
What it verifies
Typical eCommerce example

Functional testing

Features behave according to requirements

A coupon reduces only eligible items

Integration and API testing

Connected systems exchange correct data

A payment webhook updates the order once

End-to-end testing

A business journey works across all systems

Search → cart → payment → fulfillment

Usability testing

Customers can understand and complete tasks

A guest can complete checkout without confusion

Compatibility testing

The store works across supported environments

Checkout works in Safari, Chrome, and mobile browsers

Mobile testing

Mobile web and native app behavior

A wallet payment returns the user to the app

Performance testing

The system meets speed and capacity targets

Checkout remains responsive during a flash sale

Security testing

Data and transactions are protected

One customer cannot access another customer’s order

Accessibility testing

People using assistive technologies can shop

Checkout works by keyboard and with a screen reader

Localization testing

Language, currency, tax, and regional rules work

A French price and address are formatted correctly

Regression testing

Existing features still work after a change

A shipping update does not break promotions

Recovery testing

The system handles failures without corrupting data

An interrupted payment can be reconciled safely

Data testing

Records remain accurate across databases and reports

Order, stock, payment, and invoice totals match

How to test an eCommerce website step by step

1. Map the transaction ecosystem

Document the customer journey and every system it touches. Include the storefront, commerce engine, payment providers, tax service, fraud platform, inventory, ERP, CRM, fulfillment, carriers, email, analytics, and customer support tools.

This reveals failure points that page-by-page testing often misses.

2. Rank journeys by business risk

Prioritize scenarios using four factors:

  • Revenue impact.

  • Frequency of use.

  • Probability of failure.

  • Difficulty of recovery.

Payment completion, order creation, inventory reservation, refunds, and promotion calculations will usually rank above cosmetic account-page issues.

3. Define supported configurations

Create a matrix covering:

  • Browsers and browser versions.

  • Mobile devices and operating systems.

  • Countries and languages.

  • Currencies.

  • Customer types.

  • Payment methods.

  • Shipping methods.

  • Product types.

  • Tax scenarios.

Base the matrix on production analytics and target markets – not on an arbitrary list of every possible configuration.

4. Prepare realistic test data

Create reusable data for:

  • Guest and registered customers.

  • New and returning customers.

  • Taxable and tax-exempt customers.

  • Domestic and international addresses.

  • In-stock, low-stock, and out-of-stock products.

  • Physical, digital, subscription, and restricted products.

  • Valid, expired, and limited coupons.

  • Successful, declined, disputed, and refunded payments.

  • Single- and multi-warehouse orders.

Test data should be synthetic or properly protected. Production payment and personal data should not be copied casually into lower environments.

5. Test individual functions and integrations

Validate calculations and business rules at the API or service level before relying on long UI scenarios. A tax, price, or inventory rule can usually be tested more quickly and precisely below the interface.

Then test contracts with third parties: request formats, authentication, error handling, retries, timeouts, webhooks, and reconciliation.

6. Test critical journeys end to end

Run complete scenarios that prove the systems work together. At minimum, include:

  • Guest purchase.

  • Registered-user purchase.

  • Promotion and free-shipping order.

  • Mobile purchase.

  • Declined payment followed by a successful retry.

  • Partial shipment.

  • Cancellation before fulfillment.

  • Partial refund.

  • Return and inventory restocking.

7. Add non-functional testing

Run compatibility, accessibility, security, and performance tests against the journeys that matter most. A page can be functionally correct and still unusable on a mobile device, too slow during peak traffic, or vulnerable to unauthorized access.

8. Automate the stable regression layer

Automate high-value, repeatable checks such as:

  • Core API contracts.

  • Price and promotion rules.

  • Cart calculations.

  • Checkout smoke tests.

  • Payment sandbox scenarios.

  • Order-state transitions.

  • Critical browser journeys.

Keep exploratory testing for new features, unusual combinations, usability concerns, and poorly understood risks.

9. Validate production safely

After deployment, run a limited smoke suite using production-safe accounts and payment methods. Confirm monitoring, analytics, alerts, scheduled jobs, and integration queues.

Production testing should never create uncontrolled orders, contact real customers unexpectedly, or corrupt live inventory.

eCommerce test plan template

An eCommerce test plan describes what will be tested, how it will be tested, who is responsible, and what conditions must be met before release.

A useful plan should contain the following sections.

1. Objective

State the business outcome the release must protect.

Example: Verify that the redesigned checkout supports guest and registered purchases in the US, Canada, and the UK without incorrect totals, duplicate orders, or lost payments.

2. Scope

List the features, platforms, integrations, and regions included in testing.

Also record what is excluded. For example, a checkout release may include cards and digital wallets but exclude an upcoming BNPL integration.

3. System and integration map

Document every relevant dependency:

  • Storefront.

  • Commerce backend.

  • Product information system.

  • Inventory or ERP.

  • Payment provider.

  • Tax service.

  • Fraud solution.

  • Warehouse platform.

  • Shipping carriers.

  • CRM and email.

  • Analytics.

4. Risk assessment

Rank risks by probability and impact.

Risk
Probability
Impact
Testing response

Duplicate charge after retry

Medium

Critical

Idempotency, timeout, retry, and webhook tests

Incorrect promotion stacking

High

High

Rule-combination and boundary tests

Inventory overselling

Medium

High

Concurrent purchase and reservation tests

Carrier API unavailable

Medium

Medium

Fallback, retry, and error-message tests

Mobile checkout layout breaks

Medium

High

Real-device tests on top configurations

5. Test environment

Specify URLs, builds, databases, integrations, feature flags, and sandbox accounts. Record which services are real sandboxes and which are mocked.

A staging environment that bypasses payments, taxes, or inventory cannot provide complete end-to-end evidence.

6. Test data

List required users, products, addresses, coupons, cards, currencies, and order states. Assign responsibility for creating and resetting data.

7. Test coverage

Define the required test types:

  • Functional.

  • API and integration.

  • End-to-end.

  • Regression.

  • Compatibility.

  • Mobile.

  • Performance.

  • Security.

  • Accessibility.

  • Localization.

  • Recovery.

8. Browser and device matrix

Use production traffic data to define primary and secondary configurations. Critical checkout smoke tests should run on every primary configuration.

9. Automation scope

Specify which tests run:

  • On every pull request.

  • After deployment to test environments.

  • Nightly.

  • Before release.

  • After production deployment.

Avoid setting automation targets based only on the percentage of test cases. Automate according to risk, repeatability, execution frequency, and maintenance cost.

10. Roles and responsibilities

Identify who approves requirements, prepares data, executes tests, investigates failures, fixes defects, and makes the release decision.

11. Entry and exit criteria

Possible entry criteria:

  • Requirements and designs are approved.

  • The build is deployed successfully.

  • Required integrations are available.

  • Test data and sandbox accounts are ready.

  • Unit and component checks pass.

Possible exit criteria:

  • Critical journeys pass on primary configurations.

  • No unresolved blocker or critical defects remain.

  • Payment and order records reconcile.

  • Performance targets are met.

  • Security findings are assessed.

  • Known risks are documented and accepted.

  • Rollback and monitoring are ready.

12. Metrics and reporting

Track metrics that help release decisions:

  • Pass rate for critical journeys.

  • Defects by severity and business area.

  • Escaped defects.

  • Payment success and failure distribution.

  • Order-to-payment mismatches.

  • Regression duration.

  • Automated-check stability.

  • Response times and error rates.

  • Coverage by risk rather than test count alone.

Compact eCommerce test plan example

Plan element
Example

Release

Checkout redesign and second payment provider

Main objective

Complete purchases without lost or duplicate orders

In scope

Cart, checkout, cards, wallet payments, tax, shipping, confirmation

Out of scope

Loyalty redesign and marketplace seller portal

Primary risks

Duplicate charge, wrong tax, broken mobile form, missing webhook

Environments

Staging with payment, tax, email, and fulfillment sandboxes

Configurations

Chrome, Safari, Firefox; iOS and Android primary devices

Required suites

API, functional, E2E, compatibility, accessibility, performance

Release gate

All critical scenarios pass; no unresolved critical defects

Production check

One controlled purchase, refund, monitoring, and analytics validation

Sample eCommerce test cases

The following examples show the level of detail needed for the most important cart, checkout, and payment scenarios.

ID
Area
Scenario and steps
Expected result
Priority

EC-CART-01

Cart

Add an in-stock product with a selected size and color

Correct variant, price, image, and quantity appear in the cart

High

EC-CART-02

Cart

Increase quantity beyond available stock

Quantity is limited and a clear availability message appears

High

EC-CART-03

Cart

Change quantity from one to three

Subtotal, tax estimate, and promotion are recalculated correctly

High

EC-CART-04

Cart

Add items as a guest, sign in, and continue shopping

Cart follows the defined merge rule without losing or duplicating items

High

EC-CART-05

Promotion

Apply an expired coupon

Discount is not applied and the reason is explained

Medium

EC-CART-06

Promotion

Remove the item that made the order eligible for a discount

Discount and order total are recalculated

High

EC-CHK-01

Checkout

Complete checkout without creating an account

Order is created and confirmation is sent to the guest email

Critical

EC-CHK-02

Checkout

Enter an invalid postal code for the selected country

The address is rejected before payment with an actionable message

High

EC-CHK-03

Checkout

Change from standard to express delivery

Shipping fee, tax, total, and estimated delivery date update

High

EC-CHK-04

Checkout

Refresh the page before submitting payment

Entered data is retained or restored according to requirements

Medium

EC-PAY-01

Payment

Complete a successful card payment with 3-D Secure

One charge and one order are created; statuses and totals match

Critical

EC-PAY-02

Payment

Use a card configured to return a decline

No order is confirmed as paid; the customer can retry safely

Critical

EC-PAY-03

Payment

Simulate a timeout after the provider receives the request

The system checks the payment state before retrying and prevents duplicate charges

Critical

EC-PAY-04

Payment

Click Pay repeatedly or submit duplicate requests

Idempotency protection creates no more than one charge and one order

Critical

EC-PAY-05

Payment

Delay the successful payment webhook

The order enters a recoverable pending state and updates when the webhook arrives

Critical

EC-PAY-06

Refund

Partially refund one item from a multi-item order

Correct amount is refunded; order, payment, inventory, and invoice records agree

Critical

EC-ORD-01

Inventory

Two users purchase the final available unit concurrently

The defined reservation rule is enforced; overselling does not occur

Critical

EC-ORD-02

Fulfillment

Carrier API becomes unavailable during label creation

The order remains recoverable; retry and operational alerts work

High

eCommerce testing checklist

This checklist is formatted so it can be copied into a spreadsheet and extended with Owner, Status, Evidence, and Defect ID columns.

Catalog and search

  • Product names, descriptions, media, and specifications are accurate.

  • Every variant shows the correct SKU, price, and stock status.

  • Scheduled prices start and end in the correct time zone.

  • Categories and breadcrumbs are correct.

  • Search supports relevant names, SKUs, brands, synonyms, and misspellings.

  • Filters work individually and in combination.

  • Sorting produces the correct order.

  • Zero-result behavior is useful.

  • Search indexes reflect recent catalog changes.

  • Product links and structured data are valid.

Cart and promotions

  • Products can be added, updated, and removed.

  • The selected variant remains correct.

  • Quantity cannot exceed allowed stock or purchase limits.

  • Guest and authenticated carts follow the defined merge rule.

  • The cart persists for the required period.

  • Prices and totals update after catalog changes.

  • Valid discounts are calculated correctly.

  • Ineligible, expired, and overused codes are rejected.

  • Promotion stacking and exclusions work.

  • Tax, shipping, discount, and total rounding are correct.

Checkout

  • Guest checkout works.

  • Registered checkout works.

  • Required fields are clearly identified.

  • Address validation works by country.

  • Billing and shipping addresses can differ.

  • Available delivery methods are correct.

  • Tax and totals update after address or shipping changes.

  • Refresh and browser navigation do not corrupt the session.

  • Session expiration is handled clearly.

  • The order cannot be submitted twice.

Payments

  • Successful payments create one paid order.

  • Declined payments do not create a paid order.

  • 3-D Secure flows work.

  • Wallet and alternative payment flows work.

  • Payment cancellation returns the customer safely.

  • Timeouts produce a recoverable state.

  • Duplicate requests are idempotent.

  • Delayed and duplicate webhooks are handled correctly.

  • Payment, order, and invoice amounts match.

  • Full and partial refunds work.

  • Refund failures are visible to operations.

  • Reconciliation can identify inconsistent states.

Accounts and security

  • Registration and verification work.

  • Login, logout, and password reset work.

  • Sessions expire according to policy.

  • Customers cannot access other users’ data.

  • Admin permissions follow role requirements.

  • Sensitive values are not exposed in URLs, logs, or analytics.

  • Rate limits and abuse controls are tested.

  • Consent and privacy preferences are respected.

  • Account deletion and data export work where required.

Delivery and returns

  • Shipping rates and delivery estimates are correct.

  • Restricted products cannot be shipped to unsupported locations.

  • Split shipments are represented correctly.

  • Tracking links and notifications work.

  • Partial and complete cancellations work.

  • Return eligibility and windows are enforced.

  • Exchanges and partial returns work.

  • Refund and inventory records update after a return.

  • Failed fulfillment integrations can be retried.

  • Customer, warehouse, and support views show consistent order status.

Mobile, compatibility, and accessibility

  • Critical journeys work on primary browsers.

  • The site works on representative iOS and Android devices.

  • Forms remain usable with the mobile keyboard open.

  • Orientation changes do not lose data.

  • Payment redirects and app deep links return correctly.

  • Core flows work with keyboard navigation.

  • Controls have accessible names and visible focus states.

  • Error messages are announced and linked to the relevant fields.

  • Text and controls meet required contrast and size expectations.

Performance and reliability

  • Product, search, cart, and checkout performance targets are defined.

  • Expected and peak traffic models are tested.

  • Inventory and promotion services are tested under concurrency.

  • Third-party delays are included in performance scenarios.

  • Autoscaling and queue behavior are verified.

  • The system degrades safely when a dependency fails.

  • Monitoring covers errors, latency, payments, orders, and queues.

  • Alerts reach the responsible team.

  • Recovery and rollback procedures are tested.

Release readiness

  • Critical regression scenarios pass.

  • No unresolved blocker or critical defects remain.

  • Payment and order data reconcile.

  • Production configuration has been reviewed.

  • Feature flags have the intended values.

  • Analytics and conversion events are validated.

  • Support and operations teams know the release risks.

  • Production smoke tests are prepared.

  • Rollback criteria are agreed.

  • Post-release monitoring has an assigned owner.

eCommerce testing tools

A toolset should cover different layers. One large UI suite is not a substitute for API, performance, security, accessibility, and observability checks.

Tool
Primary use
Best fit in eCommerce testing

Browser automation

Cross-browser checkout and account journeys

Web application automation

Fast storefront and component feedback

Browser automation

Mature cross-browser ecosystems and broad language support

Mobile automation

Native and hybrid shopping applications

API testing

Catalog, cart, order, payment, and webhook APIs

Performance testing

Code-based load scenarios for APIs and services

Load and protocol testing

Complex traffic models and established performance suites

Device and browser cloud

Compatibility testing at scale

Web security testing

Automated security checks in delivery pipelines

Accessibility automation

Detecting common accessibility violations

Payment-provider sandboxes

Integration testing

Declines, 3-D Secure, webhooks, refunds, and disputes

Datadog, Grafana, or similar observability tools

Monitoring and diagnostics

Correlating errors, latency, orders, and infrastructure behavior

Choose tools based on architecture, team skills, supported platforms, integration capabilities, and maintenance cost. The strongest setup usually combines service-level checks with a smaller number of critical end-to-end tests.

Common eCommerce testing challenges

1. Peak traffic and promotion events

Black Friday traffic is not simply “normal traffic multiplied by ten.” Customer behavior changes during major campaigns:

  • More users arrive within a short period.

  • A small set of discounted products receives disproportionate demand.

  • Search and recommendation traffic changes.

  • Customers refresh stock and prices repeatedly.

  • Promotions require additional calculations.

  • Payment, fraud, and shipping providers may also be under load.

Adobe measured a record $257.8 billion in US online spending during the 2025 holiday season. Testing for events of this scale should model business transactions – searches, cart updates, checkouts, payments, and inventory reservations – not only page requests.

Performance tests should answer:

  • How many successful orders per minute can the system process?

  • Where does latency begin to increase?

  • Does autoscaling respond quickly enough?

  • Can inventory stay consistent under concurrency?

  • What happens when a payment or tax provider slows down?

  • Can queues recover after the traffic peak?

  • Do customers receive honest status information during degradation?

2. Payment integrations

Payments are asynchronous, security-sensitive, and dependent on external systems. The browser may show one state while a webhook, order service, and payment provider each hold another.

Design payment testing around explicit states such as:

  • Created.

  • Pending.

  • Authorized.

  • Captured.

  • Declined.

  • Cancelled.

  • Partially refunded.

  • Refunded.

  • Disputed.

  • Unknown or awaiting reconciliation.

Insight from a DeviQA project: On the ChargeAfter point-of-sale financing platform, DeviQA built more than 4,000 automated UI and API tests and reached 90% application coverage. Regression that had taken two weeks was reduced to an overnight run. The suite included multiple integrations and parallel execution because the business flow connected shoppers, retailers, and lenders in real time. For payment products, API coverage and integration-specific scenarios are essential; UI tests alone cannot isolate failures quickly enough.

3. PCI DSS and payment-page security

PCI DSS compliance is broader than software testing, and passing functional or security tests does not itself establish compliance. However, testing provides evidence that required controls operate as intended.

PCI DSS requirements 6.4.3 and 11.6.1 address the management of payment-page scripts and mechanisms for detecting unauthorized changes. The PCI Security Standards Council published dedicated payment-page security and e-skimming guidance in 2025.

For eCommerce teams, relevant checks include:

  • Only authorized scripts load on payment pages.

  • Script integrity and change controls work.

  • Security headers are configured correctly.

  • Payment pages are monitored for unauthorized modification.

  • Sensitive authentication data is not stored.

  • Logs do not expose card data.

  • Access to payment-related administration is restricted.

  • Third-party scripts are inventoried and reviewed.

Use the applicable PCI DSS scope and guidance agreed with qualified compliance specialists. Do not infer compliance from a vulnerability scan alone.

4. Inventory and order consistency

Inventory errors often occur when services update at different speeds. Test:

  • Reservations before and after payment.

  • Reservation expiration.

  • Concurrent purchases.

  • Cancellation and inventory release.

  • Partial fulfillment.

  • Backorders and preorders.

  • Returns and restocking.

  • Multiple storefronts sharing one inventory pool.

  • Warehouse synchronization delays.

  • Manual order edits.

The most important assertion is often not what appears on one screen, but whether the storefront, inventory service, order system, warehouse, and customer messages eventually agree.

5. Third-party dependencies

Tax, payment, fraud, shipping, address, and notification services can fail independently.

For every important dependency, define:

  • Timeout behavior.

  • Retry policy.

  • Idempotency rules.

  • Circuit-breaker or fallback behavior.

  • Customer-facing message.

  • Operational alert.

  • Reconciliation process.

  • Manual recovery procedure.

Mocks help reproduce rare errors, but they should complement – not replace – periodic testing against real provider sandboxes.

6. Localization and regional rules

Localization changes more than visible text. It affects addresses, names, currencies, taxes, time zones, payment methods, shipping, units, and legal consent.

In the DeviQA Shops project, the test scope covered five localizations, more than five platforms, three browsers, and real iOS and Android devices. This kind of matrix should be risk-based: not every combination requires the same depth, but every supported market needs evidence that its critical purchase path works.

7. Test data and environment limitations

An environment may be available while still being unfit for testing. Common problems include outdated catalog data, disabled webhooks, unrealistic stock, shared accounts, missing regional settings, or sandboxes that behave differently from production.

Record these limitations in the test plan. If a critical behavior cannot be tested before release, it is a known business risk – not an implicit pass.

Practical release gates for an eCommerce application

A release decision should use evidence tied to business risk. Typical gates include:

  • All critical purchase and refund journeys pass.

  • No open blocker or critical defect remains.

  • Payment totals, order records, and invoices reconcile.

  • Primary browser and mobile configurations pass smoke testing.

  • Performance meets agreed transaction and latency targets.

  • Security findings are reviewed and assigned.

  • Analytics events are accurate and not duplicated.

  • Monitoring covers the new or changed functionality.

  • Rollback is possible and has a clear trigger.

  • Operations and customer support understand known limitations.

Teams can adjust these gates by release type. A catalog-copy update does not require the same evidence as a new payment provider, but neither should be released without appropriate checks.

When to use specialized eCommerce testing support

A dedicated QA partner can help when:

  • Checkout or payment defects repeatedly reach production.

  • Releases require long manual regression cycles.

  • The store is entering new markets or adding payment methods.

  • Mobile coverage is inconsistent.

  • A major traffic event is approaching.

  • Integrations make failures difficult to diagnose.

  • The internal team lacks automation, performance, or security expertise.

  • There is no clear test plan or release-quality threshold.

DeviQA’s ecommerce testing services cover web, mobile, API, payment, integration, compatibility, security, and peak-load testing for online commerce platforms.

See what's possible for your QA

Frequently asked questions

What is eCommerce testing?

eCommerce testing verifies that an online store and its connected systems work correctly, securely, and reliably. It covers catalog browsing, search, cart, checkout, payments, accounts, inventory, fulfillment, shipping, returns, mobile experiences, and third-party integrations.

How do you test an eCommerce website?

Start by mapping the purchase and fulfillment journey, identifying high-risk integrations, and creating representative test data. Test business rules and APIs first, then run complete customer journeys. Add compatibility, mobile, accessibility, security, and performance testing before validating the production deployment.

What should be tested first?

Begin with the flows that can directly lose money or customer trust: cart totals, checkout, payments, order creation, inventory reservation, fulfillment handoff, cancellations, and refunds. Search and account access are also high-priority because they affect product discovery and customer data.

What should an eCommerce test plan include?

It should define objectives, scope, risks, integrations, environments, test data, browser and device coverage, test types, automation, responsibilities, entry and exit criteria, schedule, and reporting metrics. It should also document what is not covered.

What are common test cases for eCommerce websites?

Common cases include adding and updating cart items, applying promotions, completing guest checkout, calculating tax and shipping, handling declined or timed-out payments, preventing duplicate charges, synchronizing inventory, processing partial shipments, and issuing full or partial refunds.

Can eCommerce testing be automated?

Yes. API contracts, cart calculations, payment sandbox flows, order-state transitions, smoke tests, and stable regression journeys are strong automation candidates. Exploratory, usability, and newly developed features still benefit from human testing.

How often should eCommerce regression testing run?

Fast smoke and API suites can run on every relevant change. Broader regression can run nightly and before release. A production-safe smoke suite should run after deployment. The schedule should reflect release frequency and business risk.

How do you test an eCommerce website for peak traffic?

Build a workload model based on real customer behavior and forecasted events. Test browsing, search, cart, checkout, payment, and inventory traffic together. Measure response times, throughput, error rates, resource use, queue depth, successful orders, and recovery after the peak.

Does eCommerce testing ensure PCI DSS compliance?

No. Testing can verify security controls and provide supporting evidence, but PCI DSS compliance depends on the organization’s full technical and operational scope. Compliance requirements should be interpreted with qualified specialists.

Should returns be included in eCommerce testing?

Yes. Returns affect refunds, inventory, accounting, fraud controls, logistics, notifications, and customer retention. Test complete and partial returns, exchanges, failed refunds, restocking, return eligibility, and consistency among all connected systems.

Dmitry Reznik

About the author

Dmitry Reznik

Chief Technology Officer

Dmitry Reznik is the Chief Technology Officer and co-founder at DeviQA, bringing deep technical expertise across software architecture, implementation, and long-term system operation.