About Tealium Prism

Overview

Tealium Prism is the mobile SDK for iOS (Swift) and Android (Kotlin), designed as a fully native, reactive event pipeline. Instead of wiring each vendor SDK separately, you instrument a single, unified event API in your app and let Prism deliver those events to Tealium Collect and supported third‑party SDKs. This reduces implementation effort, keeps data consistent across tools, and gives you far more control over how mobile data is collected and activated.

Prism replaces the legacy webview‑driven model with a 100% native architecture and a custom event pipeline optimized for mobile throughput.

A native rules engine, dispatchers, and barriers manage when and where events are delivered. For example, throttling Collect traffic when offline while continuing to send events to local SDKs that handle their own queuing.

Configuration is driven by JSON (for example, from Tealium iQ), so many aspects of behavior can be tuned per environment without a new app release.

At a glance, Prism provides:

• Unified event API: A single, consistent event API for Swift and Kotlin with near‑identical concepts and naming.
• Multi‑dipatcher pipeline: Send the same event to Tealium Collect, on‑device vendor SDKs, and future destinations in parallel.
• Rules engine and barriers: Control event delivery based on connectivity, batching, consent, or other conditions.
• On‑device transformations: Modify, enrich, or filter event payloads before they leave the device, with the ability to update logic without an App Store / Play Store release.
• Configuration model: A configuration model designed for consent‑aware behavior and environment‑specific settings.

Prism vision and goals

The name Prism captures the core idea behind the new architecture. In optics, a prism takes a single beam of light and refracts it into a spectrum of colors. In the same way, the Tealium Prism SDK lets you maintain one clean stream of events using a unified API, then “refract” those events into multiple destinations such as Tealium Collect, on‑device vendor SDKs, and future outputs.

Prism is engineered as a developer toolbox to reduce workload, improve data quality, and unlock post‑deployment flexibility:

• Workload reduction: Implement tracking once and fan it out to Tealium and supported SDKs, instead of maintaining separate code paths per vendor.
• Data consistency: A single event definition ensures each destination receives the same high‑quality payloads, improving reporting alignment across tools.
• Post‑deployment agility: Native and (future) JavaScript‑based Transformations allow you to correct mappings, rename events, or adjust payloads without pushing a new app build.
• Performance and reliability: A 100% native, reactive pipeline eliminates the legacy webview dependency, reduces memory and battery impact, and avoids single‑queue bottlenecks when one destination is slow or offline.
• Cross‑platform parity: Swift and Kotlin implementations share near‑identical logic and naming so mobile teams can operate with a single mental model across iOS and Android.

Looking ahead, the Prism vision extends beyond basic event delivery. The roadmap includes native adapters for popular consent management platforms, richer configuration controls in Tealium iQ, JavaScript‑driven Transformations, deeper Moments and Moments iQ integration, and hooks for on‑device intelligence such as ML‑driven recommendations and in‑app experiences. Prism is intended to be the long‑term foundation for Tealium’s mobile ecosystem, giving you a modern, extensible base to build on as new channels, privacy rules, and activation patterns emerge.

Core architecture

Prism is built for performance and maintainability, moving away from web-dependent logic to a fully native, unified approach.

Native runtime
Prism eliminates legacy dependencies on WKWebView. All logic runs in a 100% native environment, powered by a custom rules engine and JSON configurations. This delivers a smaller memory footprint and improved battery efficiency, leveraging specialized reactive frameworks for high-throughput event processing.

Parity between Swift and Kotlin
Both the Swift and Kotlin SDKs share nearly identical logic and naming conventions. This code parity enables mobile teams to manage iOS and Android implementations with a single mental model, reducing onboarding time and minimizing platform-specific discrepancies.

Event control

Barriers are rules that control when and how events are delivered to each destination, enabling precise management of event flow.

Previously, legacy SDKs used a single event queue and if one destination was offline, all event delivery paused. With Prism, each dispatcher operates independently, and barriers can be set per destination, allowing parallel processing and minimizing bottlenecks.

For example, Tealium Collect uses connectivity and batching barriers to optimize bandwidth and ensure reliable delivery. Third-party SDKs receive events in real time, even when offline, so they can manage their own queues.

Native transformations

Use native transformations to modify event payloads directly in Swift or Kotlin before they leave the device using custom transformation logic or built-in Tealium iQ extensions. Native transformations are ideal for correcting data issues or updating logic without an app update.

Configuration governance

Prism offers a three-tier configuration system to help prevent misconfiguration and maintain app integrity. Settings are merged in a specific priority order that ensures critical or security-sensitive settings cannot be accidentally overridden by lower-priority sources. .