What is Pusher?
Pusher provides hosted APIs and messaging infrastructure to build realtime features for end-users. Pusher has two main products:
Channels - pub/sub channels over WebSockets.
Beams - an API for cross-platform push notifications for iOS, Android, and Web.
With Pusher, you can build features such as:
Realtime charts and graphs
Realtime location tracking
Collaboration and activity feeds
5 alternatives to Pusher to consider
We’ll now look at alternatives to Pusher - similar technologies that allow you to build realtime functionality for end-users. Here are the five alternatives we’ll cover:
DiffusionData (Push Technology)
DIY WebSocket solution
The Ably serverless WebSocket platform
PubNub describes itself as a “developer platform that powers the realtime infrastructure in apps to build engaging Virtual Spaces where online communities can truly connect”. PubNub provides pub/sub APIs, a managed infrastructure layer, and features such as presence and PubNub Functions to run serverless business logic on messages.
Provides globally-distributed infrastructure spanning 15 datacenters, with data replication in multiple regions to protect against single points of failure.
End-to-end encryption and compliance with standards such as HIPAA, GDPR, SOC 2 Type 2.
PubNub does not guarantee that messages are stored or sent in the exact same order in which they are published. Delivery is not guaranteed either - PubNub’s default message queue size is 100 messages. Publishing more than 100 messages results in older messages getting discarded. In practice, if you publish more than 100 messages while a subscriber goes offline, when they reconnect, they won’t receive the messages that were discarded.
PubNub’s main transport is long polling, which is an inferior option to other realtime transports. For example, compared to WebSockets, long polling is more resource intensive and comes with a latency overhead.
No functionality or integrations to send data from PubNub directly to popular streaming or queueing services, such as Amazon Kinesis and Apache Kafka.
DiffusionData (Push Technology)
DiffusionData (formerly Push Technology) offers a platform that allows you to:
Ingest data from various sources (such as REST APIs and IoT devices).
Transform and segment data in-flight.
Deliver data in realtime to clients (primarily end-user devices) over pub/sub topics.
Note that DiffusionData / Push Technology is available as a cloud offering, but also as an on-prem solution.
DiffusionData (Push Technology) pros
Multi-protocol support: WebSockets & long-polling fallbacks (supported by Diffusion SDKs), MQTT, REST, Kafka (for ingesting data).
Features like delta compression, flow control, and conflation to optimize data distribution in unreliable networks.
DiffusionData (Push Technology) cons
No support for encrypted message payloads (e.g., 256-bit AES encryption).
It’s unclear if the DiffusionData platform guarantees message ordering and delivery. For example, if a client disconnects and reconnects, the documentation doesn’t mention if the stream will resume precisely where it left off, with no messages being lost, delivered multiple times, or sent out of order.
It’s designed to operate in a single region, rather than in a multi-region architecture. This can lead to issues such as increased latency; it may also impact availability (if the region where DiffusionData is deployed experiences downtime, your system would be unavailable to end-users).
DIY WebSocket solution
WebSocket is a realtime technology that enables bi-directional, full-duplex communication between client and server over a persistent, single-socket connection.
A WebSocket connection starts as an HTTP request/response handshake. If this initial handshake is successful, the client and server have agreed to use the existing TCP connection that was established for the HTTP request as a WebSocket connection. This connection is kept alive for as long as needed (in theory, it can last forever), allowing the server and the client to independently send data at will.
DIY WebSocket solution pros
WebSocket is a mature, widely-used technology; it emerged over a decade ago and has been extensively battle-tested. Most programming languages, development platforms, and browsers support WebSockets.
The WebSocket technology allows for the implementation of application-level protocols (on top of WebSockets), and extensions for additional functionality (such as pub/sub messaging). Building on raw WebSockets means you have the flexibility of designing your own WebSocket-based protocol and capabilities, tailor-made for your specific use case and needs.
Before WebSocket, HTTP techniques like AJAX long polling and Comet were the standard for building realtime apps. Compared to HTTP, WebSocket eliminates the need for a new connection with every request, drastically reducing the size of each message (no HTTP headers). This helps save bandwidth, improves latency, and makes WebSockets less taxing on the server side compared to HTTP.
DIY WebSocket solution cons
Certain environments (such as corporate networks with proxy servers) will block WebSocket connections. You will most likely have to consider supporting fallback transports for these scenarios.
Unlike HTTP, WebSocket is stateful. This can be tricky to handle, because it requires the server layer to keep track of each individual WebSocket connection and maintain state information.
Building a reliable DIY WebSocket solution that you can trust to deliver at scale is expensive, time-consuming, and requires significant engineering effort.
Here are some key stats to give you a taste of how complex it is to engineer WebSocket capabilities in-house:
65% of DIY WebSocket solutions had an outage or significant downtime in the last 12-18 months.
10.2 person-months is the average time to build basic WebSocket infrastructure, with limited scalability, in-house.
Half of all self-built WebSocket solutions require $100K-$200K a year in upkeep.
Created back in 2010, Socket.IO is a well-known open-source library that enables low-latency, bi-directional communication between web clients and servers. Socket.IO is built on top of the WebSocket protocol and provides additional capabilities such as automatic reconnections, or falling back to HTTP long polling.
Multiplexing (namespaces), which enables you to minimize the number of TCP connections used, and broadcast support (rooms), to more efficiently distribute data to clients.
Disconnection detection (configurable Ping/Pong heartbeat mechanism) and automatic reconnections.
Integrations with various solutions for horizontal scaling: Redis, MongoDB, Postgres, AMQP / RabbitMQ. Note that you have to use one of these when you scale beyond a single Socket.IO server, to pass events between nodes, and ensure that events are properly routed to all clients.
Socket.IO does not guarantee exactly-once messaging semantics. By default, an at-most-once guarantee is provided. Socket.IO can also be configured to provide at-least-once guarantees, although this brings additional engineering complexity - you have to use acknowledgments, timeouts, assign a unique ID to each event, and persist events in the database.
Limited native security features - for example, Socket.IO doesn't provide end-to-end encryption, and it doesn't offer a mechanism to generate and renew tokens for authentication.
Designed to work in a single region, rather than a multi-region architecture. This can lead to issues such as increased latency (if you have users in different parts of the world), and system downtime - what happens if the datacenter/region where you have your Socket.IO servers goes through an outage?
Ably is a realtime experience infrastructure provider. Our realtime APIs and SDKs help developers power multiplayer collaboration, chat, data synchronization, data broadcast, notifications, and realtime location tracking at internet scale, without having to worry about managing and scaling messy realtime infrastructure.
Key Ably features and capabilities
Ably is underpinned by a globally-distributed network of datacenters and edge acceleration points of presence.
Client SDKs for every major programming language and development platform.
Pub/sub APIs with rich features, such as message delta compression, multi-protocol support (WebSockets, MQTT, Server-Sent Events), automatic reconnections with continuity, presence, and message history.
Guaranteed message ordering and delivery.
Global fault tolerance and a 99.999% uptime SLA.
< 65ms round-trip latency for 99th percentile.
Elastic scalability to handle millions of concurrent clients.
The best Twilio alternatives to consider in 2023
Discover the best Twilio alternatives and competitors you can use to build 1-to-1 and group chat experiences.
Stream (GetStream) alternatives: 5 competitors to consider in 2023
Discover the best solutions you can use instead of Stream to build web-based and in-app chat experiences.
The best AWS AppSync alternatives to consider in 2023
Read about WebSocket solutions you can use instead of AWS AppSync to deliver realtime experiences like live chat and multiplayer collaboration.