Build a Real-Time Analytics Dashboard for E-Commerce Operations in APAC

Quick Answer

Build a real-time analytics dashboard for APAC e-commerce by connecting your Shopify Plus, Adobe Commerce, or SHOPLINE store data to a streaming pipeline (using tools like Apache Kafka or Google Pub/Sub), transforming it with dbt, and visualizing it in Grafana or Metabase. This gives multi-market operators a single pane of glass across currencies, time zones, and platforms.

Why Do APAC E-Commerce Operations Need Real-Time Dashboards?

Operating e-commerce across Asia-Pacific introduces complexity that domestic-only retailers never face. You're managing inventory across warehouses in Hong Kong, Singapore, and Sydney. Your flash sale in Taiwan starts at midnight local time while your Philippines warehouse team is still processing afternoon orders. Currency fluctuations between AUD, SGD, TWD, and PHP can shift margins by percentage points within a single day.

According to Statista, Asia-Pacific e-commerce revenue is projected to reach USD 2.09 trillion in 2025, making it the largest regional market globally (Statista, E-commerce — Asia-Pacific, 2025). With that scale comes operational noise—and the only way to cut through it is with live visibility into what's actually happening across your stores.

A real-time analytics dashboard isn't a luxury for multi-market APAC operators. It's the infrastructure that lets you catch a stockout in your SHOPLINE Taiwan store before it costs you a full day of revenue, or spot a payment gateway failure in your Shopify Plus Singapore checkout within minutes rather than hours.

This tutorial walks through building one from scratch—covering architecture decisions, data pipeline setup, transformation logic, and dashboard design—with specific attention to the multi-currency, multi-platform, multi-timezone realities of APAC commerce.

What Architecture Should You Use for Real-Time E-Commerce Analytics?

Before writing any code, you need to decide on an architecture that balances cost, latency, and maintainability. Here are three proven patterns for APAC e-commerce operations, ranked by complexity:

Option 1: Webhook-to-Warehouse (Simplest)

• Latency: 1–5 minutes
• Cost: Low (USD 50–200/month for small-to-mid operations)
• Best for: Single-platform stores doing under 10,000 orders/day across all markets
• Stack: Shopify/SHOPLINE webhooks → Cloud Functions (AWS Lambda or Google Cloud Functions) → BigQuery or PostgreSQL → Metabase

Option 2: CDC + Streaming Pipeline (Mid-Complexity)

• Latency: 10–30 seconds
• Cost: Moderate (USD 300–1,500/month)
• Best for: Multi-platform operations (e.g., Shopify Plus for Singapore + Adobe Commerce for Australia)
• Stack: Debezium CDC or platform webhooks → Apache Kafka / Google Pub/Sub → dbt transformations → Grafana or Apache Superset

Option 3: Full Event-Driven Architecture (Most Complex)

• Latency: Sub-second
• Cost: Higher (USD 1,000–5,000+/month)
• Best for: High-volume operations with 50,000+ daily orders or marketplace integrations (Lazada, Shopee)
• Stack: Event mesh → Apache Flink / Kafka Streams → ClickHouse or Apache Druid → Custom React dashboard

For most APAC e-commerce operations running on Shopify Plus, Adobe Commerce, or SHOPLINE, Option 2 hits the sweet spot. That's what we'll build in this tutorial.

How to Set Up Data Ingestion from Multiple E-Commerce Platforms

The first challenge is getting order, inventory, and customer data out of your platforms in near-real-time. Each platform handles this differently.

Shopify Plus Webhooks

Shopify Plus supports webhook subscriptions for key events. Register webhooks for orders/create, orders/updated, inventory_levels/update, and refunds/create using the Shopify Admin API (version 2024-10 or later).

1curl -X POST \
2  https://your-store.myshopify.com/admin/api/2024-10/webhooks.json \
3  -H 'Content-Type: application/json' \
4  -H 'X-Shopify-Access-Token: YOUR_ACCESS_TOKEN' \
5  -d '{
6    "webhook": {
7      "topic": "orders/create",
8      "address": "https://your-ingestion-endpoint.com/shopify/orders",
9      "format": "json"
10    }
11  }'

Shopify Plus allows up to 60 webhook subscriptions per store (compared to 5 on basic plans), which gives you enough headroom for comprehensive event coverage across your Singapore, Hong Kong, and Australian storefronts.

