Platform · Blocks · Event Collection
Every touchpoint.
One live stream.
Client-side SDKs and server-side connectors capture fan signals across web, app, ticketing, streaming, on-site, and offline — then normalize, validate, and type every event the moment it arrives. No custom ETL, no nightly cleanup.
- Typed events
- Schema-validated
- Real-time
- Your warehouse
Playable · The firehose
Switch sources on.
Watch clean events come out.
This is a live simulation of the collection layer. Toggle sources, inject a broken payload, and watch the schema gate do the job a nightly cleanup job used to do.
01 · Sources
Six connectors, one framework. Flip a source off and watch its color leave the stream — that is the whole integration effort.
02 · Normalize → validate → type
listening on 5 sources…
03 · One typed stream
Typed events land here the moment they clear the gates…
Simulated live — every number on this panel is from this demo.
A signal that fails the schema never touches your graph. It bounces here, with the reason attached — not in a warehouse table next quarter.
How event collection works
From every touchpoint
to one normalized stream
Signals arrive messy — different SDKs, different payloads, different clocks. Blocks turns all of it into one typed, validated stream before anything touches your graph.
-
01
Open connector framework
Ingest events from web, app, ticketing, streaming, on-site, and offline sources without custom ETL. Raw payloads are normalized and validated as they arrive.
-
02
Real-time ingestion
Events are captured and processed as they happen, not batched overnight. Fan signals reach your identity graph immediately, so recognition and response happen in real time.
-
03
Schema validation
Every event is validated against a typed schema as it arrives, so graph hygiene is enforced on the way in rather than repaired by nightly cleanup jobs.
-
04
No parallel databases
Events flow directly into your Sfere warehouse. No vendor silo to sync or reconcile with your sources: one normalized event stream, one resolved graph.
Under the hood
Anatomy of an event,
before and after
A real raw payload from a ticketing app — and what it becomes after the normalizer runs. Press the button and watch each field find its place.
Before · raw payload
{"ev":"scan","uid":"c_8f2",
"t":1739482621,"src":"app_v3",
"seat":"A-114","px":"49.5"}
five fields · no types · epoch time · who knows what "px" is
- ev→event: ticket.scan · typed
- uid→user_id: c_8f2 · string
- t→timestamp: 2026-02-13T19:43:41Z · UTC
- seat, px→properties: seat · price_usd · typed
- src→source: ticketing/app v3 · connector
Validation happens on arrival — so "repair" is a job nobody has to run.
One framework, every source
- Web SDK
- iOS SDK
- Android SDK
- Ticketing API
- Streaming
- POS / On-site
- Offline import
- Webhooks
New sources land as connectors, not projects — the schema gate treats them all the same.
Why it matters
The source of truth for
real-time response
Fan data is most valuable the moment it arrives. Blocks captures every signal in real time, so your identity graph updates instantly, segmentation responds immediately, and activation can act within seconds of a fan interaction.
See how signals are resolved- Reduce time-to-insight from days to seconds by capturing signals as fans act.
- Lower integration cost with a shared connector framework instead of custom ETL per source.
- Improve data quality by validating schemas on arrival rather than patching errors downstream.
- Maintain data ownership by storing events in your environment, not a vendor platform.
Capture every signal your fans already send
See Blocks collect, validate, and stream events from your own sources — web, app, ticketing, and on-site — into one typed stream. Book a walkthrough and we'll map it to your stack.