How E-Commerce Companies Use Software Testing

Browse + Cart — What QA Tests:

1. Product pages
   - Images load on slow networks
   - Prices shown match backend
   - Variants (size, color) work
   - Stock status accurate

2. Search + filters
   - Search returns relevant results
   - Facets (price, brand, size) work together
   - Sort is stable and consistent
   - Empty search shows helpful message

3. Pricing
   - Discounts apply correctly
   - Coupons validate and stack per rules
   - Tax calculation by region
   - Currency conversion (if international)

4. Cart
   - Add/remove updates totals
   - Cart persists on refresh
   - Guest cart merges with logged-in cart
   - Quantity limits enforced

5. Edge cases
   - Out-of-stock after add-to-cart
   - Price change after add-to-cart
   - Cart abandoned → recovery email

Tools: Playwright, Cypress (UI), pytest (unit + API).

Real Bugs Caught (during normal QA):

1. Coupon stacking bug
   - Multiple 20% coupons stacked to 40%
   - Pre-launch caught before customer abuse

2. Cart not persisting
   - Cart lost on refresh (cookie bug)
   - Would have driven cart abandonment

3. Wrong currency conversion
   - ₹ price shown to international customer
   - Would have triggered chargeback

4. Out-of-stock not updated
   - Item sold but shown in-stock
   - Would have triggered refund

5. Filter facets conflicting
   - "Size: M" + "Color: red" returned 0 results
   - Actually had 12 SKUs matching

What makes these catchable:
- Strong API tests (data layer)
- UI tests on real user journeys
- Cross-browser + mobile coverage

Checkout + Payments — What QA Tests:

1. Address
   - PIN code validation
   - Delivery time estimate accuracy
   - Address change after order placed

2. Payment methods
   - Card (Visa, Master, Amex, RuPay)
   - UPI (Google Pay, PhonePe, Paytm)
   - Netbanking (all banks)
   - Wallets (Paytm, Amazon Pay)

3. Payment flows
   - Successful payment → order confirmed
   - Failed payment → clear retry UI
   - Cancelled payment → cart preserved
   - Partial payment (COD + wallet)

4. Refunds
   - Full refund on cancellation
   - Partial refund on return
   - Refund to source account

5. Fraud checks
   - Duplicate order prevention
   - High-value order flags
   - Suspicious pattern detection

Critical bug scenarios to always test:
- Payment succeeds but order doesn't
- Order placed but payment not captured
- Refund completes but customer not notified

Payment Gateway Tests (the hard part):

1. Sandbox testing
   - Use gateway sandbox (Razorpay, Stripe)
   - Test cards for success, failure, decline
   - Simulate timeouts and network errors

2. Idempotency
   - Same payment request twice → one charge
   - Retry after timeout → no double charge
   - This is where most bugs hide

3. Webhooks
   - Gateway callback → order state updated
   - Missed webhook → order stuck
   - Duplicate webhook → double order (critical bug)

4. Reconciliation
   - Daily reconciliation: payments vs. orders
   - Discrepancies flagged automatically
   - Alerting on mismatches

5. Refunds
   - Partial refund affects totals correctly
   - Failed refund retries
   - Refund notification reaches customer

Tools: Postman, pytest, gateway sandbox,
webhook simulators, SQL for reconciliation.

Load Testing Types (E-Commerce Specific):

1. Load testing
   - Simulate normal-to-peak traffic
   - Verify response times stay acceptable
   - Test with realistic user journeys

2. Stress testing
   - Push beyond peak until it breaks
   - Find the breaking point
   - Identify what fails first

3. Spike testing
   - Sudden traffic burst
   - Simulates flash sales / viral moments
   - Tests auto-scaling and circuit breakers

4. Soak testing
   - Sustained traffic for 24-48 hrs
   - Finds memory leaks, connection pool
     exhaustion, cache issues

5. Chaos testing
   - Inject failures (kill a service)
   - Verify graceful degradation
   - Common in modern e-commerce QA

Tools:
- k6, JMeter, Locust, Gatling
- Cloud-based: BlazeMeter, LoadView

What to test:
- Homepage + search
- Product page + add-to-cart
- Checkout + payment
- Order tracking

Pre-Sale Load Test Checklist:

Two weeks before a big sale:

□ Define realistic traffic mix (browse 70%,
  search 20%, cart 8%, checkout 2%)
□ Test with actual user journeys
  (not just endpoints)
□ Verify auto-scaling rules work
□ Check database connection pools
□ Verify cache warm-up procedures
□ Test payment gateway rate limits
□ Simulate CDN behavior (static assets)
□ Confirm monitoring + alerting
□ Run rollback drills
□ Document runbook for the day

Day-of sale checklist:
□ Monitor key metrics (latency, errors)
□ On-call engineers ready
□ Kill-switch for non-critical features
□ Warm standby for critical services
□ Pre-loaded FAQ + support scripts