Adobe Commerce (Magento) Event Integration

Adobe Commerce 2.4.6+ includes Adobe I/O Events, which let you publish commerce events to Adobe's event mesh. For self-hosted Magento installations—still common across APAC—you'll use Debezium to capture MySQL binlog changes.

Create a docker-compose.yml for your Debezium connector:

1version: '3.8'
2services:
3  debezium-connect:
4    image: debezium/connect:2.5
5    ports:
6      - "8083:8083"
7    environment:
8      BOOTSTRAP_SERVERS: kafka-broker:9092
9      GROUP_ID: ecommerce-cdc
10      CONFIG_STORAGE_TOPIC: connect_configs
11      OFFSET_STORAGE_TOPIC: connect_offsets
12      STATUS_STORAGE_TOPIC: connect_statuses

Then register a MySQL connector:

1{
2  "name": "magento-connector",
3  "config": {
4    "connector.class": "io.debezium.connector.mysql.MySqlConnector",
5    "database.hostname": "your-magento-db-host",
6    "database.port": "3306",
7    "database.user": "debezium_user",
8    "database.password": "your_password",
9    "database.server.id": "184054",
10    "topic.prefix": "magento",
11    "table.include.list": "magento.sales_order,magento.sales_order_item,magento.cataloginventory_stock_item",
12    "schema.history.internal.kafka.bootstrap.servers": "kafka-broker:9092",
13    "schema.history.internal.kafka.topic": "schema-changes.magento"
14  }
15}

SHOPLINE Webhook and API Setup

SHOPLINE, widely used across Taiwan, Hong Kong, and Southeast Asia, offers webhook support through its Open API. Register event subscriptions via the SHOPLINE Partner Dashboard or API. Key events include order.created, order.updated, and product.inventory_updated.

1import requests
2
3headers = {
4    "Authorization": "Bearer YOUR_SHOPLINE_ACCESS_TOKEN",
5    "Content-Type": "application/json"
6}
7
8payload = {
9    "topic": "order.created",
10    "callback_url": "https://your-ingestion-endpoint.com/shopline/orders",
11    "is_active": True
12}
13
14response = requests.post(
15    "https://open.shoplineapp.com/v1/webhooks",
16    headers=headers,
17    json=payload
18)

One important note: SHOPLINE's API rate limits are stricter than Shopify's. According to SHOPLINE's developer documentation, standard apps are limited to 40 requests per minute per store. Plan your polling intervals accordingly if you supplement webhooks with periodic API syncs.

How to Build the Streaming Data Pipeline

With data flowing from all platforms, you need a central message broker to normalize and route events. We recommend Google Cloud Pub/Sub for teams already on GCP, or a managed Kafka service like Confluent Cloud or Amazon MSK.

Here's a lightweight ingestion service in Python (using FastAPI) that receives webhooks from all three platforms and publishes to Google Pub/Sub:

1from fastapi import FastAPI, Request
2from google.cloud import pubsub_v1
3import json
4import hashlib
5import hmac
6
7app = FastAPI()
8publisher = pubsub_v1.PublisherClient()
9PROJECT_ID = "your-gcp-project"
10TOPIC_ID = "ecommerce-events"
11topic_path = publisher.topic_path(PROJECT_ID, TOPIC_ID)
12
13@app.post("/shopify/orders")
14async def shopify_order(request: Request):
15    body = await request.body()
16    # Verify HMAC signature
17    hmac_header = request.headers.get("X-Shopify-Hmac-Sha256")
18    computed = hmac.new(
19        b"YOUR_SHOPIFY_WEBHOOK_SECRET", body, hashlib.sha256
20    ).digest()
21    # ... verification logic ...
22    
23    data = json.loads(body)
24    event = {
25        "platform": "shopify",
26        "event_type": "order_created",
27        "market": detect_market(data.get("currency", "USD")),
28        "payload": data,
29        "received_at": datetime.utcnow().isoformat()
30    }
31    
32    publisher.publish(
33        topic_path,
34        json.dumps(event).encode("utf-8"),
35        platform="shopify",
36        event_type="order_created"
37    )
38    return {"status": "ok"}
39
40def detect_market(currency: str) -> str:
41    currency_market_map = {
42        "HKD": "HK", "SGD": "SG", "TWD": "TW",
43        "AUD": "AU", "PHP": "PH", "MYR": "MY",
44        "VND": "VN", "IDR": "ID", "NZD": "NZ"
45    }
46    return currency_market_map.get(currency, "UNKNOWN")

