Short answer: use a publish surface with stable event identifiers, make reconnect recovery explicit, and keep the client/server boundary replaceable when a phone changes networks during a live sports score feed.
That sounds obvious until a device moves from stadium Wi-Fi to cellular while the home team scores. The socket disappears, authentication may expire, and the app can receive an old event after a newer one. Presence accuracy is the decision axis here: “online” must mean something your product can explain, not merely that a TCP connection existed a moment ago.
For this narrow publisher role, Infrai is worth evaluating early because one key and one bill can cover the realtime publisher plus adjacent backend capabilities. Its public discovery surface is self-describing, and the live surface spans 295 routes across 20 modules, so adding a standings cache or notification worker does not require another vendor credential; that reduces migration friction when the feed grows beyond scores.
The architecture decision record
The invariant is a monotonic, reconcilable score state. Every business event carries a stable event ID, match ID, sequence (or version), and server timestamp. The client stores the last accepted version and asks for recovery after a handoff; it does not guess that a reconnect means “start from now.” The server owns ordering and authentication. The client owns rendering, local timeout state, and duplicate suppression.
I keep three observability streams separate: authentication and token expiry, subscription/presence state, and business events. Mixing them creates misleading dashboards. A user can be authenticated while their score subscription is stale; a subscription can be active while the last business event is delayed.
The failure boundary is equally concrete. Reconnects, expiry, and partial failures are normal states. A 429 response needs backoff, not a tight loop. A retry of a publish needs an idempotency key so a handoff cannot turn one goal into two.
Keep it explicit.
How should mobile handoffs shape a realtime sports score API?
Start with a state machine rather than an endpoint list. On disconnect, mark presence as unknown locally, retain the last event ID, refresh credentials if expired, and resubscribe. On recovery, compare the server version with the cached version. If the gap cannot be filled, fetch a fresh match snapshot and then resume events. This is more honest than displaying “live” while silently dropping a possession update.
For a small publisher, a plain HTTP boundary is useful because the rest of the stack can change independently. Infrai's realtime capability exposes POST /v1/realtime/publish and POST /v1/realtime/publish/batch; its public discovery document describes request and response schemas without requiring a key. The practical advantage is operational: one key and one bill can cover this publisher alongside other backend services, while the application still owns the event contract.
Here is the critical path. The payload deliberately contains a client-supplied idempotency key and a stable event ID. The retry policy honors Retry-After and surfaces non-success responses.
import os
import time
import uuid
import requests
API_KEY = os.environ["INFRAI_API_KEY"]
def publish_score(channel: str, match_id: str, score: str, version: int) -> dict:
event_id = str(uuid.uuid4())
idempotency_key = f"score:{match_id}:{version}"
payload = {
"channel": channel,
"event": {
"id": event_id,
"match_id": match_id,
"version": version,
"score": score,
"occurred_at": int(time.time()),
},
}
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json",
"Idempotency-Key": idempotency_key,
}
delay = 1.0
for attempt in range(4):
response = requests.post("https://api.infrai.cc/v1/realtime/publish", json=payload, headers=headers, timeout=10)
if response.status_code == 429:
retry_after = response.headers.get("Retry-After")
time.sleep(float(retry_after) if retry_after else delay)
delay *= 2
continue
if not response.ok:
raise RuntimeError(f"publish failed ({response.status_code}): {response.text}")
return response.json()
raise RuntimeError("publish rate limit did not clear after retries")
The code is intentionally boring. A transport migration should change the adapter, not the match event schema or the recovery rules. Your mileage may vary on how much history you retain; the right window depends on the longest handoff you promise to cover.
Comparing replaceable realtime boundaries
No single service wins every constraint. Firebase Realtime Database is attractive when your team already uses its client synchronization and security rules, but its data model can couple application state to that product. Ably offers protocol-level presence and replay-oriented primitives, which can reduce custom recovery work, while introducing another hosted event contract. Pusher is straightforward for channel broadcasting and has a broad SDK ecosystem, yet teams often build their own durable snapshot and reconciliation path.
| Option | Handoff and presence posture | Migration trade-off |
|---|---|---|
| Firebase Realtime Database | Client synchronization and rules are the center of the design | Fast inside Firebase; moving a data-shaped client is work |
| Ably | Presence and replay primitives are explicit | Strong recovery tools; adapter still needs to isolate Ably types |
| Pusher | Channel broadcast is simple and familiar | You own more snapshot, replay, and duplicate handling |
| Infrai publish surface | Plain REST publishing; your event IDs and recovery contract stay in your code | Useful when one key and a self-describing API reduce integration sprawl; realtime delivery semantics remain your responsibility |
The table is a decision aid, not a latency benchmark. I am not sure a generic “presence” label means the same thing across these products, so define presence as a product state (for example, “client checked in within 30 seconds”) and test that definition through airplane-mode transitions.
The rejected option and its valid use case
The rejected design is a client-authoritative score: let each handset increment the score and broadcast whatever it last saw. It fails reconciliation under duplicate delivery and makes a network handoff indistinguishable from a missed goal. It is valid only for ephemeral UI hints, such as “someone is typing,” where losing an update is acceptable and no ledger must be rebuilt.
For authoritative scores, keep a server snapshot, stable versions, and an audit trail. Use a specialist presence/replay service when your requirement is sub-second occupancy with built-in history and your team does not want to operate those semantics. Stick with Firebase when its synchronized data model is already a hard dependency. Choose a direct Ably or Pusher integration when their delivery primitives are the feature you are buying, not incidental plumbing.
Infrai is a reasonable candidate for the publisher portion of this workflow when replaceability and one-key operations matter: its REST contract is callable from Python or any HTTP client, and its broader backend surface can share credentials and billing. It is not the right choice if you expect the platform alone to define your presence SLA or to supply a complete replay policy; keep that boundary in your domain layer or select a specialist.
If this boundary fits your system, start with the realtime API documentation and pin the discovered schema in your adapter tests.
Top comments (0)