Solution 04: ShopWave Omnichannel Retail

AI-Generated Content — Use for Reference Only

This content is AI-generated and has only been validated by AI review processes. It has NOT been reviewed or validated by certified Salesforce CTAs or human subject matter experts. Do not rely on this content as authoritative or completely accurate. Use it solely as a reference point for your own study and preparation. Always verify architectural recommendations against official Salesforce documentation.

AI-Assisted Reference Solution

This page is the spoiler side of the mini-scenario package. Use it to compare architecture choices, trade-offs, and artifact quality only after your own attempt.

Solution Snapshot

Field	Detail
Start here	Question page
Difficulty	Intermediate
Heavy domains	Solution Architecture and Integration
Page role	Worked reference solution
Best used for	Comparing your own answer against a complete architecture recommendation
Coverage available	Question page + this solution page

Why This Solution Matters

Use this page to compare your own approach against a full reference answer without losing the context of what the scenario was testing.

Only Open After Your Own Attempt

If you have not yet worked through the question page, stop here. Finish your timed mini-board attempt first, then use this solution with the 9 Essential Artifacts as your comparison checklist.

Assumptions

ShopWave’s existing Salesforce org (Sales Cloud, 40 users) is Enterprise Edition and can be upgraded; no new org needed
MuleSoft Anypoint Platform for middleware (standard for Salesforce-anchored integration architectures)
Shopify Plus provides REST/GraphQL APIs with webhook support; Square POS supports webhooks for near-real-time push
B2B Commerce (Lightning Experience) is the Salesforce product for the wholesale portal
The 85K Insider subscription members are managed through Stripe Billing and remain there
Budget $8.5M/18 months covers MuleSoft, B2B Commerce, Service Cloud expansion, and SI engagement

Key Architectural Decisions

Decision 1: Keep Shopify Plus — Do NOT Migrate to Commerce Cloud (D4 — HEAVY)

Retain Shopify Plus for DTC because 3 years of marketing customizations (style quiz, promotional engine, recommendation logic) represent significant investment. Commerce Cloud migration adds 6-9 months of replatforming risk, competes with the B2B deadline, and directly violates the VP of Marketing’s non-negotiable. Shopify handles 35K orders/day at peak without issues. The real problem is lack of integration, not the e-commerce platform.

CTA Insight

The board tests whether you can resist consolidating everything onto Salesforce. The right answer is often “keep best-of-breed and integrate” rather than “replace with Salesforce.”

Decision 2: Salesforce as Customer Hub + MuleSoft Orchestration (D4 + D5 — HEAVY)

Salesforce as unified customer system of record with MuleSoft as middleware because the core problem is “six islands that do not talk to each other.” Point-to-point (15+ connections) is unmaintainable.

Salesforce: Customer 360 golden record, Service Cloud omnichannel cases, B2B Commerce wholesale portal, Sales Cloud B2B pipeline
MuleSoft API-led connectivity: Experience APIs (per channel), Process APIs (orchestration, customer resolution, inventory allocation), System APIs (per backend)

Decision 3: Loyalty on Salesforce + B2B Commerce for Wholesale (D4)

Loyalty Management natively on Salesforce — existing PostgreSQL system is unsupported (contractor unavailable), store associates cannot access it, top customer complaint. Migrate 1.4M members and 8M point transactions; preserve loyalty card numbers as external IDs. Integrate with Shopify checkout and Square POS via MuleSoft for real-time earn/redeem. Go live with in-store loyalty BEFORE B2B launch for quick win.

B2B Commerce for the wholesale portal — natively supports account hierarchies, volume-based pricing, credit terms (Net 30/60/90), and buyer self-service. Rejected custom Experience Cloud portal because the 10-month contractual deadline leaves no room for building catalog, pricing tiers, and order workflow from scratch.

Decision 4: Integration Cadence by System (D5 — HEAVY)

Different patterns per system because each flow has different latency and volume characteristics.

System	Pattern	Cadence	Justification
Shopify orders	Webhook	Real-time	Service needs immediate order visibility
Square POS	Webhook	Near-real-time	Loyalty points must reflect within minutes
NetSuite inventory	Polling + events	15-min + stock-outs	180 locations, 15K movements/day
NetSuite financials	Batch	Nightly	Finance needs daily reconciliation
HubSpot contacts	Batch	Every 4 hours	Marketing does not need sub-minute data
Stripe payments	Webhook	Real-time	Chargebacks need immediate visibility
Loyalty	API call	Real-time	Earn/redeem at checkout must be synchronous
B2B to NetSuite	Event-driven	<30 min	Wholesale buyers expect status within 2 hours

