What is AWS AppSync?
AWS AppSync is a fully managed service for data integration, data querying, data synchronization, and realtime communication. AppSync provides two types of APIs:
GraphQL APIs. They allow frontends to query databases, microservices, and other backend components from a single GraphQL endpoint. GraphQL APIs built with AppSync can interact with the following data sources: AWS Lambda, Amazon DynamoDB, Amazon Aurora Serverless, and HTTP endpoints.
Pub/Sub APIs, which allow you to push realtime updates from app clients and backend services to subscribed API clients over serverless WebSockets. Pub/Sub over WebSocket APIs can be used to deliver realtime experiences and features like live chat, social media feeds, and multiplayer collaboration.
AWS AppSync alternatives for GraphQL APIs
If you’re a developer who’s specifically interested in working with GraphQL APIs, there are several well-known alternatives you could use instead of AWS AppSync.
Apollo. GraphQL developer platform offering several products:
Apollo GraphOS - end-to-end cloud platform for building, observing, and managing GraphQL APIs.
Apollo Client - allows you to consume graphs and bind data to your UI with GraphQL. Available for Web, iOS, and Android.
Apollo Server - open-source, spec-compliant GraphQL server that's compatible with any GraphQL client, including Apollo Client.
Hasura. GraphQL engine that allows developers to build real-time GraphQL APIs backed by databases. Hasura is available as a fully-managed cloud solution, but also as a self-hosted, open-source version. Key features:
Roughly 20 databases are supported, including Amazon Aurora, AzureDB Postgres, Cockroach DB, Supabase, PostgreSQL, and CockroachDB.
Queries, mutations, and subscriptions.
Rate limits, role-based authorization and permissions, with the ability to restrict operations based on user role.
PostGraphile. Open-source GraphQL API generator for PostgreSQL databases. It provides a way to create a GraphQL API by introspecting a PostgreSQL database and generating a fully-featured GraphQL schema and resolvers based on the database schema. Key features include:
Joins, filtering, sorting, aggregation.
Authorization and access control.
Schema customization through smart comments.
Extensible via schema and server plugins.
Other solutions you can use instead of AWS AppSync to create and manage GraphQL APIs include Azure API Management Platform, Apigee API Management, and Boomi API Management.
5 alternatives to AWS AppSync for WebSocket-based realtime apps
As previously mentioned, AWS AppSync allows you to create and use Pub/Sub over WebSocket APIs, which come in handy when you’re engineering realtime experiences for end-users (e.g., live chat, broadcasting live data, multiplayer collaboration functionality).
We’ll now look at WebSocket alternatives to AWS AppSync - technologies that you can use to build realtime mobile and web apps where the communication is powered by WebSockets. Here are the five alternatives we’ll cover (note that some of them offer pub/sub over WebSocket capabilities):
Azure Web PubSub
In a nutshell, Firebase is a Backend as a Service (BaaS) platform that helps you build, test, release, and monitor mobile and web applications. With Firebase, you immediately get many useful features out of the box, some of which are listed below:
Realtime database. At its core, Firebase is a cloud service that allows you to store data related to your application and service. Firebase offers two different non-relational database options: the Firebase Realtime Database, and Cloud Firestore.
Cloud and in-app messaging. Both Firebase Realtime Database and Cloud Firestore can push realtime updates to client devices over WebSockets following any changes to the database. There’s also Firebase Cloud Messaging, a service that allows you to send cross-platform push notifications and notification messages.
Authentication: Firebase’s authentication service is a natural extension to its database offering, allowing you to securely store user information.
Hosting. Firebase provides secure hosting on Google Cloud.
Integrations. Given that Firebase is powered by Google, this naturally extends its functionality via integrations with services such as Google Pub/Sub, Google Cloud Functions, and Google Analytics.
Firebase helps app developers move quickly: you don’t have to worry about hosting, provisioning, and managing backend processes and components like databases, data storage, and authentication. Firebase’s collection of services makes the entire development cycle shorter and more straightforward.
Firebase has good technical documentation, and detailed SDK and API reference, making it easy to get started and use the platform. Going beyond docs, there are about 1.5 million apps built with Firebase, so there’s a pretty big community of experts who can help you with questions and issues.
Most of the Firebase services are free to start with, which is great if you are new to Firebase and simply want to test the platform, to assess if it’s the right choice for your project.
An instance of the Firebase Realtime Database has a limit of 200.000 concurrent connections and 1.000 write operations per second. To scale beyond these limits, you have to use sharding, which is a notoriously difficult process.
Vendor lock-in is an issue when you use Firebase. For example, if one day you conclude that the Realtime Database / Cloud Firestore is unsuitable for your use case, it’s hard to migrate to another (NoSQL) database. This is because of the way data is stored - a JSON tree in the case of the Realtime Database, respectively collections of documents (which are very similar to JSON data) in the case of Cloud Firestore.
There are plenty of horror stories of costs escalating out of control, especially if you are new to Firebase, and don’t yet have a good grasp on the pricing model and how to engineer your apps in a cost-effective manner. See How not to get a $30k bill from Firebase and We burnt $72K testing Firebase + Cloud Run and almost went bankrupt for details.
Azure Web PubSub
Generally available as of November 2021, Azure Web PubSub is a fully managed realtime messaging service. It allows you to create loosely coupled realtime web applications using WebSockets and the publish/subscribe pattern.
Azure Web PubSub comes with capabilities such as:
Authentication and authorization via JWTs.
The ability to send messages to a particular client, all clients, or a subset of clients.
Hubs (a set of client connections) and groups (a subset of connections to a hub).
Supports various subprotocols, like the JSON WebSocket subprotocol and the Protobuf WebSocket subprotocol.
Azure Web PubSub advantages
Supports both native and serverless WebSockets (with Azure Functions).
Claims it’s designed for large-scale applications and highly available architectures.
Supports a large variety of clients, such as browsers, desktop and mobile apps, or IoT devices; you can use any standard WebSocket client (in your language of choice) with Azure Web PubSub.
Azure Web PubSub disadvantages
Azure Web PubSub is a regional service, which can negatively impact its performance, reliability, and availability.
Azure Web PubSub doesn’t provide a robust messaging QoS. Message ordering and guaranteed delivery are theoretically only possible when you use reliable WebSocket subprotocols (Reliable Protobuf WebSocket and Reliable JSON WebSocket). However, both these subprotocols are currently in developer preview, and some changes are to be expected in the future.
Acquired by MessageBird in 2020, Pusher is a PaaS designed to add realtime functionality to web and mobile applications. Pusher provides realtime APIs, managed messaging infrastructure, and capabilities like:
Pub/sub messaging (Pusher Channels).
Push notifications (Pusher Beams).
Authentication, authorization, and encryption.
Pusher primarily uses WebSockets, but will also fall back to HTTP in environments where WebSockets aren’t supported.
SDKs for every major development platform and programming language, giving you the flexibility of integrating Pusher in your preferred language.
Features such as presence (useful, for example, for chat apps), webhooks to capture and respond to client events as they happen, and end-to-end encryption for enhanced security.
No superior QoS messaging guarantees; for example, if a message is published whilst a client is briefly disconnected (such as going through a tunnel or changing networks), then the message published over Pusher will never arrive to that client.
Pusher does not provide integrations with services such as event streaming platforms (e.g., Kafka) and serverless platforms (e.g., AWS Lambda, Azure Functions, etc.)
Pusher requires you to choose a single datacenter for an app to reside in. All realtime traffic must therefore be routed through that single datacenter, regardless of a user’s location. This has implications for performance, reliability, and availability.
Socket.IO is an open-source realtime library that enables low-latency, bi-directional communication between web clients and servers. Built on top of the WebSocket protocol, Socket.IO provides additional capabilities compared to raw WebSockets:
Fallback to HTTP long polling for environments where WebSockets aren’t supported (e.g., older browsers and some corporate networks with proxy servers).
Disconnection detection, packet buffering, and automatic reconnections.
Broadcasting to all clients, or a subset of clients via rooms.
Acknowledgments (via callbacks).
Making use of namespaces enables you to minimize the number of TCP connections used, and save socket ports on the server, while broadcasting allows you to efficiently distribute data in scenarios where you need to fan out the same message to multiple users.
Socket.IO is easy to get started with; it provides a simple API for both the client side and the server side, making it straightforward to implement realtime functionality into your application.
Integrations with various solutions for horizontal scaling: Redis, MongoDB, Postgres, AMQP / RabbitMQ, so you can choose the one that best suits your needs. Note that you must 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, Socket.IO provides an at-most-once delivery guarantee. This means there’s a chance some messages might never get delivered to recipients, especially when poor network conditions and disconnections are involved. If you’re unhappy with the default semantics, you can configure Socket.IO to provide an at-least-once messaging guarantee. However, this brings additional engineering complexity - you have to use acknowledgments, timeouts, assign a unique ID to each event, persist events in a database, and resend events upon reconnections.
Socket.IO is designed to work in a single region, rather than a multi-region architecture. This can lead to issues such as increased latency (if your users are in different regions), and even system downtime - what happens if the datacenter where you have your Socket.IO servers goes through an outage?
Ably is a realtime experience infrastructure provider. Our APIs and SDKs help web and mobile developers build and deliver realtime experiences without having to worry about maintaining and scaling messy realtime infrastructure.
Key Ably features and capabilities
Pub/sub messaging over serverless WebSockets, with rich features such as message delta compression, automatic reconnections with continuity, user presence, message history, and message interactions.
Support for several other protocols: Server-Sent Events, MQTT, Raw HTTP, AMQP, STOMP.
Client SDKs for every major programming language and development platform.
Custom webhooks and integrations with streaming solutions like Apache Kafka & Amazon Kinesis, and serverless platforms such as AWS Lambda, Microsoft Azure Functions, and Google Cloud Functions.
A globally-distributed network of datacenters and edge acceleration points-of-presence.
Guaranteed message ordering and delivery.
Global fault tolerance and a 99.999% uptime SLA.
< 65ms round-trip latency (P99).
Dynamic elasticity, so we can quickly scale to handle any demand (billions of messages sent to millions of pub/sub channels and WebSocket connections).
Firebase alternatives: The best competitors to consider in 2023
Discover the best alternatives to the Firebase Backend as a Service platform for realtime messaging and push notifications in 2023.
The best Amazon API Gateway alternatives to consider
Discover the best alternatives and competitors to Amazon API Gateway for API management, and for building realtime experiences like chat and multiplayer collaboration.
Supabase alternatives: Competitors to consider in 2023
Discover the best alternatives to the Supabase backend as a service platform for realtime messaging and realtime sync in 2023.