Top AWS AppSync alternatives to consider in 2024

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.

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. 

• End-to-end caching.

• 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. 

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):

• Firebase

• Azure Web PubSub

• Pusher

• Socket.IO

• Ably 

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 advantages

• 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.  

Firebase disadvantages

• 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 for details.

Learn more about the challenges of using Firebase at scale

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.

• Lacks features such as presence, message history (incredibly helpful for use cases such as chat), and delta compression (useful for reducing bandwidth costs and increasing throughput). 

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).

• Presence.

• Authentication, authorization, and encryption.

• Webhooks.

Pusher advantages

• 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.

Pusher disadvantages

• 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.

• Multiplexing (namespaces).

• Broadcasting to all clients, or a subset of clients via rooms.

• Acknowledgments (via callbacks).

Socket.IO advantages

• 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 disadvantages

• 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 offers a limited set of capabilities. Unlike other similar solutions, Socket.IO doesn’t provide features like message history, push notifications, webhooks, or serverless functions. There are only a few client and server implementations (Socket.IO is primarily a JavaScript/Node.js solution), there’s no native support for end-to-end encryption, and no Socket.IO mechanism to generate and renew tokens for authentication.

• 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?

Learn more about Socket.IO’s pros and cons

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.

• Push notifications.

• 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).