FastPubSub Network

Resilient realtime pub/sub over the global Internet

When FastPubSub is a better fit than Kafka, NATS, or RabbitMQ

FastPubSub is not a queue or a durable log. It is a resilient live-delivery fabric: path reliability when Internet routes fail, not data reliability through retries and replay.

Use durable brokers when every message must arrive. Use FastPubSub when the stream must keep flowing even if individual samples are lost during reconvergence.

Self-hosted software Kafka / NATS / RabbitMQ Your servers, cluster, storage, ops You run it in every region you need Focus: durable processing vs Managed service broker FastPubSub global broker Connect via WebSocket, start publishing Global by default, single-region optional Focus: live low-latency delivery

Which software broker fits which job

Use Kafka when

You need durable logs, replay, retention, and stream processing with historical data.

Use RabbitMQ when

You need queue semantics for work distribution, acknowledgments, and brokered task processing.

Use NATS when

You need lightweight broker messaging, request/reply patterns, and internal service transport.

Use FastPubSub when

The stream must survive Internet path failures — cable cuts, BGP flaps, peering outages — not when every message must be replayed from a durable log.

Path reliability, not message replay

FastPubSub reroutes in seconds when underlay paths degrade. It does not retransmit lost application messages or buffer for replay. Stalls are worse than loss for live signals.

Managed overlay, not self-hosted clusters

Connect via WebSocket and publish. No regional broker clusters, storage tiers, or path measurement to operate yourself.

Why FastPubSub is positioned differently

Behavior under Internet failure

When a path fails, FastPubSub measures alternates and reroutes in about five seconds. Durable brokers typically keep using the same broken underlay and mask loss with retries and buffers.

Realtime flow vs durable stream

FastPubSub treats messaging as a UDP-style flow: the next sample matters. Kafka and similar tools treat messaging as a TCP-style stream: every byte must arrive, even if stale.

What you give up

No persistence, replay, consumer groups, or global ordering — by design. If you need those, use a durable broker and accept underlay routing as-is.

Side-by-side comparison

Capability
Kafka
NATS
RabbitMQ
FastPubSub
Persistence
Strong
Optional (JetStream)
Queue persistence options
No, by design
Replay
Yes
With storage mode
Limited queue semantics
No, by design
Behavior under Internet path failure
Depends on your deployment; no path reroute
Depends on your deployment; no path reroute
Depends on your deployment; no path reroute
Measured reroute in ~5 s on overlay mesh
Reliability model
Data reliability (retries, durable log)
Data reliability (optional persistence)
Data reliability (ACKs, queues)
Path reliability (flow continues; samples may drop)
Consumer groups
Yes
Subject/stream patterns
Worker consumers
No
Ordering guarantees
Partition-based
Depends on mode
Queue/order semantics
No global channel ordering
Network path optimization
No
No
No
Measured low-latency routes
Cross-region live fan-out
Possible with architecture work
Possible with architecture work
Possible with architecture work
Primary design goal
WebSocket client edge
External components needed
External components needed
External components needed
Built-in edge integration
Best for
Durable event streaming
Lightweight service messaging
Task and queue workflows
Live low-latency message transport
Delivery model
Software platform
Software platform
Software platform
Managed service broker
Geographic scope
Depends on your deployment
Depends on your deployment
Depends on your deployment
Global by default, single-region optional

Related solutions

Choose the right tool for the right job

Use durable brokers for storage and replay. Use FastPubSub when the stream must survive path failures.