Introduction to Satori

A live game generates signals continuously. Running LiveOps at scale comes down to solving four problems: targeting the right players with the right content at the right moment; escaping the operational drag of a fragile stack of stitched-together tools; moving at the speed of player behaviour shifts with live updates; and knowing with confidence which changes are actually moving your metrics.

These four capabilities are what Satori is built to deliver: precise lifecycle intervention, a unified operational platform, real-time configuration, and evidence-based iteration.

Satori is the LiveOps platform from Heroic Labs, giving game studios a single place to understand their players, deliver live content at scale, and personalise every experience. The mental model behind Satori is simple: events → player properties → audiences → personalized experience.

Satori has three main interfaces:

  1. A browser-based console your LiveOps team uses. All operations (configuring events, adjusting targeting, reading results) are fully managed via the console with no engineering involvement.
  2. A client SDK your engineering team integrates.
  3. A console API for server-to-server communication, letting you manage Satori configuration programmatically.

Key capabilities #

Segmentation

  • Build audiences from behavior, spend, device, location, or custom game attributes
  • Unlimited number of segments
  • Segments update as players send events in near real-time

Remote configuration

  • Update any game parameter without client updates
  • Serve different configurations to different player segments
  • Unlimited number of feature flags and variants

Live events

  • Plan and schedule from a bird's-eye event calendar
  • Override feature flags to deliver custom variants per live event
  • Require explicit join for opt-in events and retain enrolled players with sticky membership

Experiments

  • Run A/B tests with sequential phases, adjusting variant split or values
  • Set metrics to track outcomes and catch side effects
  • Cap participants, set an admission deadline, or lock enrollment mid-experiment

Player messaging

  • Deliver messages through the in-game inbox, push notifications, or email
  • Personalize with player properties and multi-language translations
  • Tie delivery to live event timing

Performance monitoring

  • Track D1-D30 retention out of the box
  • Define any custom metric once and apply them across operations
  • Measure RoAS per cohort, filterable by channel, campaign, country, and experiment variant

Satori at a glance #

Satori ingests analytic events from your game client at high throughput. Each event updates event-derived player properties, which in turn drive segment membership. Segments stay current continuously: as players send events, their membership is recomputed so targeting always reflects the latest player state.

When a player requests their active live events, experiments, or feature flags, Satori evaluates eligibility at that moment against their current computed state, delivering the most up-to-date assignment every time.

Satori provides integration to your existing infrastructure:

  • Data export: All events remain available in their raw format and can be exported into your existing data lake such as BigQuery, Snowflake, and Databricks.
  • Push notifications: Firebase FCM, Apple APNS, and OneSignal for out-of-game player messaging
  • Managed audiences: Import segment data from your existing analytics platform and use it as a targeting source directly in Satori

Diagram of the Satori system architecture. Two entry points connect to the Satori backend: the Satori Console API, used by operators to configure and manage the platform, and the Game Client SDK, integrated in the game. The game client sends analytic events to the backend. In return, the backend sends live events, feature flags, and remote configs to the game client. The Satori backend processes incoming events, computes player properties, and evaluates audience membership to determine which content each player receives.

How Satori works

The full LiveOps lifecycle, in one place #

Satori covers the full operational lifecycle in a single platform. Player events captured by the SDK feed the audience computation that determines who enrolls in a live event, which feature flag values they receive, and which experiment variant they are assigned. The live event calendar gives your team a bird’s-eye view of everything scheduled and active. While an event runs, remote configuration lets you mutate reward values, flag overrides, or targeting in real time with no code deploy. When it ends, performance data flows back into the same system, ready to inform the next campaign.

The six stages of the Satori LiveOps lifecycle shown in sequence: Target, Configure, Test, Launch, Operate, and Analyze. Each stage lists the Satori capabilities available at that point in the workflow.

How Satori supports each stage of LiveOps

How Satori is different #

Bring your own data model #

Feature flags power remote configuration in Satori. You define the schema for each flag: the fields and types that represent a meaningful unit of your game world. A flag can carry a complete reward configuration, a set of difficulty parameters, or a shop layout. Experiments and live events then serve variants of that schema to targeted player segments.

Event capture at high throughput #

Send analytic events and their associated properties for ingestion and analysis in Satori via the provided client SDKs. You can propagate events from Nakama automatically to have a full view of user activity, and receive events from any third-party systems you have in place.

One connected player data layer #

Satori maintains a robust identity for every player, combining default properties with custom properties and computed properties generated from your game events. These properties are the foundation of your segmentation, defining the audiences you target with content, offers, and experiments.

All of this is visible in the identity’s behavior stream, where you can view all captured events, edit properties, and see which audiences the player belongs to, which experiments they’re enrolled in, and which feature flags and remote configs apply to them.

Segment data that stays up to date #

Satori recomputes all audiences every 10 minutes by default. When a player sends a game event, their segment membership updates immediately. Live events and feature flags check a player’s eligibility at the moment they make a request.

Measure the impact of your operations #

Define a metric once and apply it to any experiment, feature flag, or live event. Scope a retention report to players in a specific experiment variant, or filter your return on ad spend report to a single live event. No separate analytics platform required.

Next steps #

If you don’t use Satori yet, contact us to start adding LiveOps capabilities to your game.
  1. Integrate Satori into your game by following the get started guide.
  2. Explore each capability in more depth: segmentation, remote configuration, live events, experiments, player messaging, and performance monitoring.
  3. Check the client libraries to start developing your game client.
  4. Browse the console API reference for server-to-server communication endpoints.

Need help? Get in touch with the Heroic Labs team.