This normalizes events from different platforms into a consistent schema before they hit your data warehouse.

How to Transform Raw Data into Dashboard-Ready Metrics

Raw webhook payloads are messy—nested JSON, inconsistent field names across platforms, and currencies that need standardization. Use dbt (data build tool) version 1.7+ to create a clean analytics layer.

Create a staging model that unifies orders across platforms:

1-- models/staging/stg_unified_orders.sql
2
3WITH shopify_orders AS (
4    SELECT
5        'shopify' AS platform,
6        id AS platform_order_id,
7        created_at,
8        total_price AS order_total_local,
9        currency AS local_currency,
10        financial_status AS payment_status,
11        fulfillment_status,
12        JSON_EXTRACT_SCALAR(shipping_address, '$.country_code') AS ship_country
13    FROM {{ source('raw', 'shopify_orders') }}
14),
15
16shopline_orders AS (
17    SELECT
18        'shopline' AS platform,
19        order_id AS platform_order_id,
20        created_at,
21        total_amount AS order_total_local,
22        currency AS local_currency,
23        payment_status,
24        shipping_status AS fulfillment_status,
25        shipping_country_code AS ship_country
26    FROM {{ source('raw', 'shopline_orders') }}
27),
28
29adobe_orders AS (
30    SELECT
31        'adobe_commerce' AS platform,
32        entity_id AS platform_order_id,
33        created_at,
34        grand_total AS order_total_local,
35        order_currency_code AS local_currency,
36        status AS payment_status,
37        CAST(NULL AS STRING) AS fulfillment_status,
38        shipping_country_id AS ship_country
39    FROM {{ source('raw', 'adobe_commerce_orders') }}
40)
41
42SELECT
43    *,
44    order_total_local * fx.rate_to_usd AS order_total_usd
45FROM (
46    SELECT * FROM shopify_orders
47    UNION ALL
48    SELECT * FROM shopline_orders
49    UNION ALL
50    SELECT * FROM adobe_orders
51) orders
52LEFT JOIN {{ ref('fx_rates_daily') }} fx
53    ON orders.local_currency = fx.currency_code
54    AND DATE(orders.created_at) = fx.rate_date

The fx_rates_daily model is critical for APAC operations. We pull daily exchange rates from the European Central Bank's free API and load them into a reference table. According to the Bank for International Settlements, the USD/SGD pair alone sees average daily turnover of USD 119 billion (BIS Triennial Survey, 2022), which underscores how much even small FX fluctuations can distort cross-market comparisons if you don't normalize.

Create a mart model for the dashboard:

1-- models/marts/mart_realtime_operations.sql
2
3SELECT
4    DATE_TRUNC(created_at, HOUR) AS hour_bucket,
5    platform,
6    local_currency AS market_currency,
7    {{ detect_apac_market('ship_country') }} AS market,
8    COUNT(*) AS order_count,
9    SUM(order_total_usd) AS gmv_usd,
10    AVG(order_total_usd) AS aov_usd,
11    COUNTIF(payment_status = 'paid') AS paid_orders,
12    COUNTIF(payment_status IN ('pending', 'authorized')) AS pending_orders,
13    COUNTIF(fulfillment_status = 'fulfilled') AS fulfilled_orders
14FROM {{ ref('stg_unified_orders') }}
15WHERE created_at >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 48 HOUR)
16GROUP BY 1, 2, 3, 4

How to Design the Dashboard for Multi-Market Visibility

We recommend Grafana 10.x or Metabase 0.49+ for the visualization layer. Both connect natively to BigQuery, PostgreSQL, and ClickHouse. Grafana is stronger for operational monitoring with alerting; Metabase is better if non-technical team members need self-service access.

Essential Dashboard Panels for APAC E-Commerce

Panel 1: Live Orders Heatmap by Market

• Metric: Orders per minute, grouped by APAC market
• Purpose: Instantly spot if a market goes quiet (possible checkout failure)
• Refresh interval: 30 seconds

Panel 2: GMV by Currency (Normalized to USD)

• Metric: Running 24-hour GMV with hourly granularity
• Purpose: Cross-market revenue comparison without currency distortion
• Include: Local currency GMV as a secondary axis for market managers

Panel 3: Inventory Alerts

