---
id: wiki-2026-0508-e-commerce-optimization
title: E-commerce Optimization
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [CRO, conversion rate optimization, ecommerce growth, funnel optimization]
duplicate_of: none
source_trust_level: A
confidence_score: 0.95
verification_status: applied
tags: [ecommerce, conversion, optimization, growth-hacking, ab-testing, cro, ux]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: Python / TypeScript
  framework: GA4 / Mixpanel / Optimizely / VWO
---

# E-commerce Optimization

## 매 한 줄
> **"매 funnel 의 매 step 의 conversion 의 increase"**. 매 visitor → cart → checkout → purchase → repeat 의 매 leakage 의 fix. 매 modern: 매 ML personalization + 매 A/B + 매 LLM (review summary, search). 매 metric: CVR, AOV, LTV.

## 매 핵심

### 매 funnel
1. **Acquisition**: 매 ad → land.
2. **Engagement**: 매 product browse.
3. **Conversion**: 매 add to cart → checkout.
4. **Retention**: 매 repeat purchase.
5. **Advocacy**: 매 review / referral.

### 매 key metric
- **CVR** (Conversion Rate): 매 purchase / visit.
- **AOV** (Average Order Value).
- **LTV** (Lifetime Value).
- **CAC** (Customer Acquisition Cost).
- **Cart abandonment rate**.
- **Repeat rate**.

### 매 lever
- **UX**: 매 PDP, search, navigation.
- **Pricing**: 매 dynamic + bundle.
- **Personalization**: 매 reco + DCO.
- **Trust**: 매 review + social proof.
- **Speed**: 매 Core Web Vitals.
- **Promotion**: 매 discount + urgency.

### 매 modern AI
- **Reco**: 매 sequence + transformer.
- **Visual search**: 매 CLIP-based.
- **Review summary**: 매 LLM.
- **Chat**: 매 product question.
- **Smart bundle**: 매 ML 의 affinity.

### 매 응용
1. **DTC brand**: 매 owned channel.
2. **Marketplace**: 매 search + reco.
3. **Subscription**: 매 churn + upsell.
4. **Luxury**: 매 service + AOV.
5. **B2B**: 매 quote + repeat.

## 💻 패턴

### Funnel analytics
```python
import pandas as pd

def funnel_drop(events_df):
    steps = ['view_landing', 'view_product', 'add_to_cart', 'checkout', 'purchase']
    counts = []
    user_set = None
    for step in steps:
        users = set(events_df[events_df.event == step].user_id)
        if user_set is None: user_set = users
        else: user_set = user_set & users
        counts.append((step, len(user_set)))
    
    drops = []
    for i in range(1, len(counts)):
        drop = 1 - counts[i][1] / counts[i-1][1]
        drops.append((counts[i-1][0], counts[i][0], drop))
    return pd.DataFrame(drops, columns=['from', 'to', 'drop_rate'])
```

### A/B test (CUPED-adjusted)
```python
import numpy as np
from scipy import stats

def cuped_test(control, treatment, control_pre, treatment_pre):
    """매 pre-experiment covariate 의 variance 의 reduce."""
    pre = np.concatenate([control_pre, treatment_pre])
    post = np.concatenate([control, treatment])
    theta = np.cov(pre, post)[0, 1] / np.var(pre)
    
    c_adj = control - theta * (control_pre - pre.mean())
    t_adj = treatment - theta * (treatment_pre - pre.mean())
    return stats.ttest_ind(c_adj, t_adj)
```

### Cart abandonment recovery
```python
def abandoned_cart_email(user, cart, hours_since=2):
    if cart.total < 50: return None  # 매 ROI gate
    
    discount = compute_personalized_discount(user, cart)
    return {
        'subject': f'Still thinking about your {cart.items[0].name}?',
        'discount': discount,
        'expires': now() + timedelta(hours=24),
        'urgency': cart.items[0].inventory < 10,
    }
```

### Recommender (collaborative filtering)
```python
import numpy as np

def item_item_cf(user_item, target_item, k=20):
    """매 cosine similarity 의 매 item 의 closest k."""
    item_vec = user_item[:, target_item]
    sims = []
    for j in range(user_item.shape[1]):
        if j == target_item: continue
        sim = np.dot(item_vec, user_item[:, j]) / (
            np.linalg.norm(item_vec) * np.linalg.norm(user_item[:, j]) + 1e-9
        )
        sims.append((j, sim))
    return sorted(sims, key=lambda x: -x[1])[:k]
```