Reality:
- No load test fully simulates sale day
- The pattern is "test, learn, fix, retest"
- Teams that test twice win

Post-Order — What QA Tests:

1. Order tracking
   - Order status updates in real time
   - Estimated delivery remains accurate
   - Delays communicated clearly
   - Tracking link works on mobile

2. Order modifications
   - Address change before dispatch
   - Cancel before dispatch
   - Partial cancellation (one item)
   - Modify quantity before dispatch

3. Returns
   - Return request flow (with reasons)
   - Pickup scheduling
   - Refund trigger on return
   - Exchange vs. refund paths

4. Customer support
   - Help center search works
   - Chatbot responds correctly
   - Escalation to human agent
   - Ticket status tracked

Key metric:
- Time from "return requested" → refund
- If > 7 days, customer churn risk rises sharply

Notification Tests (often overlooked):

1. Order confirmation
   - Email arrives within 5 minutes
   - SMS arrives correctly
   - Content matches actual order
   - Links work

2. Shipping updates
   - "Order shipped" notification
   - "Out for delivery" notification
   - "Delivered" notification
   - Delay notifications

3. Payment-related
   - Payment success confirmation
   - Payment failure with retry link
   - Refund initiation + completion

4. Marketing
   - Cart abandonment email (after X hours)
   - Back-in-stock notifications
   - Promo reminder emails

Common bugs:
- Notification sent to wrong customer
- Duplicate notifications
- Wrong content (order A notified for B)
- Broken links
- Delays > 30 minutes

Tests:
- Send test notifications via staging
- Verify content + timing
- Check unsubscribe flow

Returns Testing:

1. Return request flow
   - Can customer request return?
   - Reasons captured correctly
   - Pickup date options work

2. Return validation
   - Return window enforced
   - Non-returnable items blocked
   - Quality checks on pickup

3. Refund trigger
   - Refund initiated on return receipt
   - Correct amount refunded
   - Refund to original payment method
   - Refund notification sent

4. Exchange flow
   - Exchange requested correctly
   - New item dispatched
   - Old item picked up
   - Difference charged/refunded

5. Fraud prevention
   - Return-to-different-address blocked
   - Repeated returners flagged
   - Warranty fraud patterns

Common bugs:
- Refund stuck in "processing"
- Wrong amount refunded
- Return window not enforced
- Exchange blocked incorrectly

Real E-Commerce QA Failures:

1. Payment double-charge
   - Retry after network error → two charges
   - Customers complained for weeks
   - Refund costs + trust loss

2. Sale-day crash
   - 50x traffic broke the checkout
   - Millions in revenue lost
   - Weeks of PR damage

3. Wrong price display
   - $99 shown for $999 product
   - Orders placed before caught
   - Forced honouring cost thousands

4. Cart merge bug
   - Guest cart overwrote account cart
   - Customers lost saved items
   - Cart abandonment spiked

5. Shipping address bug
   - "apt" in address dropped silently
   - Orders delivered to wrong place
   - Returns + customer service load

6. Mobile web checkout broken
   - Worked on desktop, broken on mobile
   - 70% of users on mobile
   - Revenue impact was immediate

What QA Missed (in each case):

1. Payment double-charge
   - Missed idempotency test
   - No retry simulation
   - No "same request twice" test

2. Sale-day crash
   - Load test at 5x, not 50x
   - No stress test to find breaking point
   - Auto-scaling not tested with
     real traffic pattern

3. Wrong price display
   - No test for decimal handling
   - No "unusual price" test case
   - Only tested with "normal" prices

4. Cart merge bug
   - No guest → logged-in merge test
   - Only tested happy path
   - No persistence edge cases

5. Address bug
   - No test with unusual addresses
   - No address normalization tests
   - Only tested with clean test data

6. Mobile checkout
   - No real device testing
   - Only tested on desktop Chrome
   - No iOS Safari testing

How to Prevent (practical):

1. Payment
   - Idempotency keys for every request
   - Test: send same request twice
   - Test: timeout → retry → verify single charge
   - Daily reconciliation between gateway and
     internal DB

2. Sale-day
   - Load test at 2x expected peak
   - Stress test to find breaking point
   - Simulate realistic traffic mix
   - Two weeks before, twice

3. Pricing
   - Test all price boundaries ($0.01, $0, $9999)
   - Test decimals + currency
   - Alerts on price mismatch between
     catalog and checkout

4. Cart
   - Test guest → login merge
   - Test persistence on refresh
   - Test concurrent sessions

5. Address
   - Test with real Indian addresses
   - Test with unusual characters
   - Verify shipping provider API contract

6. Devices
   - Real device testing (BrowserStack)
   - iOS Safari + Chrome Android
   - Slow network simulation