Cloud Mode allows you to process E-commerce events directly on your backend using App Functions. In this integration model, events are delivered securely from Salla’s servers to your application through a server-to-server connection.

Your App Function receives the event payload and can execute custom business logic in response, without relying on any client-side scripts.

This architecture provides:

Reliable event delivery

Secure server-side processing

Scalable integrations with backend systems and external services

To learn more about implementing backend logic with App Functions, see the
App Functions Documentation.

When to Use Cloud Mode

Cloud Mode is recommended when events need to be handled by backend services.

Common use cases include:

Order Management

Automatically process events such as:

new orders

order updates

order cancellations

Fulfillment Systems

Trigger operations such as:

shipping creation

inventory updates

warehouse notifications

CRM & Marketing Automation

Update customer records or trigger campaigns based on behavioral events.

Examples:

abandoned carts

purchase completion

product views

Custom Business Logic

Implement real-time automation such as:

fraud detection

loyalty systems

reward programs

webhook forwarding

How Cloud Mode Works

The Cloud Mode event flow looks like this:

Customer Action
      │
      ▼
Storefront / Mobile App
      │
      ▼
Salla Platform
      │
      ▼
App Function (your backend logic)
      │
      ▼
External Systems (CRM, OMS, Analytics)

A customer performs an action in the store.

The platform captures the event.

Salla forwards the event payload to your App Function.

Your function processes the event and optionally returns a response.

Implementing Cloud Mode

To start processing events in Cloud Mode, you will need to create and deploy an App Function.

The App Function acts as your server-side event handler.

Typical responsibilities include:

receiving event payloads

validating event data

executing business logic

integrating with external services

For the complete implementation steps, see:

Usage — Cloud Mode Setup Guide

Example Event Handling Flow

A typical backend flow might look like this:

Event: order.created
        │
        ▼
App Function receives payload
        │
        ▼
Validate order data
        │
        ▼
Send order to fulfillment system
        │
        ▼
Store event in analytics pipeline

This allows your system to react to platform events immediately without relying on storefront scripts.

Example Event Payload

Example payload for an order event:

{
  "event": "order.created",
  "timestamp": "2026-03-09T10:15:20Z",
  "store_id": 12345,
  "order": {
    "id": 98765,
    "total": 450,
    "currency": "SAR",
    "status": "created",
    "customer": {
      "id": 1922,
      "email": "customer@example.com"
    }
  }
}

Your App Function can use this data to trigger downstream workflows such as:

order fulfillment

customer segmentation

reporting pipelines

Recommended Architecture

Most production integrations follow a pattern like this:

Salla Events
     │
     ▼
App Function
     │
     ▼
Event Processor Service
     │
     ├── CRM
     ├── Fulfillment System
     ├── Data Warehouse
     └── Analytics Platform

This architecture allows:

centralized event processing

easier debugging

scalable integrations with multiple services

Next Steps

To implement Cloud Mode in your application:

Enable App Functions for your app

Create an event handler

Deploy the function

Test events using a demo store

Follow the full guide here:

Usage — Cloud Mode Setup

Cloud Mode

When to Use Cloud Mode#

Order Management#

Fulfillment Systems#

CRM & Marketing Automation#

Custom Business Logic#

How Cloud Mode Works#

Implementing Cloud Mode#

Example Event Handling Flow#

Example Event Payload#

Recommended Architecture#

Next Steps#