### Personalized search ranking
```python
def rerank(query_results, user):
    scored = []
    for item in query_results:
        base = item.relevance_score
        affinity = predict_affinity(user, item)  # 매 ML
        margin = item.margin
        
        score = 0.6 * base + 0.3 * affinity + 0.1 * margin
        scored.append((item, score))
    return [i for i, _ in sorted(scored, key=lambda x: -x[1])]
```

### Review summarization (LLM)
```python
def summarize_reviews(reviews, n_pros=3, n_cons=3):
    prompt = f"""Summarize the {len(reviews)} customer reviews below.
Output JSON with {n_pros} pros and {n_cons} cons (one short phrase each).
Reviews:
{format_reviews(reviews)}"""
    return llm.generate(prompt)
```

### Bundle pricing (cross-sell)
```python
def bundle_recommend(cart, catalog, threshold=0.7):
    # 매 affinity from co-purchase data
    last_item = cart.items[-1]
    candidates = [(c, affinity(last_item, c)) for c in catalog if c.id != last_item.id]
    candidates.sort(key=lambda x: -x[1])
    
    bundles = []
    for c, score in candidates[:5]:
        if score > threshold:
            bundle_price = (last_item.price + c.price) * 0.9
            bundles.append({'item': c, 'bundle_price': bundle_price, 'savings': last_item.price + c.price - bundle_price})
    return bundles
```

### LTV prediction
```python
import xgboost as xgb

def predict_ltv(user_features):
    """매 first 30-day signal → 매 12-month LTV."""
    model = xgb.XGBRegressor(n_estimators=300, max_depth=6).fit(X_train, y_train)
    return model.predict(user_features.reshape(1, -1))[0]
```

### Cohort retention
```python
def retention_curve(orders_df):
    orders_df['cohort_month'] = orders_df.groupby('user_id').order_date.transform('min').dt.to_period('M')
    orders_df['order_month'] = orders_df.order_date.dt.to_period('M')
    orders_df['period'] = (orders_df.order_month - orders_df.cohort_month).apply(lambda x: x.n)
    
    cohort = orders_df.groupby(['cohort_month', 'period']).user_id.nunique().reset_index()
    return cohort.pivot(index='cohort_month', columns='period', values='user_id')
```

### Page speed (Core Web Vitals)
```javascript
// 매 client-side measure
import { onLCP, onINP, onCLS } from 'web-vitals';
onLCP(({ value }) => analytics.track('LCP', { value }));
onINP(({ value }) => analytics.track('INP', { value }));
onCLS(({ value }) => analytics.track('CLS', { value }));
```

### Visual search (CLIP-style)
```python
from transformers import CLIPModel
model = CLIPModel.from_pretrained('openai/clip-vit-large-patch14')

def visual_search(query_image, catalog_embeds):
    q_emb = model.get_image_features(preprocess(query_image))
    sims = (q_emb @ catalog_embeds.T).softmax(-1)
    return sims.topk(20).indices
```

### Smart upsell (post-purchase)
```python
def upsell(order, catalog):
    bought_categories = {item.category for item in order.items}
    candidates = [c for c in catalog if c.category in bought_categories]
    return sorted(candidates, key=lambda c: c.cross_sell_score, reverse=True)[:3]
```

## 매 결정 기준
| 상황 | Lever |
|---|---|
| Low CVR | UX + trust |
| Low AOV | Bundle + upsell |
| High CAC | Retention + LTV |
| Cart abandon | Recovery email + urgency |
| Slow site | Core Web Vitals |
| Repeat low | Subscription + reco |

**기본값**: 매 funnel 진단 + 매 leak step 의 fix + 매 A/B 검증 + 매 reco / personalization for scale.

## 🔗 Graph
- 부모: [[E-commerce]]
- 변형: [[CRO]] · [[Funnel-Optimization]]
- 응용: [[Recommender-Systems]] · [[Dynamic Pricing & Offers]]
- Adjacent: [[Dynamic-Creative-Optimization]] · [[Core Web Vitals Optimization (INP, LCP 개선)|Core-Web-Vitals]]

## 🤖 LLM 활용
**언제**: 매 e-commerce site. 매 marketplace. 매 DTC.
**언제 X**: 매 information-only. 매 niche / B2B-large-account.

## ❌ 안티패턴
- **Optimize without funnel data**: 매 wrong step.
- **AOV at expense of trust**: 매 dark pattern.
- **No A/B test**: 매 noise 의 confuse.
- **CAC ↑ chase**: 매 LTV 의 ignore.
- **Reco without diversity**: 매 echo bubble.

## 🧪 검증 / 중복
- Verified (ConversionXL, Baymard, Booking.com Eng).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-04-20 | Auto-reinforced |
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — funnel + 매 A/B / cart / reco / LTV / cohort / CWV code |
