High-scale, high-frequency messaging and burst activity can lead to significant costs and performance challenges for realtime applications. To help with this, we’ve introduced server-side batching and conflated subscriptions—two powerful optimizations in Ably Pub/Sub that significantly reduce message count, lower bandwidth usage, and optimize processing overhead.
These features allow you to process high-frequency updates more efficiently without sacrificing accuracy, reliability, or latency.
The challenge of cost optimization when operating at scale
As your application scales, so does the volume of data you need to process and transmit. This can lead to increased costs and potential performance bottlenecks. Traditional approaches to handling high-frequency data can be inefficient and expensive, hindering innovation and growth.
Here at Ably, we wanted to tackle this challenge head-on. The introduction of both our batching and conflated subscriptions feature highlights our commitment to actively developing features that:
- Actively reduce the message count and therefore the cost of total messages sent.
- Reduce the amount of data sent by only sending the most up to date changes.
- Foster creativity: development of large scale, efficient realtime experiences without the architectural complexities or exponential costs.
Reduce the cost of large scale realtime interactions with server-side batching
Some realtime scenarios—like high-activity chat rooms or virtual event feeds—generate large bursts of messages within milliseconds of each other. Sending each message individually can be expensive and inefficient.
Ably Pub/Sub’s server-side batching solves this by grouping multiple messages into a single batch before sending them to subscribers. This significantly reduces the count of messages processed and billed, leading to lower costs and improved efficiency. Importantly, every message is still sent—just in fewer batches.
How it works
Instead of sending:
[message 1] → [message 2] → [message 3] → [message 4]
Batching consolidates messages into a single transmission:
[batch: message 1, message 2, message 3, message 4]
This results in:
- Reduced message volume: By combining multiple messages into a single batch, we significantly reduce the number of messages sent over the network.
- Optimized bandwidth usage: Batching minimizes data transfer, leading to lower bandwidth costs.
- Lower risk of hitting rate limits during high-throughput scenarios.
- Improved performance: Fewer messages mean faster delivery and reduced latency.
- Larger presence sets: Thousands vs hundreds of users can share their online presence.
Batching use cases at scale
- High-volume chat applications: Combine user messages, reactions, and presence updates into fewer network transmissions.
- Fan engagement platforms: Reduce the load of high-frequency events (polls, Q&A, audience reactions).
- Livestream interactions: Optimize high-throughput messaging for realtime comments and interactions.
- Collaboration tools: Group frequent document edits or realtime updates.
Have a play with our consumption costs estimator tool to see how much you could save with batching.
Reduce bandwidth and processing needs with conflated subscriptions
For some streaming data use cases, the last state (such as price, or location) is what matters most. There is no need for full message streams, just periodic updates. Conflated subscriptions ensure that within a defined interval (e.g., every 100ms), only the most recent message is delivered. This reduces bandwidth consumption, memory usage, and processing overhead while keeping applications responsive.
This is particularly useful for scenarios like displaying stock prices on a large screen, where only the latest data needs to be shown at specific intervals. By delivering only the most recent message within a conflation period, you can ensure your applications remain responsive and up to date without overwhelming your system with unnecessary data.
How it works
Instead of sending:
[price update: $50] → [price update: $51] → [price update: $52] → [price update: $55]
A conflated subscription delivers only the latest price at the defined interval:
[price update: $55]
This results in:
- Reduced message volume: By delivering only the latest updates within a specified interval, conflated subscriptions minimize unnecessary data transfer.
- Optimized bandwidth usage: Less data means lower bandwidth costs and improved performance.
- Simplified application development: Developers can focus on building core features without worrying about handling high-frequency data streams.
Conflated subscription use cases at scale
- Stock price tickers: Display only the latest stock price updates rather than every microsecond-level trade.
- Live sports scores: Show current scores without redundant updates.
- IoT telemetry: Reduce bandwidth by only delivering the latest sensor readings.
- Traffic & location tracking: Stream realtime movement data efficiently.
Try it out
Both server-side batching and conflated subscriptions are now available in Ably Pub/Sub, helping you reduce messaging costs and improve efficiency at scale.
- Server-side batching ensures every message is sent, but in fewer transmissions, reducing total message count and cost.
- Conflated subscriptions prioritize only the most recent update, reducing bandwidth usage and processing overhead.
These optimizations work together to help developers handle high-throughput messaging more efficiently—without sacrificing performance, reliability, or realtime accuracy. Start using batching and conflated subscriptions today—check out the docs for more details and sign up to get started.
