AI for the 10%: Fixing E-commerce Edge Cases

Most digital teams celebrate when dashboards show a 90% success rate. That’s a trap.

In e-commerce and digital services, the “last 10%” of weird, messy exceptions is where your margins disappear: stuck orders, mismatched payments, delivery retries, KYC reviews, refund loops, and those mysterious tickets that only one person in ops knows how to resolve. South African online businesses feel this sharply in December—higher volumes, more first-time buyers, more courier pressure, and far less patience for delays.

Here’s the stance I’ll defend: reliability isn’t defined by the happy path. It’s defined by how quickly and calmly you recover when the happy path breaks. That’s the difference between “we shipped features” and “customers trust us with their money.”

The source article (from a software engineering perspective) argues that top development teams obsess over exception handling, orchestration, and long-term maintainability. I agree—and for this series on How AI Is Powering E-commerce and Digital Services in South Africa, the missing link is clear: AI is becoming the practical tool that helps teams tame those exception paths without drowning in manual workarounds.

The hidden cost of “just handle it manually”

Answer first: Manual workarounds are expensive because they scale linearly with volume, they hide root causes, and they create operational risk.

Exception paths usually start as “small.” One verification step. One spreadsheet. One person who knows the trick. But that’s exactly how operational debt forms. The dashboard says 90% is fine, but the remaining 10% often consumes half the team’s time because:

• Exceptions don’t arrive evenly—they cluster during peak periods.
• Each exception needs context across systems (payments, inventory, courier, CRM).
• Humans become the “integration layer,” copying data between tools.
• Fixing one case doesn’t automatically prevent the next.

For South African e-commerce, you’ll recognise the usual suspects:

• Payment exceptions: delayed EFTs, split payments, reversals, “paid but not allocated.”
• Address quality issues: missing unit numbers, informal settlements with inconsistent formats.
• Stock and fulfilment drift: inventory says “1 left,” warehouse says “0,” oversells happen.
• Returns and refunds complexity: partial returns, courier damage, store credit vs card refund rules.
• Identity and fraud checks: legitimate customers flagged, fraudsters slipping through.

The business impact is measurable even when teams don’t track it formally:

1. SLA drag: exceptions blow up response times.
2. Support costs: ticket volume rises, and AHT (average handle time) balloons.
3. Revenue leakage: failed checkouts, cancelled orders, and goodwill refunds.
4. Team burnout: constant firefighting kills delivery capacity.

If you’re trying to grow an online store or a digital service, exception handling is not an “ops problem.” It’s a product capability.

Why orchestration matters more than another new system

Answer first: Orchestration matters because most failures happen between systems, not inside them.

A lot of modernisation projects stall because teams keep adding tools—new CRM, new helpdesk, new payment reconciliation—without fixing the connective tissue. The result is “automation islands” separated by manual steps.

Orchestration is the discipline of creating a predictable end-to-end flow across services, with clear rules for:

• what triggers the next step,
• what data must be present,
• how to detect failure,
• how to recover without human heroics.

In practice, orchestration looks like:

• An order moves from checkout → payment confirmation → stock reservation → fulfilment → courier handoff → delivery confirmation.
• If any step fails, the system doesn’t just stop. It creates a structured exception path with next-best actions.

For teams in South Africa operating with a mix of legacy and modern platforms (ERP + e-commerce platform + courier integrations + payments), orchestration is where reliability is won.

Straight-through processing is expected; recovery is where reputations are earned.

That quote from the source article nails it. Customers barely notice when everything works. They definitely notice when it doesn’t—and how quickly you fix it.

Where AI actually helps: handling the 10% at scale

Answer first: AI helps by classifying exceptions, enriching missing context, predicting outcomes, and automating next actions—without hard-coding a thousand brittle rules.

Traditional automation struggles with edge cases because edge cases are messy: unstructured text, incomplete data, ambiguous intent. That’s where AI earns its keep.

1) AI triage for ops and support tickets

If your support queue mixes “Where’s my order?” with “Payment reversed” and “Wrong item delivered,” your team wastes time just sorting.

AI can:

• Classify tickets (refund, address change, delivery issue, payment allocation).
• Detect urgency (VIP customer, high-value basket, perishable delivery window).
• Route to the right workflow (finance vs warehouse vs courier escalation).
• Summarise context from multiple systems into one view.

This is especially useful during peak seasons when volume spikes and new temporary staff join support teams. AI doesn’t replace your agents; it reduces the “find and figure out” tax.

2) Payment allocation and reconciliation

Payments are a classic exception factory. You often have partial references, inconsistent bank strings, or timing differences.

AI approaches that work well:

• Probabilistic matching (payer name + amount + time window + basket value) to suggest the most likely allocation.
• Anomaly detection to flag unusual patterns early (possible fraud or system drift).
• Natural-language extraction from remittance messages to populate missing fields.

The goal isn’t perfect autonomy on day one. The goal is “AI suggests, humans approve, the system learns.” That’s how exception volume drops over time.

3) Address validation and delivery exception prevention

South African delivery realities are complicated: variable address formats, incomplete location data, and different courier rules.

AI can help by:

• standardising addresses,
• predicting “likely undeliverable” orders before dispatch,
• prompting customers for the missing detail that matters (unit number, access instructions),
• routing high-risk deliveries to more suitable delivery options.

This is the difference between exceptions happening on day 5 (failed delivery) versus being resolved in minute 2 (checkout).

4) Fraud and trust: reducing false positives

Fraud models that are too aggressive create expensive edge cases: manual reviews, delayed fulfilment, and frustrated legitimate customers.

AI improves this when combined with orchestration:

• Use richer signals (device, behaviour, basket patterns) to reduce blunt rules.
• Create graduated responses: step-up verification instead of outright declines.
• Automate “trust building” actions (confirm identity, confirm delivery preferences) with minimal friction.

For digital services (fintech, insurance, subscriptions), this also maps directly to onboarding and KYC exceptions.

A practical blueprint: from chaos to calm operations

Answer first: The fastest way to improve reliability is to map your exception paths, instrument them, and automate the top 3 causes with AI-assisted workflows.

Most companies get this wrong by starting with a shiny AI tool. Start with your pain.

Step 1: Identify your “exception hotspots”

Pull 30–60 days of data from:

• support tickets,
• failed payment logs,
• refund reasons,
• courier exception scans,
• manual adjustment records.

Then rank exceptions by:

1. frequency,
2. average handling time,
3. customer impact,
4. financial risk.

You’ll typically find a short list that drives most pain.

Step 2: Design explicit recovery workflows

Write down the recovery path like a product flow, not an ops note:

• What’s the trigger?
• What information is required?
• What’s the next action?
• When do we escalate—and to whom?
• What do we tell the customer at each step?

If you can’t describe your recovery flow clearly, AI won’t save you. AI needs a workflow to plug into.

Step 3: Add AI where it reduces decision friction

Good AI insertion points are:

• classification and routing,
• data enrichment,
• recommended next-best action,
• risk scoring,
• automated customer updates.

Bad AI insertion points are:

• “Let the model decide everything,”
• replacing audit trails in regulated flows,
• making irreversible actions without human review early on.

Step 4: Instrument, measure, and tighten the loop

Track a small set of reliability metrics:

• Exception rate per 1,000 orders
• Mean time to recover (MTTR) for exceptions
• Manual touches per order
• Refund cycle time
• Customer contact rate (tickets per 1,000 orders)

If you want a one-liner KPI that executives understand: “How many human minutes does each order cost us after checkout?”

What “good” looks like (and why it drives growth)

Answer first: Good exception handling creates predictable operations, faster releases, and higher customer trust—because teams stop firefighting.

The source article shared an example from open banking: over £6,000 in transactions in the first 24 hours, rising to £47,000 after 72 hours, plus strong early adoption signals (including 16% of first-time depositors choosing the new method immediately). The point isn’t the currency; it’s the pattern: when architecture is clean and recovery is engineered, customers adopt quickly and operations run quietly.

For South African e-commerce and digital services, the equivalent “quiet wins” look like:

• fewer “where is my order” contacts because status updates are proactive,
• refunds processed in days, not weeks,
• fewer stockouts caused by system drift,
• support agents handling more tickets per hour with less stress,
• more time for product teams to build features that actually grow revenue.

It’s not flashy. It’s dependable. And dependable beats “fast but brittle” every quarter.

What to do next: build for the 10%, not the demo

If you’re running e-commerce operations or a digital service in South Africa, treat this as a strategy decision: will you keep paying people to patch exceptions, or will you build a system that expects exceptions and resolves them calmly?

A sensible starting plan for Q1 (right after the holiday rush) is:

1. Pick one high-pain exception flow (payments, deliveries, refunds, or KYC).
2. Map the recovery path end-to-end.
3. Add orchestration so failures trigger the right next step automatically.
4. Use AI for triage, enrichment, and recommendations—then measure MTTR.

If you want leads from your digital channels, reliability is part of your marketing. Customers don’t separate “ads” from “operations.” They remember whether you delivered.

So here’s the forward-looking question I keep coming back to for this series: as AI makes automation cheaper and faster, will your business use it to ship more happy-path features—or to finally fix the 10% that quietly sets your growth ceiling?