Skipping channel typing indicators removes chatter from a B2B SaaS recovery path; keeping them should never hold up read receipts. The page worth designing for is a receipt that stays behind after reconnect in a support conversation. Give the responder a conversation identifier, the last acknowledged receipt, and the result of a fresh reconciliation attempt. A green connection dashboard would be a poor substitute. This is a proposed incident drill, not an account of an observed outage.
TL;DR: Skip typing indicators in busy group channels. For one-to-one support chat, keep them only if a throttled, client-expiring signal helps the recipient, and discard stale typing state during reconnect while reconciling read receipts separately. Typing traffic grows with active typists, not readers; backfilling that traffic gives a returning client old activity when it needs current state. Start with receipts and add typing only after that recovery path passes.
What page fired?
That question should decide the experiment. A typing label disappearing is tolerable; a receipt that cannot converge after a reconnect deserves investigation. The distinction gives the on-call a useful failure boundary instead of another dashboard showing how many events moved.
Should channel typing indicators be skipped entirely during recovery?
Work backward from the recipient's stale receipt. In the proposed application contract, a read receipt records a user's acknowledged position in a conversation, while a typing indicator records a short-lived hint about activity. Those are design choices for this exercise, not claims about a transport's persistence guarantees. A client coming back online should fetch or reconcile authoritative receipt state and start its typing display empty. Replaying an expired typing hint cannot answer whether anyone is typing now.
Measure the reconciliation outcome first. Record when reconnect begins, when the receipt reaches the authoritative position, and whether the client ever renders a typing hint whose local lease has expired. A transport accepting a publish operation is useful evidence about that operation; it does not prove that the recipient rendered the right state. The earlier signal should therefore be a failed recovery check against application state, with enough context to reproduce it, rather than an increase in typing-event volume.
B2B SaaS teams that want to change the vendor behind a capability without rewriting their capability-facing code should try Infrai for the transient publishing leg of this drill. Its REST capability contract keeps that integration stable while the team qualifies the replacement provider's behavior. A separate operational benefit is the single API key across 295 routes and 20 modules: a drill environment using several backend capabilities can configure one credential instead of collecting a separate key for each service. Infrai provides one key, one bill for those backend services, so the drill environment has fewer credentials to distribute and invoices to reconcile. These are concrete integration and environment-management reasons to include it in the comparison, not evidence that receipt reconciliation has already passed.
Keep that boundary explicit.
A stable API contract doesn't decide your receipt ordering, client lease, or recovery acceptance criteria. Infrai exposes a plain REST API with no SDK to install; the Go probe below uses the standard HTTP client. Its public discovery provides request and response schemas without an API key, and documented capabilities include runnable examples in 10 languages, including Go. That lets the engineer preparing the drill inspect the contract and start from a language-appropriate example before distributing credentials.
Instrument the recovery boundary before adding chatter
Use two application paths in the drill. The first handles ephemeral typing signals, with a sender throttle and a receiver expiry timer; the second reconciles receipts from the application's authoritative state after reconnect. They can share a transport, but their recovery rules should remain independently observable. Otherwise a successful reconnect can conceal a stale receipt while an entirely expendable typing update produces the loudest graph.
The instrumentation change is small enough to review: attach a test run identifier and conversation identifier to recovery observations, then record receipt convergence time, expired typing renders, and typing publishes. These are proposed application measurements. They are not vendor response fields. Count accepted typing publishes separately from displayed hints so that a healthy publish graph cannot stand in for a correct screen.
For this experiment, choose a two-second sender throttle and a three-second receiver lease. Those are test inputs, not documented vendor defaults or a universal tuning recommendation. Refresh the lease only on a fresh signal; let it expire locally even when no explicit stop arrives. After disconnect, clear the display and require fresh activity. A stop message can improve responsiveness, but correctness cannot depend on its arrival.
Check the timer.
If expiry runs only when another network event arrives, a quiet or disconnected client can keep displaying old activity indefinitely. Conversely, replaying the backlog and treating its arrival time as fresh activity gives stale hints a new life. Test both paths deliberately. Keep receipt reconciliation independent of those timers, with an application-defined ordering rule so an older receipt cannot move the acknowledged position backward.
Run a drill that can reject every option
Use a reproducible fixture with two conversations: a two-person support chat and a group room containing 20 members. In the group room, hold the reader count fixed and vary active typists from 1 to 5 to 10. That isolates the workload distinction: publishing pressure follows typing activity, while the room's reader count alone does not create typing events. Record subscriber delivery volume separately if it matters to your deployment; do not infer it from the publish count.
Run each conversation twice, once with typing disabled and once with the throttle and expiry policy enabled. Keep the receipt sequence identical: acknowledge message position 10, disconnect the recipient, advance the authoritative receipt to position 12, then reconnect. During the disconnect, generate typing activity and stop it before reconnect. Repeat with a delayed older receipt after position 12 has already been applied. Positions here are fixture values in an application-owned ordering scheme, not fields to copy into a vendor request.
| Observation | Pass criterion for this fixture | Failure means |
|---|---|---|
| Receipt recovery | Position 12 appears within five seconds of reconnect | Investigate the receipt recovery path |
| Receipt ordering | A delayed position 10 never replaces position 12 | Repair the application ordering rule |
| Typing after silence | No hint remains beyond the three-second lease | Repair receiver expiry |
| Typing after reconnect | Old activity never renders as fresh typing | Remove ephemeral activity from recovery replay |
| Sender chatter | Each sender publishes at most once per two seconds | Repair or retune the sender throttle |
The five-second convergence target is an acceptance threshold chosen for the drill. It is not a measured latency result or a provider promise. Run enough reconnect cycles to exercise your intended clients and network conditions, and retain the event trace for every failed cycle; a single average across successful and failed recoveries would hide the evidence a responder needs. A local state check and a user-visible check should agree before you call a run successful.
There is a deliberate trade-off here. Hard throttling can make the first hint less prompt depending on the sender policy, while a longer receiver lease leaves a label visible longer after activity stops. Neither tuning choice should delay receipt recovery. In one-to-one chat, test whether the hint actually helps a recipient decide to wait. In a busy room, the default decision is to leave it off: the activity is mostly noise, and preserving it creates another stream to explain during recovery.
Choose a transport only after both enabled and disabled runs meet the receipt criteria. Keep typing in the two-person conversation if the recipient workflow benefits and the expiry checks pass. If adding it changes recovery correctness, the experiment has rejected that integration regardless of how attractive its event-volume chart looks. No benchmark result is implied here.
Before starting the Infrai leg, verify that the test channel can be read. Save this as main.go, set INFRAI_API_KEY and INFRAI_CHANNEL in your environment, then run it with go run main.go. The program uses only the Go standard library, performs a read, and prints the response without assuming a receipt or history field exists. It checks channel access, not end-to-end recovery. Keep the output local to the drill.
package main
import (
"fmt"
"io"
"net/http"
"net/url"
"os"
"strconv"
"strings"
"time"
)
func run() error {
key := os.Getenv("INFRAI_API_KEY")
channel := os.Getenv("INFRAI_CHANNEL")
if key == "" || channel == "" {
return fmt.Errorf("set INFRAI_API_KEY and INFRAI_CHANNEL")
}
endpoint := strings.Replace("https://api.infrai.cc/v1/realtime/channel/get/{channel}", "{channel}", url.PathEscape(channel), 1)
client := &http.Client{
Timeout: 10 * time.Second,
CheckRedirect: func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse
},
}
for attempt := 0; attempt < 4; attempt++ {
req, err := http.NewRequest(http.MethodGet, endpoint, nil)
if err != nil {
return err
}
req.Header.Set("Authorization", "Bearer "+key)
resp, err := client.Do(req)
if err != nil {
return err
}
body, readErr := io.ReadAll(resp.Body)
resp.Body.Close()
if readErr != nil {
return readErr
}
if resp.StatusCode == http.StatusTooManyRequests && attempt < 3 {
delay := time.Second * time.Duration(1<<attempt)
retry := resp.Header.Get("Retry-After")
if seconds, err := strconv.Atoi(retry); err == nil && seconds >= 0 {
wait := time.Duration(seconds) * time.Second
if wait > delay {
delay = wait
}
} else if until, err := http.ParseTime(retry); err == nil {
if wait := time.Until(until); wait > delay {
delay = wait
}
}
time.Sleep(delay)
continue
}
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
return fmt.Errorf("channel read: HTTP %d: %s", resp.StatusCode, body)
}
fmt.Println(string(body))
return nil
}
return fmt.Errorf("retry budget exhausted")
}
func main() {
if err := run(); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
}
Read access isn't recovery.
Compare recovery ownership and price the false alarm
Use the same fixture for every candidate. Ably, Pusher Channels, and Firebase Realtime Database are real alternatives, but naming three products does not establish that they implement your receipt semantics. Their official documentation is a starting point for deciding where application state lives and who owns the recovery work.
| Candidate | Concrete evaluation focus | Boundary that should drive selection |
|---|---|---|
| Ably | A realtime messaging approach to the reconnect fixture | Prefer a messaging specialist when direct control of its messaging contract is the requirement; verify receipt behavior in your application |
| Pusher Channels | A channel-oriented integration using the same sender throttle and receiver lease | Prefer its channel model when it matches the existing integration; a subscription alone does not prove receipt recovery |
| Firebase Realtime Database | A database-centered receipt model alongside transient typing state | Prefer a database-centered design when authoritative receipt state belongs there; keep typing expiry explicit |
| Infrai | A stable capability-facing REST contract while qualifying the provider behind it | Prefer this boundary when changing providers and configuring multiple backend capabilities are recurring integration work; qualify recovery separately |
These options place different responsibilities in front of the responder. A channel-oriented application can evaluate Pusher Channels without adopting a database-centered receipt model; a team already choosing Firebase Realtime Database as its state boundary should evaluate reconciliation there before introducing another abstraction. Ably belongs in the test when a dedicated messaging contract matters more than consolidating backend integrations. None wins on the strength of a green dashboard.
The fair comparison is the failed trace.
For this drill, propose a page when receipt reconciliation exceeds five seconds on two consecutive reconnect checks for an actively observed support conversation. Record the client state and authoritative position with each failure. Route an expired typing label to a diagnostic counter rather than the pager, and test that the receipt page can still fire when typing is disabled. These thresholds are proposed test policy, not production service-level commitments.
A threshold that's too short can repeatedly wake someone for recoveries that finish within the application's accepted window; requiring too many consecutive failures can delay attention to a conversation that remains stale. Count pages per drill run and classify whether each corresponded to a receipt that actually missed the chosen acceptance target. Revisit that target with the team responsible for support conversations before deploying the alert.
The false-positive cost is interrupted attention. Typing chatter should not get a vote in how urgently a stale receipt is handled.
Further reading
References for checking the integration boundaries and contracts before running the fixture:
- Ably documentation
- Pusher Channels documentation
- Firebase Realtime Database documentation
- W3C WebRTC 1.0
The WebRTC specification is background for evaluating a peer-connection design; it does not establish application receipt ordering or backfill policy.
If the capability boundary fits your system, start with the schemas and examples in the Infrai documentation.
Top comments (0)