
Written by: Chief Technology Officer
Dmitry ReznikUpdated: 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:
The storefront displays the right product, price, and stock level.
Search or navigation helps the customer find the product.
The cart calculates quantities, promotions, tax, and shipping.
Checkout collects and validates customer information.
A payment service authorizes or declines the transaction.
The store creates one – and only one – order.
Inventory is reserved or reduced.
A warehouse or fulfillment platform receives the order.
The customer receives accurate confirmation and tracking messages.
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
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.
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
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.
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.
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.

About the author
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.