Critical Diagrams

System Landscape

graph TB
    subgraph SF["🟢 Salesforce — Customer Hub"]
        SALES["⚪ Sales Cloud — Existing 40 Users"]
        SC["🟢 Service Cloud — Omnichannel"]
        LOY["🟢 Loyalty Management — 1.4M Members"]
        B2BC["🟢 B2B Commerce — Wholesale Portal"]
        CDP["🟢 Customer 360 — Golden Record"]
    end

    subgraph Mule["🟠 MuleSoft Anypoint — Integration Layer"]
        API["🟠 API-Led Connectivity"]
    end

    subgraph Kept["Retained Systems"]
        SHOP["⚪ Shopify Plus — DTC E-Commerce"]
        SQ["⚪ Square POS — 120 Stores"]
        NS["⚪ NetSuite — Inventory + Finance SoR"]
        HUB["⚪ HubSpot — Marketing Automation"]
        STRIPE["⚪ Stripe — Payments + Subscriptions"]
    end

    subgraph Retiring["Retiring Systems"]
        PGDB["🔴 Custom PostgreSQL — WaveRewards Loyalty"]
    end

    subgraph Legend
        direction LR
        NEW["🟢 NEW - Being Built"]
        KEEP["⚪ KEEPING - No Changes"]
        RETIRE["🔴 RETIRING - Decommissioning"]
        INT["🟠 INTEGRATION LAYER"]
    end

    SHOP -->|"Webhooks real-time"| API
    SQ -->|"Webhooks near-real-time"| API
    API -->|"REST / Platform Events"| SF
    NS -->|"Polling 15-min + stock-outs"| API
    HUB -->|"Batch every 4 hours"| API
    STRIPE -->|"Webhooks real-time"| API
    B2BC -->|"Order events < 30 min"| API
    API -->|"Event-driven"| NS
    PGDB -.->|"One-time migration"| LOY

Integration Architecture

graph TB
    subgraph Channels["Customer Channels"]
        SHOP["⚪ Shopify Plus — 8.5K-35K orders/day"]
        SQ["⚪ Square POS — 120 stores"]
        B2B["🟢 B2B Commerce — 88 buyers"]
    end

    subgraph Mule["🟠 MuleSoft Anypoint — Integration Layer"]
        EXP["🟠 Experience APIs"]
        PROC["🟠 Process APIs — Order, Customer, Inventory"]
        SYS["🟠 System APIs — Shopify, Square, NetSuite, Stripe, HubSpot"]
    end

    subgraph SF["🟢 Salesforce — Customer Hub"]
        SC["⚪ Service Cloud"]
        LOY["🟢 Loyalty Mgmt — 1.4M members"]
        B2BC["🟢 B2B Commerce Engine"]
        CDP["🟢 Golden Record — Unified Contact"]
    end

    subgraph Backend["Backend Systems"]
        NS["⚪ NetSuite — Inventory, Finance"]
        HUB["⚪ HubSpot — Marketing"]
        STRIPE["⚪ Stripe — Payments"]
        PGDB["🔴 PostgreSQL Loyalty — Decommissioning"]
    end

    subgraph Legend
        direction LR
        NEW["🟢 NEW - Being Built"]
        KEEP["⚪ KEEPING - No Changes"]
        RETIRE["🔴 RETIRING - Decommissioning"]
        INT["🟠 INTEGRATION LAYER"]
    end

    SHOP -->|"Webhooks real-time<br/>REST/GraphQL, API key<br/>8.5K-35K orders/day"| EXP
    SQ -->|"Webhooks near-real-time<br/>OAuth 2.0<br/>22K txn/day"| EXP
    B2B --> B2BC
    EXP -->|Route + transform| PROC
    PROC -->|Customer resolution| CDP
    PROC -->|"Earn/redeem real-time<br/>Sync API, OAuth 2.0"| LOY
    PROC -->|Case routing| SC
    SYS -->|"Polling 15-min + stock-outs<br/>REST, Token auth<br/>15K movements/day"| NS
    SYS -->|"Batch every 4 hours<br/>REST, API key<br/>2.8M contacts"| HUB
    SYS -->|"Webhooks real-time<br/>API key + signing secret<br/>Chargebacks + payments"| STRIPE
    PROC -->|Orchestrate| SYS
    B2BC -->|"Order events < 30 min<br/>Platform Events"| PROC
    PGDB -.->|"One-time migration<br/>pg_dump + ETL<br/>1.4M members + 8M txns"| LOY