• Metric: SKUs below reorder threshold by warehouse location
• Purpose: Prevent stockouts during cross-border fulfillment delays
• Note: APAC cross-border shipping times vary from 2 days (HK→SG) to 14+ days (AU→PH via standard post), per Australia Post's published service standards

Panel 4: Payment Gateway Health

• Metric: Success/failure rate by payment provider and market
• Purpose: APAC markets use diverse payment methods—GrabPay in SEA, LINE Pay in Taiwan, PayNow in Singapore. Monitor each independently.

Panel 5: Fulfillment Pipeline

• Metric: Orders by status (unfulfilled → processing → shipped → delivered)
• Purpose: Identify bottlenecks in specific markets or warehouses

Here's a sample Grafana dashboard provisioning config:

1# grafana/dashboards/apac-ecommerce-ops.yaml
2apiVersion: 1
3providers:
4  - name: 'APAC E-Commerce Operations'
5    orgId: 1
6    folder: 'E-Commerce'
7    type: file
8    disableDeletion: false
9    updateIntervalSeconds: 30
10    options:
11      path: /var/lib/grafana/dashboards/apac-ecommerce
12      foldersFromFilesStructure: true

For the live orders panel, use this BigQuery query in Grafana:

1SELECT
2  TIMESTAMP_TRUNC(created_at, MINUTE) AS time,
3  market,
4  COUNT(*) AS orders_per_minute
5FROM `your_project.analytics.mart_realtime_operations_live`
6WHERE created_at >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 2 HOUR)
7GROUP BY 1, 2
8ORDER BY 1 DESC

How to Handle Time Zones Across APAC Markets

Time zone handling is where many APAC dashboards break. Your Hong Kong team (UTC+8) shouldn't have to mentally convert timestamps when looking at Australian Eastern Time (UTC+10 or UTC+11 during daylight saving) data.

Two rules that prevent confusion:

Rule 1: Store everything in UTC. All timestamps in your data warehouse should be UTC. No exceptions.

Rule 2: Convert at the presentation layer. In Grafana, set the dashboard timezone to "Browser" so each user sees data in their local time. For shared screens in operations centers, set it to the team's local timezone explicitly.

For market-specific reporting, create a dbt macro:

1-- macros/convert_to_market_tz.sql
2{% macro convert_to_market_tz(timestamp_col, market_col) %}
3  CASE {{ market_col }}
4    WHEN 'HK' THEN TIMESTAMP({{ timestamp_col }}, 'Asia/Hong_Kong')
5    WHEN 'SG' THEN TIMESTAMP({{ timestamp_col }}, 'Asia/Singapore')
6    WHEN 'TW' THEN TIMESTAMP({{ timestamp_col }}, 'Asia/Taipei')
7    WHEN 'AU' THEN TIMESTAMP({{ timestamp_col }}, 'Australia/Sydney')
8    WHEN 'NZ' THEN TIMESTAMP({{ timestamp_col }}, 'Pacific/Auckland')
9    WHEN 'PH' THEN TIMESTAMP({{ timestamp_col }}, 'Asia/Manila')
10    WHEN 'MY' THEN TIMESTAMP({{ timestamp_col }}, 'Asia/Kuala_Lumpur')
11    WHEN 'VN' THEN TIMESTAMP({{ timestamp_col }}, 'Asia/Ho_Chi_Minh')
12    WHEN 'ID' THEN TIMESTAMP({{ timestamp_col }}, 'Asia/Jakarta')
13    ELSE {{ timestamp_col }}
14  END
15{% endmacro %}

Be aware that New Zealand and parts of Australia observe daylight saving time while most Southeast Asian and East Asian markets do not. This creates a shifting time difference that affects period-over-period comparisons.

What Did We Learn Building This for a Multi-Market Retailer?

In late 2023, Branch8 built a real-time operations dashboard for a fashion retailer running Shopify Plus stores in Hong Kong and Singapore alongside a SHOPLINE store in Taiwan. The client's operations team was manually checking three separate admin panels and consolidating numbers in Google Sheets every morning—a process that took roughly 90 minutes and was always stale by the time it was done.

We deployed the webhook-to-Pub/Sub-to-BigQuery pipeline described above, with dbt Cloud handling transformations on a 15-minute schedule (a trade-off: true real-time via streaming would have tripled infrastructure costs for a business doing ~2,000 orders/day). The Grafana 10.2 dashboard went live in six weeks, covering GMV, fulfillment status, inventory levels, and payment health across all three markets.

