Fictional Case Study: Global Retailer Loyalty App
A global retailer has a wildly popular loyalty app. Their engineering team has a strict rule: no third-party SDKs in the mobile app. They want to keep the app lean, preserve cold-start performance, and minimize risk.
Meanwhile, the marketing team already thrives with Tealium on the web with governed data, rapid activation to hundreds of integrations, and real-time audiences. Their ask: “How do we bring the same Tealium benefits to mobile without installing an SDK?”
Use case
When a user scans a receipt in-app, award points and notify them within seconds while instantly suppressing them from paid retargeting to save budget. That demands real-time streaming into Tealium.
Three SDK-Free Ways to Send Mobile Events to Tealium
Option 1 — Direct App → Tealium Collect API
The app POSTs JSON events straight to Tealium’s Collect endpoint for the fastest possible path into EventStream/AudienceStream.
Pros
- Lowest latency
- Simple and direct
- Works natively with Live Events, Event Specs, Trace
Cons
- Adds another network call from the app
- The mobile team owns the API integration
Option 2 — Backend/Gateway Forwarding → Tealium Collect
The app only talks to APIs you control. From there, your backend (e.g., via Kafka/Confluent) or API gateway (via a mirrored request) forwards events to Tealium in real time.
Pros
- No additional outbound calls from the app
- Centralized retries, auth, and transformations
- Strong governance with low latency
- Flexible: works with either backend services or gateway mirroring
Cons
- Requires a connector/service or gateway config
- Must maintain identity and schema discipline end-to-end
Option 3 — Warehouse Import (Snowflake → Tealium)
If mobile events already land in Snowflake, import them to Tealium for activation and profile enrichment.
Pros
- Leverages existing pipelines and governance
- Great for enrichment and historical backfill
- Simple mapping to stitch identities
Cons
- Latency is tied to CDC/polling, which is not ideal for in-app instant reactions
- Best for near-real-time or batch activation
The Fictional Retailer’s Choice (And Why)
In this fictional case study, the retailer chose Option 2: Backend/Gateway Forwarding → Tealium Collect.
This option struck the balance both teams needed. Engineering was able to keep the app uncluttered, free of third-party SDKs, and limited to a single outbound call to their own backend. That preserved performance budgets, protected app stability, and ensured compliance with internal IT governance policies.
On the other side, the marketing team gained real-time access to mobile app events through Tealium EventStream, our event collection and API hub, and AudienceStream, our real-time customer data platform for building and activating audiences. This gave them the same control they enjoyed on web: the ability to define event specs, stitch identities, and activate audiences in the moment. A scanned receipt could instantly trigger a reward confirmation push notification and simultaneously remove that user from paid retargeting campaigns.
This choice gives business users real-time power without forcing development teams into compromises they aren’t willing to make.
Implementation Outline
1. Data model & quality
- Define `receipt_scanned`, `receipt_validated`, and `wallet_credited` with Event Specs. Use Live Events to verify payloads.
2. Identity
- Carry your first-party user/device ID through to Tealium and map it to a Visitor ID attribute in AudienceStream for real-time audience evaluation.
3. Forwarding pattern
- Backend route: App → API → (optional) Kafka → HTTP sink/microservice → Tealium Collect (token-based auth as needed).
- Gateway route: API Gateway mirror posts normalized JSON to Tealium Collect asynchronously.
4. Real-time audiences & actions
- “Receipt Scan → Credit Pending” – Email / SMS
- “Credit Confirmed (last 3 min)” – Update user experience
Projected Results
By forwarding events from their backend to Tealium, the fictional retailer expected several key benefits. First, application performance would remain pristine, since the mobile app was shielded from any additional calls to third parties. All the complexity lived server-side, where retry logic, authentication, and payload transformation could be controlled centrally.
Second, the marketing team would now have real-time levers at their disposal. AudienceStream would segment users within milliseconds of a receipt scan, enabling timely and relevant engagement. The retailer could notify customers that their points had been posted almost immediately, reinforcing loyalty and encouraging repeat use. At the same time, ad budgets would be used more efficiently, as newly converted customers would be suppressed from re-marketing lists immediately.
Finally, the IT and data teams would gain stronger oversight. Using Tealium’s Event Specs, Live Events, and Trace, they could monitor incoming events, validate payloads, and troubleshoot the pipeline without waiting on developers to add custom logs or metrics. This alignment across marketing, IT, and engineering was a major cultural win as well as a technical one.
Where Option 3 (Snowflake) Shines
While the retailer chose a real-time forwarding option, the Snowflake import path has its own compelling advantages, particularly when real-time speed isn’t the primary driver.
For example, if the business wants to enrich customer profiles with calculated values, such as lifetime value, churn risk, or propensity scores generated within the warehouse, Snowflake to Tealium becomes the natural choice. It also excels at historical backfills, such as when the marketing team wants to retroactively build audiences based on months of past in-app behavior.
Snowflake is also a strong candidate for near-real-time activations, where a few seconds of delay are acceptable. Many downstream channels, such as email campaigns or nightly retargeting updates, don’t require sub-second responsiveness. In those cases, leveraging existing data pipelines and governance structures in Snowflake allows teams to maximize efficiency while still keeping data flowing into Tealium.
In short, Snowflake isn’t the answer when you need an instant “scan then send push” experience, but it is a powerful complement to real-time paths when enrichment, backfill, or governed batch delivery are the priority.
Key takeaways
- Even without an SDK, mobile apps can stream events to Tealium in real time.
- You can send data directly from the app or route through your backend/gateway for more control.
- Warehouse imports from systems like Snowflake shine when enrichment or historical data is needed, but are less suited for in-the-moment reactions.
- Tealium’s flexibility ensures you can align with your architecture, governance, and performance requirements without compromise.
Conclusion
This fictional case study shows that SDK restrictions don’t have to limit innovation. Tealium offers multiple ways to bring mobile data into the platform, whether through our robust SDKs, direct app calls, backend/gateway forwarding, or warehouse imports.
The real value lies in Tealium’s flexibility. Whatever your architecture, compliance posture, or performance requirements, you can design an approach that keeps engineering happy, satisfies IT governance, and still empowers marketing to deliver real-time, personalized, and measurable experiences.