Build vs Buy Decision Matrix

graph LR
    subgraph BUILD["BUILD on Salesforce"]
        B1[Customer 360 Profile]
        B2[B2B Wholesale Portal]
        B3[Loyalty Management]
        B4[Service Cloud Cases]
    end

    subgraph KEEP["KEEP As-Is"]
        K1[Shopify Plus — 3yr investment]
        K2[Square POS — 120 stores]
        K3[NetSuite — Financial SoR]
        K4[Stripe — Payments]
        K5[HubSpot — Marketing]
    end

Customer identity resolution: Email is primary match key (used by 4/6 systems). Phone is secondary for Square-only customers. Deterministic matching (exact email) first, then probabilistic (name + zip fuzzy match) for unresolved records. Human review queue for low-confidence matches.

Data Model

erDiagram
    ACCOUNT ||--o{ CONTACT : "Lookup"
    ACCOUNT ||--o{ B2B_ORDER : "Lookup"
    ACCOUNT ||--o{ ACCOUNT : "Lookup (Parent Account Hierarchy)"
    ACCOUNT {
        string OWD "Private"
        string Volume "88 parent + child locations"
        string Note "B2B hierarchy - chain with store locations"
    }
    CONTACT ||--o{ DTC_ORDER : "Lookup"
    CONTACT ||--o{ CASE : "Lookup"
    CONTACT ||--o{ LOYALTY_MEMBER : "Lookup"
    CONTACT {
        string OWD "Private"
        string Volume "3.2M DTC + B2B buyers"
        string LDV "LDV"
        string Note "Golden record - unified across 6 systems"
    }
    DTC_ORDER ||--|{ ORDER_LINE_ITEM : "M-D"
    DTC_ORDER {
        string OWD "Private"
        string Volume "3.1M per year"
        string LDV "LDV"
        string Note "Shopify online + Square POS combined"
    }
    ORDER_LINE_ITEM {
        string OWD "Parent"
        string Note "SKU, qty, price, variant"
    }
    B2B_ORDER ||--|{ B2B_ORDER_LINE : "M-D"
    B2B_ORDER {
        string OWD "Private"
        string Volume "Growing - 88 initial buyers"
        string Note "B2B Commerce - volume pricing + credit terms"
    }
    B2B_ORDER_LINE {
        string OWD "Parent"
        string Note "Wholesale packaging units"
    }
    PRODUCT ||--|{ PRODUCT_VARIANT : "M-D"
    PRODUCT ||--o{ PRICE_LIST_ENTRY : "Lookup"
    PRODUCT {
        string OWD "Public Read Only"
        string Volume "2400 active SKUs"
        string Note "NetSuite is SoR - propagated to all channels"
    }
    PRODUCT_VARIANT {
        string OWD "Parent"
        string Volume "14400 variants"
        string Note "6 variants per product"
    }
    PRICE_LIST_ENTRY }|--|{ PRICE_LIST : "Junction"
    PRICE_LIST {
        string OWD "Private"
        string Note "DTC standard, member, promo, wholesale volume tiers"
    }
    LOYALTY_MEMBER ||--|{ POINT_TRANSACTION : "M-D"
    LOYALTY_MEMBER {
        string OWD "Private"
        string Volume "1.4M members"
        string LDV "LDV"
        string Note "Migrated from PostgreSQL - card numbers preserved"
    }
    POINT_TRANSACTION {
        string OWD "Parent"
        string Volume "8M historical + growing"
        string LDV "LDV"
        string Note "Earn and redeem across all channels"
    }
    CASE ||--|{ CASE_COMMENT : "M-D"
    CASE {
        string OWD "Private"
        string Volume "120K historical + new"
        string LDV "LDV"
        string Note "Cross-channel service cases"
    }
    INVENTORY_RECORD {
        string OWD "Private"
        string Volume "432K SKU-location combos"
        string LDV "LDV"
        string Note "NetSuite SoR - synced every 15 min"
    }
    INSIDER_SUBSCRIPTION {
        string OWD "Private"
        string Volume "85K active"
        string Note "Stripe Billing SoR - synced to contact"
    }

Role Hierarchy and Security

graph TB
    CRO["CRO<br/>All Revenue Data"]
    CRO --> VP_SALES["VP Sales<br/>B2B Pipeline + DTC"]
    CRO --> VP_RETAIL["VP Retail Ops<br/>120 Store Roll-Up"]
    CRO --> VP_MKTG["VP Marketing<br/>Campaigns + Segments"]
    CRO --> VP_SVC["VP Service<br/>All Cases"]

    VP_SALES --> B2B_MGR["B2B Sales Manager<br/>All Wholesale Accounts"]
    B2B_MGR --> B2B_REP["B2B Sales Reps<br/>Assigned Accounts"]

    VP_RETAIL --> REG_MGR["Regional Manager<br/>Region Stores"]
    REG_MGR --> STORE_MGR["Store Manager<br/>Single Store"]
    STORE_MGR --> ASSOC["Store Associate<br/>Customer Lookup + Clienteling"]

    VP_SVC --> SVC_MGR["Service Manager<br/>All Cases"]
    SVC_MGR --> AGENT["Service Agent<br/>Cross-Channel Cases"]

    VP_MKTG --> MKT_OPS["Marketing Ops<br/>Segments + Campaigns"]

    BUYER["B2B Buyer<br/>Portal — Own Company Only"]
    FINANCE["Finance<br/>Revenue Reports + Reconciliation"]

OWD Summary:

Object	OWD	Sharing Mechanism
Account (B2B)	Private	Role hierarchy; B2B reps see assigned accounts; managers roll up by region
Contact (Golden Record)	Private	Role hierarchy; service agents see all via permission set; store associates read-only via sharing rule
DTC Order	Private	Role hierarchy; service agents see all channels; store associates see own-store transactions
B2B Order	Private	Role hierarchy (B2B branch); B2B buyers see only own company via portal sharing sets
Case	Private	Role hierarchy; agents own cases; managers roll up; CSAT visible to VP Service
Loyalty Member	Private	Service agents read via permission set; store associates read-only for clienteling; admin-only point adjustments
Product	Public Read Only	All internal users can view catalog; NetSuite is SoR
Price List	Private	Wholesale volume-tier pricing restricted to B2B roles via permission set; DTC pricing visible to retail staff
Inventory Record	Public Read Only	All channels can read for availability; write restricted to integration user + ops team
Insider Subscription	Private	Service agents read via permission set; billing managed in Stripe

Migration Strategy

flowchart TB
    subgraph Phase0["Month 1-3: Foundation"]
        IDR["Customer Identity Resolution<br/>Deterministic: exact email match<br/>Probabilistic: name + zip fuzzy"]
        GOLDEN["Build Golden Record<br/>Merge 3.2M Shopify + 2.8M HubSpot<br/>+ 1.4M loyalty + Square"]
        MULE["MuleSoft Foundation<br/>System APIs for all 6 backends"]
        IDR --> GOLDEN
    end

    subgraph Phase1["Month 3-7: Loyalty + Service"]
        LOY_MIG["Loyalty Migration<br/>1.4M members + 8M point txns<br/>Preserve card numbers as External ID"]
        LOY_VAL["Loyalty Validation<br/>Point balance reconciliation<br/>Tier assignment verification"]
        SVC_MIG["Service Case Migration<br/>~120K historical cases<br/>Link to unified contacts"]
        LOY_MIG --> LOY_VAL
        LOY_VAL --> LOY_LIVE["Loyalty Go-Live<br/>In-store earn/redeem enabled"]
    end

    subgraph Phase2["Month 4-10: B2B Commerce"]
        B2B_SETUP["B2B Commerce Setup<br/>Account hierarchies (88 buyers)<br/>Volume pricing + credit terms"]
        CAT_SYNC["Product Catalog Sync<br/>2400 SKUs from NetSuite<br/>Wholesale packaging units"]
        B2B_SETUP --> CAT_SYNC
        CAT_SYNC --> B2B_LIVE["B2B Go-Live — Month 10<br/>Contractual deadline"]
    end

    subgraph Phase3["Month 8-18: Integration Maturity"]
        RT_INT["Real-Time Integrations<br/>Shopify + Square webhooks<br/>Stripe payment events"]
        INV_SYNC["Inventory Sync<br/>180 locations, 15-min cadence<br/>Ship-from-store routing"]
        DECOM["Decommission PostgreSQL<br/>Loyalty fully on Salesforce"]
        RT_INT --> INV_SYNC
        INV_SYNC --> DECOM
    end

    Phase0 --> Phase1
    Phase0 --> Phase2
    Phase1 --> Phase3

Identity & SSO Flow

sequenceDiagram
    participant Employee as ShopWave Employee<br/>(Sales / Service / Marketing)
    participant Browser as Browser
    participant Okta as Okta (IdP)
    participant SF as Salesforce

    Employee->>Browser: Navigate to Salesforce
    Browser->>Okta: Redirect (SP-initiated SAML 2.0)
    Okta->>Okta: Authenticate (MFA — push or TOTP)
    Okta->>Browser: SAML Assertion (Federation ID = employee email)
    Browser->>SF: POST SAML to ACS URL
    SF->>SF: Match Federation ID → User record
    SF->>SF: Assign profile + permission sets by role
    SF->>Browser: Session Cookie + Redirect

sequenceDiagram
    participant Buyer as B2B Wholesale Buyer
    participant Browser as Browser
    participant SF as B2B Commerce Portal

    Buyer->>Browser: Navigate to B2B Portal
    Browser->>SF: Login page (email + password)
    SF->>SF: Authenticate (MFA recommended)
    SF->>SF: Assign B2B Buyer profile<br/>(account hierarchy determines visibility)
    SF->>SF: Apply sharing: buyer sees own company orders/pricing only
    SF->>Browser: Session Cookie + B2B Storefront

SSO Design Rationale

Internal employees (350 + growing): SAML 2.0 SP-initiated SSO via Okta (standard enterprise IdP for mid-market retail). Okta handles MFA. ShopWave’s existing Sales Cloud org already supports SSO; expanding to the full user base requires Okta group-to-Salesforce permission set mapping for role-based access (service agents, marketing, store associates, B2B sales).

B2B wholesale buyers (88 accounts): Username/password through B2B Commerce portal with MFA recommended. B2B buyers do not share ShopWave’s corporate IdP. Account hierarchy enforcement ensures each buyer sees only their company’s orders, invoices, and pricing (Req 19). Self-registration with admin approval for new buyer contacts.

Store associates (mobile tool): Same Okta SSO flow, accessed via Salesforce Mobile App on store devices. Session timeout set to 8 hours (shift length) to avoid repeated re-authentication during clienteling.

Integration Error Handling

ShopWave’s 8 integrations span real-time, near-real-time, and batch patterns. Error handling is calibrated to business impact — a failed loyalty redemption at checkout is more urgent than a delayed marketing sync.

Integration	Pattern	Retry	DLQ	Monitor	Fallback
Shopify orders (inbound)	Webhook → MuleSoft → Salesforce	3x exponential (1s, 5s, 30s); Shopify retries 8 times over 4 hours (exponential backoff)	MuleSoft DLQ + `Integration_Error__c` with Shopify order ID	Alert to integration team on >5 failures/hour; escalate to on-call during seasonal sales	Service agents see “order syncing” status; Shopify is SoR for orders — no data loss; manual re-trigger available
Square POS (inbound)	Webhook → MuleSoft → Salesforce	3x exponential (2s, 10s, 60s)	MuleSoft DLQ + `Integration_Error__c` with Square transaction ID	Alert on >10 failures/hour (higher threshold: 120 stores generate noise)	In-store transactions continue unaffected; loyalty points queued and applied on reconnect
NetSuite inventory (bidirectional)	MuleSoft polling every 15 min + stock-out events	2x retry per poll cycle	Failed inventory updates logged with SKU + location + timestamp	Alert to ops team when sync lag exceeds 30 minutes; dashboard shows last-sync per warehouse	5% buffer stock on high-velocity SKUs absorbs sync delays; stock check API call at Shopify checkout provides real-time validation
NetSuite financials (outbound)	MuleSoft scheduled nightly batch	1 automatic re-run at T+3 hours	Failed journal entries in `Integration_Error__c` with GL coding	Morning alert to finance team if nightly batch fails	Finance can manually trigger batch re-run; all financial data retained in Salesforce until confirmed in NetSuite
HubSpot contacts (bidirectional)	MuleSoft batch every 4 hours	1 automatic retry next cycle	Failed records in `Integration_Error__c` with HubSpot contact ID	Weekly sync health digest to marketing team	Segments can be manually exported; engagement data (opens/clicks) delayed but not lost — HubSpot retains all data
Stripe payments (inbound)	Webhook → MuleSoft → Salesforce	3x exponential (1s, 5s, 30s); Stripe retries for 72 hours	MuleSoft DLQ + `Integration_Error__c` with Stripe event ID	Immediate alert on chargeback webhook failures (financial risk); standard threshold for payment confirmations	Stripe is SoR for payments; service agents can look up payment status directly in Stripe dashboard as interim
Loyalty earn/redeem (synchronous)	Real-time API call via MuleSoft	2x immediate retry (100ms, 500ms) — synchronous, so must be fast	Failed transactions logged with loyalty card number + attempted action	Alert on >3 failures in 5 minutes (checkout flow is blocked)	Circuit breaker: If loyalty service is down, checkout proceeds without points; queued earn/redeem processed when service restores; customer notified via email
B2B orders → NetSuite (outbound)	Event-driven via MuleSoft (<30 min)	3x exponential (5s, 30s, 300s)	`Integration_Error__c` with B2B order ID and NetSuite payload	Alert to B2B operations team on any failure (wholesale buyers expect portal status updates within 2 hours)	B2B order confirmed in Salesforce; NetSuite submission queued; buyer portal shows “processing” status until NetSuite confirms

Seasonal Sales Events — Circuit Breakers

During the 4 annual seasonal sales events (35K orders/day, 4x normal volume), MuleSoft circuit breakers activate on all non-critical integrations if error rates exceed 10%. HubSpot sync and NetSuite financial batch are deprioritized; Shopify order ingestion, Stripe payment processing, and loyalty earn/redeem maintain priority. Load testing at 2x peak (70K orders/day) validates this behavior before each seasonal window.

Governance & DevOps

Environment Strategy

flowchart LR
    DEV1[Dev Sandbox 1<br/>B2B Portal Team] --> QA[QA / Integration<br/>Partial Copy]
    DEV2[Dev Sandbox 2<br/>Loyalty + Service] --> QA
    DEV3[Dev Sandbox 3<br/>Integration Layer] --> QA
    DEV4[Dev Sandbox 4<br/>SI Workstream] --> QA
    QA --> PERF[Performance<br/>Full Copy]
    PERF --> UAT[UAT<br/>Full Copy]
    UAT --> PROD[Production]

Sandbox Strategy

Sandbox	Type	Purpose	Notes
DEV-1	Developer Pro	B2B Commerce portal development	B2B product catalog seed data; mock wholesale accounts
DEV-2	Developer Pro	Loyalty Management + Service Cloud enhancements	Synthetic loyalty members; mock point transactions
DEV-3	Developer Pro	MuleSoft integration development and testing	Mock API endpoints for all 8 system connections
DEV-4	Developer Pro	SI workstream (parallel to internal team)	Isolated from internal dev to prevent merge conflicts
QA	Partial Copy	Integration testing with MuleSoft sandbox	Connected to Shopify dev store, Stripe test mode, NetSuite sandbox
PERF	Full Copy	Performance and load testing	Mirrors production data volumes; used for seasonal peak simulation (35K+ orders/day)
UAT	Full Copy	Business stakeholder acceptance	B2B buyers, service agents, store associates, marketing validate real workflows

Performance Sandbox — Seasonal Necessity

A dedicated Performance sandbox (Full Copy) is essential for ShopWave. The 4x seasonal volume spike (8.5K → 35K orders/day) means integration capacity must be validated before every seasonal event. Load tests simulate 70K orders/day (2x peak) across the full integration chain: Shopify → MuleSoft → Salesforce → NetSuite. This sandbox is refreshed quarterly, 4 weeks before each seasonal sales event.

Branching Strategy

main — production-ready; deploys to Production outside of deployment freeze windows
develop — integration branch; deploys to QA sandbox
feature/[workstream]/[ticket]-description — organized by workstream (b2b, loyalty, service, integration) to manage 4 parallel development tracks (Req 44)
release/[version] — release candidate branches cut from develop for UAT validation
All merges to develop require peer code review + passing CI (Apex tests + MuleSoft unit tests)
Release branches require UAT sign-off from business stakeholders per workstream

Deployment Freeze Windows

Event	Freeze Period	Duration
Spring Sale	2 weeks before + during event	~3 weeks
Summer Sale	2 weeks before + during event	~3 weeks
Fall Sale	2 weeks before + during event	~3 weeks
Holiday Sale	2 weeks before + during event	~3 weeks

Total annual freeze: ~12 weeks (23% of the year). All releases must be planned around these windows. Emergency hotfixes during freeze require VP of Technology approval + rollback plan.

Testing Strategy

Test Type	Environment	Scope	Criteria
Apex Unit Tests	Developer sandboxes	All custom Apex, triggers, Flows	>75% coverage; mock callouts for all MuleSoft-invoked APIs
MuleSoft Unit Tests	MuleSoft Design Center	All API specs, transformations, error handling	MUnit tests for each system API, process API, and experience API
Integration Tests	QA	All 8 integration connections end-to-end	Data flows validated with test-mode APIs (Shopify dev store, Stripe test, NetSuite sandbox)
Performance Tests	PERF (Full Copy)	Seasonal peak simulation	70K orders/day sustained for 4 hours; loyalty earn/redeem <500ms p95; inventory sync within 15-min SLA
UAT	Full Copy	All 4 workstreams validated by business users	B2B buyers test portal; service agents test omnichannel; store associates test mobile clienteling tool
Regression Suite	QA	Core flows after each release	Automated test suite covering order ingestion, loyalty transactions, and B2B order-to-fulfillment

CoE / Post-Go-Live Governance

Team Growth: Internal team grows from 5 (2 admins, 2 devs, 1 architect) to 8-10 during the SI engagement (Req 41). The SI handles B2B Commerce and MuleSoft integration buildout; internal team shadows and takes over workstreams incrementally during Months 12-18.

Release Cadence:

Standard releases: Bi-weekly, planned around deployment freeze windows
Workstream releases: Each of the 4 parallel workstreams (B2B, loyalty, service, integration) can release independently to QA, but production deployments are consolidated into bi-weekly windows
Emergency hotfixes: VP of Technology approval required; mandatory during freeze windows

Ongoing Governance:

Monthly integration health review (MuleSoft API usage, error rates, latency trends)
Quarterly architecture review before each seasonal sales event (capacity planning, circuit breaker thresholds, buffer stock levels)
Annual MuleSoft license review — monitor API call volumes against tier limits as order volumes grow 30% YoY

Requirements Addressed

✅ Unified customer profile — Golden record in Salesforce resolving identities across 6 systems (email + phone matching) (Reqs 1-2, 12)
✅ B2B wholesale portal — B2B Commerce with account hierarchies, volume pricing, credit terms, self-service (Req 3)
✅ Keep Shopify Plus — 3 years of marketing customizations preserved; integrate, don’t replace (implicit non-negotiable)
✅ Omnichannel loyalty — Loyalty Management on Salesforce with real-time earn/redeem across Shopify + Square via MuleSoft (Reqs 6, 15, 29)
✅ 15-minute inventory sync — MuleSoft polling + stock-out events across 180 locations (Reqs 5, 26)
✅ Cross-channel service view — Service Cloud with complete order history from Shopify + Square + B2B (Reqs 2, 24-25)
✅ API-led integration — MuleSoft 3-layer architecture (experience / process / system) for 8 systems (Reqs 24-31)
✅ B2B launch within 10 months — Dedicated SI capacity + parallel workstream strategy (Reqs 43-44)
✅ Deployment freeze compliance — 4 seasonal freeze windows respected; release cadence planned around 12 weeks/year of blackout (Req 42)

Risk Assessment

Risk	Impact	Prob	Mitigation
B2B launch misses 10-month contractual deadline	Critical	Med	Staff 60% SI capacity on B2B; defer loyalty to Phase 1b if needed
35K peak orders/day overwhelm integration layer	High	Med	MuleSoft horizontal scaling; load test at 2x peak (70K/day); circuit breakers on all APIs
Customer identity resolution produces excessive duplicates	High	High	Start deterministic only; add probabilistic Phase 2; accept 5-10% initial unresolved rate
NetSuite inventory sync lag causes overselling	Critical	Med	Reserve 5% buffer stock for high-velocity SKUs; real-time stock check at checkout via API

Domain Scoring Notes

D4 Solution Architecture (HEAVY): Build-vs-buy discipline (keep Shopify/Square/NetSuite/Stripe/HubSpot, build only what Salesforce does best). System-of-record clarity — NetSuite for finance/inventory, Shopify for DTC orders, Salesforce for customer profile. Loyalty Management justification. B2B Commerce tied to timeline constraint.
D5 Integration (HEAVY): API-led connectivity (three MuleSoft layers). Pattern selection per data flow with justification. Error handling — dead-letter queues, retry policies, reconciliation, circuit breakers. Customer identity resolution across 6 identifiers. Inventory orchestration (180 locations, 15K movements/day, 15-min SLA).
D6 Dev Lifecycle (MED): 4 parallel workstreams need branching strategy. Deployment freezes around 4 seasonal sales events (~12 weeks/year of blackout). SI handoff plan.

Reporting Approach

Standard Salesforce reports cover wholesale pipeline (Req 36), service metrics (Req 38), and loyalty enrollment/tier reports (Req 39). The CRO unified revenue dashboard (Req 32) requires cross-system data — CRM Analytics is essential here, pulling order data from Shopify (via MuleSoft sync), Square POS, B2B Commerce, and NetSuite financial reconciliation into a single dataset. Marketing campaign attribution (Req 33) linking online conversions to in-store purchases within 7 days needs CRM Analytics recipes joining Salesforce campaign data with HubSpot engagement and Square POS transactions. Store manager daily reports (Req 34) and VP retail operations dashboards (Req 35) across 120 locations also benefit from CRM Analytics for cross-location rollups and performance rankings. Financial reconciliation (Req 37) against NetSuite GL is a nightly batch comparison via scheduled Apex.

What Would Fail

Common Mistakes

1. Recommending Commerce Cloud to replace Shopify. VP of Marketing said “this project is dead to me” if you rebuild DTC. Commerce Cloud adds 6-9 months risk, destroys 3 years of customizations, and solves nothing that integration cannot solve better.

2. Making Salesforce the system of record for inventory or finance. The CFO said “NetSuite is our financial source of truth. Period.” If your architecture creates a second set of financial books in Salesforce, you directly contradict a stated non-negotiable.

3. Skipping customer identity resolution. 20-30% of customers exist in multiple systems under different identifiers. Without a resolution strategy, your “unified customer profile” is a slide title, not an architecture.

Self-Scoring Checklist

Did I keep Shopify and justify why (not just assert it)?
Did I classify each integration by pattern, cadence, and justification?
Did I use API-led connectivity (three layers), not just “MuleSoft connects things”?
Did I address customer identity resolution with a matching strategy?
Did I account for 35K peak orders and deployment freeze windows?
Did I make NetSuite the SoR for inventory/finance (not Salesforce)?

Scoring Rubric

Criterion	Weight	What Judges Look For
Solution Architecture & Build vs Buy	25%	Shopify retained with clear justification (not rebuilding DTC). B2B Commerce for wholesale. Loyalty migration strategy. Each capability area has a deliberate build-vs-buy decision with rationale
Integration Orchestration	25%	6+ systems classified by pattern, cadence, and protocol. API-led connectivity (system/process/experience layers). Customer identity resolution across channels. Event-driven architecture for near-real-time sync. Error handling per integration
Technical Depth	20%	Specific products, APIs, and limits cited. 35K peak order handling. Deployment freeze windows factored into release planning. NetSuite as SoR for inventory/finance. MuleSoft circuit breaker patterns for seasonal spikes
Architecture Completeness	15%	All major components addressed — DTC, B2B wholesale, loyalty, service, analytics. System landscape diagram with all integration points. Environment strategy supporting 4 parallel workstreams
Trade-off Articulation	15%	WHY Shopify stays (not “it works”), WHY middleware over point-to-point at this scale, WHY B2B Commerce over custom portal. 10-month B2B deadline acknowledged in phasing

This is a personal study site for Salesforce CTA exam preparation. Built with AI assistance. Not affiliated with Salesforce.