The biggest technical hurdle was SHOPLINE's webhook delivery reliability—we observed approximately 3-5% of webhooks arriving with delays exceeding 60 seconds during peak sale periods. We mitigated this with a reconciliation job that polls the SHOPLINE Orders API every 10 minutes and backfills any missed events. Within the first month, the client's ops lead reported that the morning reporting ritual dropped from 90 minutes to a 10-minute dashboard review, and they caught two payment gateway issues in Singapore within minutes that would previously have gone unnoticed for hours.

What Are the Common Pitfalls to Avoid?

Pitfall 1: Ignoring Data Residency Requirements

Several APAC jurisdictions have data localization rules. Vietnam's Cybersecurity Law (2018) requires certain data to be stored locally. Indonesia's Government Regulation No. 71 of 2019 mandates local data processing for public-facing electronic systems. According to the Information Technology & Innovation Foundation, at least 62 countries have enacted data localization measures as of 2024 (ITIF, 2024). Check where your data warehouse lives relative to your customer data.

Pitfall 2: Over-Engineering for Sub-Second Latency

Most e-commerce operations decisions don't require sub-second data. A 1–5 minute delay is perfectly acceptable for inventory monitoring and revenue tracking. Reserve sub-second architectures for fraud detection or dynamic pricing—use cases where latency directly costs money.

Pitfall 3: Building Dashboards Nobody Opens

A dashboard that isn't embedded in daily workflows gets ignored. Set up Grafana alerts that push to Slack, Microsoft Teams, or LINE (widely used in Taiwan and Japan) when critical thresholds are breached—like order volume dropping more than 40% compared to the same hour last week.

Pitfall 4: Forgetting Tax Complexity

APAC tax rules differ significantly. Australia's GST (10%), Singapore's GST (9% as of January 2024, per IRAS), Taiwan's VAT (5%), and the varying VAT rates across Southeast Asia all affect your true revenue numbers. Make sure your dashboard can toggle between gross and net revenue views.

How to Deploy and Maintain the Dashboard Long-Term

Once built, the dashboard needs ongoing care:

• Schedule dbt model tests to run every hour. Use dbt test with custom assertions like order count sanity checks (e.g., if any market shows zero orders during business hours, flag it).
• Monitor webhook delivery with a simple heartbeat: send a test event every 5 minutes and alert if it doesn't arrive within 30 seconds.
• Update FX rates daily via a scheduled Cloud Function that pulls from the ECB or Open Exchange Rates API.
• Review and prune dashboard panels quarterly. According to a Databox survey, companies with 5–10 KPIs per dashboard have 28% higher user engagement than those with 20+ (Databox, 2023).
• Version-control everything: dbt models in Git, Grafana dashboards as JSON via provisioning, and infrastructure as Terraform configs.

A well-maintained real-time analytics dashboard becomes the operational nervous system for APAC e-commerce. It lets you make staffing decisions based on actual order velocity, catch platform issues before customers tweet about them, and give each market manager visibility into their performance without waiting for a weekly report.

Branch8 builds and manages real-time analytics infrastructure for e-commerce operations across Asia-Pacific. If you're running multi-market stores on Shopify Plus, Adobe Commerce, or SHOPLINE and need unified operational visibility, talk to our engineering team at branch8.com about a scoped implementation.

Sources

• Statista — E-commerce Revenue in Asia-Pacific: https://www.statista.com/outlook/emo/ecommerce/asia
• BIS Triennial Central Bank Survey (2022): https://www.bis.org/statistics/rpfx22.htm
• Shopify Admin API Webhook Documentation: https://shopify.dev/docs/api/admin-rest/2024-10/resources/webhook
• SHOPLINE Open API Documentation: https://developer.shoplineapp.com/
• ITIF — Data Localization Measures (2024): https://itif.org/publications/2024/03/04/how-barriers-cross-border-data-flows-are-spreading-globally/
• Inland Revenue Authority of Singapore — GST Rate Change: https://www.iras.gov.sg/taxes/goods-services-tax-(gst)/gst-rate-change
• Databox — Dashboard KPI Best Practices: https://databox.com/kpi-dashboard-best-practices
• Debezium Documentation (2.5): https://debezium.io/documentation/reference/2.5/