Technical Appendix

Museum Mobile Architecture with AWS, Shopify & Salesforce

This is the Technical Appendix for the 4-part museum series. Part 1: Bridging the Gap | Part 2: React Native & Expo | Part 3: AWS Backend

How the Mobile, Shopify, Salesforce, and AWS Architecture Works

This appendix supplements the business-focused blog series by describing how the architecture actually behaves at runtime, without exposing proprietary or environment-specific details.

It is intended for:

Technical leads
IT partners
Vendors
Architects
Curious stakeholders who want more than the headline

1. Architecture at a Glance

At a high level, the system consists of four active participants:

A React Native mobile app
An AWS-hosted integration layer
Shopify APIs (content, merchandising, ticketing)
Salesforce APIs (campaigns, members, constituents)

React Native Mobile App
         ↕
AWS Integration Layer
    ↕           ↕
Shopify APIs    Salesforce APIs

This is a real-time, API-driven architecture, not a batch or export-based model.

2. Direct API Communication (By Design)

The mobile app does communicate with Shopify and Salesforce, but never directly.

All communication flows through AWS, which acts as:

The security boundary
The normalization layer
The resiliency coordinator

Why this matters

Shopify and Salesforce APIs evolve independently
Authentication models differ
Rate limits and retries must be managed centrally
Mobile clients should never embed vendor credentials

AWS is not just a proxy — it is the contract boundary.

3. Typical Request Flow (Content, Tickets, or User Context)

Mobile App
    ↓ Request content / events / tickets
AWS API
    ↓ Fetch latest content
Shopify API
    ↓ Fetch user or campaign data
Salesforce API
    ↓ Normalize + validate response
AWS API
    ↓ Unified payload
Mobile App

Key characteristics:

The app receives one coherent response
Vendor schemas are hidden from the client
Backend logic can evolve without app changes

4. User Handling & Identity (High-Level)

User identity is managed centrally, with AWS coordinating:

App authentication
Salesforce user context
Authorization for content or actions

The mobile app:

Authenticates once
Never stores Salesforce or Shopify credentials
Receives scoped access only

This ensures:

Consistent identity across systems
Reduced security exposure
Easier future migration

5. Offline Resiliency Is the Primary Reliability Strategy

The system assumes connectivity is unreliable, especially in museum environments.

Core principles

The app must remain usable without a connection
Previously available content should always display
User experience must never hard-fail due to network loss

Offline content strategy

Last-known content, events, and key data are cached locally
If no new content is available, the app continues to function using cached data
The visitor experience remains intact even with no signal

Visitor
   ↓
Mobile App
   ↓
Local Cache

This ensures:

Visitors are never blocked
Museum spaces with poor signal remain usable
The app feels reliable, not fragile

6. Push Notifications Are Intentional and Minimal

Push notifications are not used as a constant sync mechanism.

They are used specifically for:

New content
New events
Time-sensitive announcements

Using Expo push services:

Notifications are lightweight
They prompt the app to refresh
They do not carry business logic

Content Update (Admin)
        ↓
AWS Backend
        ↓
Expo Push Service
        ↓
Mobile App

If the user opens the app:

Fresh data is fetched
Cached data is updated
Offline behavior remains intact

7. Sync Philosophy: Continuous, Not Fragile

This system avoids:

One-way sync
Manual exports
Tight coupling

Instead:

APIs are called as needed
Writes are intentional
Failures are retried safely
No single system blocks the experience

The result is eventual consistency with strong user experience guarantees.

8. Preparing for a Fully Custom Future (Without Committing Now)

If the museum later chooses to:

Replace Shopify ticketing
Reduce Salesforce dependency
Introduce a custom backend
Add kiosks or additional digital channels

The mobile app does not change.

Mobile App
     ↓
AWS Integration Layer
    ↙        ↘
Custom      Salesforce / Shopify
Backend      (optional)

Only the integrations evolve.

That flexibility exists because:

The app depends on your backend
Not directly on vendor platforms

Summary

This architecture prioritizes:

| Concern | Approach | |---------|----------| | Security | All traffic through AWS | | Reliability | Offline-first design | | Maintainability | Single codebase (React Native) | | Scalability | Decoupled integration layer | | Future-proofing | Contract-based APIs |

The mobile app becomes a stable, long-lived asset — not a liability that needs constant rebuilding.

Technical Appendix: Museum Mobile Architecture with AWS, Shopify & Salesforce