6 ms·

Postgres LISTEN/NOTIFY actually scales

373 points by KraftyOne 2mo ago

dietr1ch 2mo ago
I recall that in the first release that supported LISTEN/NOTIFY there was a performance issue around it (poor locking IIRC), which today the "bad post" mentioned in here corrects in a errata just after their first paragraph. Since the correction apparently dates from May 8th, I think that a post from July 24th might want to acknowledge that the popular post asserting this feature doesn't (didn't?) scale was not made in bad faith or was even wrong about their claims at the time.
- KraftyOne 2mo ago
  If you mean the optimizations coming in Postgres 19, the original post addresses this: > As an aside, there’s been some online discussion of a Postgres patch (https://github.com/postgres/postgres/commit/282b1cde9dedf456ecf02eb27caf086023a7bb71 https://github.com/postgres/postgres/commit/282b1cde9dedf456...) related to this issue. This patch (to be released in Postgres 19) does not remove the global lock or fix the bottleneck we observed. Instead, it optimizes the narrower case where there are many notification channels and each listener is waiting only on a specific channel.
  - JoelJacobson 2mo ago
    It did fix the original "Postgres LISTEN/NOTIFY does not scale" [1] post's problem though, which was mentioned in an update of that article: Update: Fixed in Postgres core This commit has eliminated the bottleneck in the postgres core. Credit to Joel Jacobson and the core postgres contributors for resolving this. [1] https://www.recall.ai/blog/postgres-listen-notify-does-not-scale https://www.recall.ai/blog/postgres-listen-notify-does-not-s...
Latty 2mo ago
One way it explicitly doesn't scale (unless something has changed since I last checked and my quick search failed me) is the hard limit on 8000 bytes of data in a notification. If your notification doesn't make sense to exist as a row (where you can just give an ID), then that makes it hard to use. I had a web game and the events were transient descriptions of changes in state that didn't make sense to store in the database, and could be bigger than that, so it didn't work for that use case.
- dietr1ch 2mo ago
  As an implementer of a scalable notification system I'd be sure to cap the notification size. - Keeps messages O(1) so I can focus on scaling in the amount of notifications - Tells whoever runs into this that, - I didn't planned for arbitrarily large messages as they *might* otherwise grind performance to a halt. - They *might* be misusing my notification system
- pgwhalen 2mo ago
  Could you not send a message that pointed to the state that changed in a non-row-specific way?
  - Latty 2mo ago
    It was diffs in state that got sent to the client, so recomputing them from the current state would have required having the previous state.
jerf 2mo ago
"Scale" isn't a binary, it's a continuum. "Scales to 60K/s" can be 5 orders of magnitude more than one system needs and 5 orders of magnitude too small for another. Personally I'd knock the general "premature optimization" off the list of "most common developer errors" and put in its place "using techs with the wrong scaling factors". If you use something too small and you exceed its needs, the failure is obvious, but the other way around is a problem too. Bringing in the overhead and management issues of the super scalable techs, as well as their limitations they impose so that they can scale, to a system that would actually be better off with a richer model whose richness prevents it from scaling but would save a lot of effort is also a bad choice. The ceiling of LISTEN/NOTIFY is small enough that you need to pay attention, and I personally like to have at least an order of magnitude of slack left over even after my most pessimistic load numbers are accounted for, but it's still plenty for a lot of projects, and the integration with the rest of the DB, its availability, its not being another service you have to devops, it's definitely not something that should be simply dismissed out of hand as an option. Even the original 2K/s number they cite is a lot of messages for some systems that are more properly measured in seconds per message.
- zbentley 2mo ago
  > 5 orders of magnitude too small for another. Nitpick on an otherwise good post, but I don’t think there are very many 6billion RPS systems out there, and those that do exist are almost certainly using bespoke, purpose-built tools
  - jerf 2mo ago
    Fair.
  - odo1242 2mo ago
    The highest I could think of is WhatsApp, which gets ~1.6 million RPS on average, and they use MQTT
    - znpy 2mo ago
      DynamoDB scales much more than that. In one of their dynamodb papers they claimed that the amazon us retail website alone made like 89 millions rps during prime day, a few years ago.
nzoschke 2mo ago
I continue to love DBOS for how it just leverages Postgres (and now SQLite) properly. It's effortless to drop into an existing CRUD stack. Once you start down the "durable workflows" path, you start seeing them everywhere. My latest experiments are treating individual emails as durable workflows, where you, the people you're communicating with, agents and tools like GitHub or Attio all take turns in the flow. https://housecat.com/blog/gmail-durable-workflows-sandbox-vm https://housecat.com/blog/gmail-durable-workflows-sandbox-vm
mamcx 2mo ago
Is the optimization only possible using dbos? is not clear to me if this mean a way to tune normal PG
- KraftyOne 2mo ago
  The core optimization is to buffer notifications in-memory and send them in a batch instead of sending them as part of every transaction. So that's a general-purpose optimization for Postgres apps using LISTEN/NOTIFY.
  - mamcx 2mo ago
    So this is not inside a trigger but on the app connected to pg?
    - gordonhart 2mo ago
      Yes, per the article they “scaled” Postgres to meet their requirements by altering their usage pattern to avoid hitting the bottleneck.
jrochkind1 2mo ago
If I understnad right, they are saying it scales (to theri needs) with a custom patch to pg changing their semantics, right? It does seem interesting, and possibly welcome if there were a configuration option or even a way to set individual notifies as serialized or not.
- KraftyOne 2mo ago
  To be clear, it's not a custom patch to pg itself, but an application-side buffering and batching optimization.
  - jrochkind1 2mo ago
    Ah, thanks. I am not following at all how an application can do this.
acaloiar 2mo ago
Much of the FUD around using LISTEN/NOTIFY in production comes from people who have never done so. It of course has its limits, and we should remain aware of them. Much like the limits of every piece of tech in our stacks. Choose database queue technology https://news.ycombinator.com/item?id=37636841 https://news.ycombinator.com/item?id=37636841
- hxtk 2mo ago
  Personally I love it for cache invalidation. I used it on an older especially on project originally built without caching in mind that then added caching for immutable data without caching for mutable data in mind. It fell to me to add caching of mutable data. I found it rather convenient to put NOTIFY triggers on cached tables and have a LISTENer that will delete the corresponding rows from memcached when it gets a notification. It’s basically impossible to out-scale it in that use case because the scale is intrinsically linked to number of writes the leader in your database processes.
  - muaazkhan 2mo ago
    and here was I thinking ( when creating same cache invalidation system ) that I was the only one that came up with this patch. LMAO
zenith605 2mo ago
[dead]
David_runai 2mo ago
[flagged]
tjadfsaj 2mo ago
Sure it "scales" if clients batch commands to amortize the per-request cost. The word "scale" does a lot of load-bearing, maybe it's just not a useful or productive word in practice.
sandeepkd 2mo ago
I think a lot of these kind of posts are standalone assessment of your problems, understanding and solutions. Its debatable to term something as lack of expertise if one is trying to work with default settings of a tool and expecting a certain performance. Everyone is doing a continuous learning with the failures. 1. What I find interesting is that the experiment seems to be using a DB server with 96 cores, 384 GB RAM (https://github.com/dbos-inc/dbos-postgres-benchmark/blob/main/terraform/main.tf#L85 https://github.com/dbos-inc/dbos-postgres-benchmark/blob/mai...). This is very critical part of any such experiment, it should have been called out. The database is vertically scalable and that too has its limits 2. Who is making connection, and from where has its own impact on performance and overall latency 3. 60k may seem big number, however in real world the things which bring the systems down are the bursts of traffic, not the regular traffic. Personally I would never start with such a big server unless I am a big business. Its > 100K cost for one production DB cluster if I include read replicas and cross region redundancy
- elendilm 2mo ago
  Agreed
d9127acbd6fe281 2mo ago
So in summary, Postgres NOTIFY actually scales if you make your application not write to the database? That's a bit of a tough sell...
abratabia 2mo ago
[flagged]
dang 2mo ago
Related, presumably: Postgres LISTEN/NOTIFY does not scale - https://news.ycombinator.com/item?id=44490510 https://news.ycombinator.com/item?id=44490510 - July 2025 (321 comments)
newswangerd 2mo ago
I went through this process when I was designing the sync server for Digital Carrot. In the end, I decided to just go with the simplest solution possible. In my case it's just a barebones Go gRPC service that uses an in memory channel to send notifications between connected clients. The reality is that this simple Go server will scale up to about 1000 simultaneously connected customers on about 2gb of RAM. I don't expect to have more than that many paying customers, and if I do I can always just throw a bigger VM at the problem. Engineers love to over complicate things in the name of infinite scalability, when in reality you can save a lot of time and effort by just understanding the scope of the actual problem you're trying to solve. Fingers crossed that this will become an issue for me some day, but until then most of us just don't need to worry about it!
- anachronox 2mo ago
  I had a similar setup, scaled pretty well with some GOGC tuning. I had a small, simple "router" using channels https://github.com/urjitbhatia/gopipe https://github.com/urjitbhatia/gopipe and except for the per connection 16ish kb network overhead per socket, you can get away with a lot of performance with a small hand rolled service.
- znpy 2mo ago
  1000 connections is a fairly low number by modern standards, c10k “challenges” are like twenty years old by now. The real questions are: - how many messages per second are you processing on that 2gb machine (and using how many cpus)? - does your message processing involve transaction handling, including saving data ti disk durably? No offense but it really seems you’re comparing apples and oranges, with your use case being much much simpler than the one described.
  - newswangerd 2mo ago
    These are all very conservative back of the napkin calculations. Also, this isn't 1000 connections. It's 1000 customers, each of which can consume dozens of connections. My point here is that it is important to match the tech stack to the challenge you're facing. When I started thinking about how to solve this problem my first reaction was to design an overly complicated distributed message queue using PG Notify, Redis, Kafka or something along those lines. The key takeaway here is that I realized that I probably wouldn't end up with more than 1000 customers, so I just needed to design a system that could comfortably handle that level of traffic without much effort. If, by some miracle, my business goes crazy viral, I know that my cloud provider can probably handle up to 200,000 customers by just updating a slider in my dashboard, which is way more business than I want anyway. Engineers love to fantasize about Google levels of scale, but that's just not realistic for a lot of services.
qphe95 2mo ago
I'm reading the code for this and I'm like yeah it doesn't scale. Like forget about debugging this code, does anybody even know what it is doing?
luciana1u 2mo ago
[flagged]
vhiremath4 2mo ago
I once was the CTO of a company that serviced about 100k requests per day across all our services. We grew to millions and eventually 10's of millions, but, somewhere along the way, an engineer on our team decided he wanted to build a queue off LISTEN/NOTIFY semantics in order to take advantage of strong consistency with the rest of our data model, which seemed reasonable given LISTEN/NOTIFY is not that hard to understand and we did need consistency guarantees for this workflow and this would remove the need for yet another place data got stored and transfered. In practice, this eventually ended up being very awkward because extending the functionality (since we had "built" it) and had to work around internal pg semantics (we should have just moved off much sooner). It also did not scale well. We ended up getting a ton of disk contention on our RDS instance in non-obvious ways, and the vacuum runs on that table was a nightmare. Additionally, it was hard to get other engineers to really debug and take ownership of the system because they automatically viewed a queue (very easy to understand) implemented in a foreign way (off pg internals) as something "scary". It was emotional, not rational, but we are emotional beings, and I do not blame them. These were good engineers with a lot of other things on their plates. Obviously, this is all hand-wavy without discussing the internal schema, indeces, etc. that we had set up, but my main takeaway with core technology from this experience was to always reach for the dumb, expected, simple thing. Even if it adds another moving piece in the infra stack. Unless I need very strong data consistency guarantees, it's always better to use something like SQS, Redis queues, etc. where the understanding is that it is just a queue (or at least the API contract suggests simplicity), and then everything needs to work around it. The fewer mechanistic responsibilities per core data store, the better in my experience.
- zmmmmm 2mo ago
  It is so rare that a new moving part beats other factors. But the one thing I will say is that there's tremendous advantages to of all things, your queuing system being independent of other architectural pieces : it's the one component built to natively store and forward, so if you can keep its lifecycle separate then you can harness that to decouple other systems from each other during updates, troubleshooting, patch windows etc.
  - 2mo ago
b-man 2mo ago
related: https://pgdog.dev/blog/scaling-postgres-listen-notify https://pgdog.dev/blog/scaling-postgres-listen-notify
elendilm 2mo ago
The tested machine appears big and with 96 vcpu + 384 gb yielding 20k writes sounds too low. Jumping to 60k is very good. But still too small a throughput for what the machine is capable of. Batching ensures you run at cpu & memory speeds and only pay significant latency for the flush - which usually linux kernel coalesces well if concurrent.
- gunnarmorling 2mo ago
  Yeah, with that machine spec, I think if anything, the post goes to show that LISTEN/NOTIFY does actually _not_ scale well. A CDC-based solution would give you a multiple of these numbers on much smaller (and cheaper) hardware.
villgax 2mo ago
Even AI generated art needs taste, looks so bland & off-point.
phamilton 2mo ago
Just sharing a data point and experience. We had a lot of success with LISTEN/NOTIFY when we paired it with a Rust graphql subscription broker. 10s of thousands of subscriptions, but only 3 or 4 LISTEN connections (one for each host). All changes would be pushed out to all hosts, who would each manage the actual user subscriptions and choose what to actually publish. This worked super well. In general, moving from hundreds of Ruby or Node hosts to just a few Rust hosts just allows so many simplifications and things that "don't scale" to actually work quite well.
- hoodaly 2mo ago
  I‘m interested, which graphql library for Rust can you recommend?
  - rneswold 2mo ago
    I like 'async-graphql'. I tried 'juniper' but, at the time, it didn't have as many features. That may have changed over the last year or so since I looked at it.
  - phamilton 2mo ago
    Any graphql library would work. I like async-graphql except compilation is a bear due to all the macros. We wired LISTEN up to subscriptions using tokio mpmc channels. It was a great moment of "fearless concurrency", it all just worked.
luciana1u 2mo ago
[flagged]
konstmonst 2mo ago
I had to use it in production and it abdolutely doesn't scale and actually looses messages if the load is high enough.
keynha 2mo ago
[dead]
dagss 2mo ago
I feel like the article is leaving the most important part out ; how to allocate that "offset" (sequence number) which allows consumers to keep tabs on how far they have read and query if there are new messages in the fallback. There are a few schemes, some more creative than others, but it is not a trivial problem to solve without complexity or possibility of lock contention (or races with consumers if you do it the wrong way). Most people I guess have writers acquire a lock, for instance on a single row in a state table, for allocating the next sequence number for an event topic. What is the best way? Perhaps a tool that reads CDC and writes allocated event sequence numbers to another table would work ok, or would that have long latency? And that CDC processor should then do the NOTIFY too. Also on the consumer side in some usecases batching can drastically improve throughput. You don't even use LISTEN/NOTIFY then. Just run the consumer in a loop and each iteration process all new unprocessed messages, and store your last sequence number processed between iterations.
issung 2mo ago
My recommendation to everyone out there willing to put in the effort of writing an article; don't put a naff low effort AI generated image at the top of it (or anywhere in it..). It turns me off before I've even read the first word.
MrBuddyCasino 2mo ago
That makes one wonder, why is there only an option for globally ordered NOTIFYs? I would expect to have a little more tuning knobs available: - explicitly unordered - ordered per table, but not globally
tonyx1998 2mo ago
[flagged]
stuaxo 2mo ago
There are so many in important things built that run perfectly fine on one postgres database, maybe redis as well and one to three of the smaller ec2 instances.
deleted 2mo ago
[deleted]
gatekeephqpro 2mo ago
[flagged]
eudamoniac 2mo ago
Something interesting is that postgres PostGIS index for location finding scaled well enough for Uber. They eventually switched to something else but I don't think it was due to scaling problems.
rlio 2mo ago
the article mentions lock contention on the global queue, but i think doesn’t mention the other problem with a fixed size global queue: a single slow reader on one channel can block all writes to all channels. (at least this was a failure mode a few years ago! perhaps it’s changed since i last looked)

373 points by KraftyOne 2mo ago

I recall that in the first release that supported LISTEN/NOTIFY there was a performance issue around it (poor locking IIRC), which today the "bad post" mentioned in here corrects in a errata just after their first paragraph. Since the correction apparently dates from May 8th, I think that a post from July 24th might want to acknowledge that the popular post asserting this feature doesn't (didn't?) scale was not made in bad faith or was even wrong about their claims at the time.

KraftyOne 2mo ago
If you mean the optimizations coming in Postgres 19, the original post addresses this: > As an aside, there’s been some online discussion of a Postgres patch (https://github.com/postgres/postgres/commit/282b1cde9dedf456ecf02eb27caf086023a7bb71 https://github.com/postgres/postgres/commit/282b1cde9dedf456...) related to this issue. This patch (to be released in Postgres 19) does not remove the global lock or fix the bottleneck we observed. Instead, it optimizes the narrower case where there are many notification channels and each listener is waiting only on a specific channel.
- JoelJacobson 2mo ago
  It did fix the original "Postgres LISTEN/NOTIFY does not scale" [1] post's problem though, which was mentioned in an update of that article: Update: Fixed in Postgres core This commit has eliminated the bottleneck in the postgres core. Credit to Joel Jacobson and the core postgres contributors for resolving this. [1] https://www.recall.ai/blog/postgres-listen-notify-does-not-scale https://www.recall.ai/blog/postgres-listen-notify-does-not-s...

Latty 2mo ago

One way it explicitly doesn't scale (unless something has changed since I last checked and my quick search failed me) is the hard limit on 8000 bytes of data in a notification. If your notification doesn't make sense to exist as a row (where you can just give an ID), then that makes it hard to use. I had a web game and the events were transient descriptions of changes in state that didn't make sense to store in the database, and could be bigger than that, so it didn't work for that use case.

dietr1ch 2mo ago
As an implementer of a scalable notification system I'd be sure to cap the notification size. - Keeps messages O(1) so I can focus on scaling in the amount of notifications - Tells whoever runs into this that, - I didn't planned for arbitrarily large messages as they *might* otherwise grind performance to a halt. - They *might* be misusing my notification system
pgwhalen 2mo ago
Could you not send a message that pointed to the state that changed in a non-row-specific way?
- Latty 2mo ago
  It was diffs in state that got sent to the client, so recomputing them from the current state would have required having the previous state.

jerf 2mo ago

"Scale" isn't a binary, it's a continuum. "Scales to 60K/s" can be 5 orders of magnitude more than one system needs and 5 orders of magnitude too small for another. Personally I'd knock the general "premature optimization" off the list of "most common developer errors" and put in its place "using techs with the wrong scaling factors". If you use something too small and you exceed its needs, the failure is obvious, but the other way around is a problem too. Bringing in the overhead and management issues of the super scalable techs, as well as their limitations they impose so that they can scale, to a system that would actually be better off with a richer model whose richness prevents it from scaling but would save a lot of effort is also a bad choice. The ceiling of LISTEN/NOTIFY is small enough that you need to pay attention, and I personally like to have at least an order of magnitude of slack left over even after my most pessimistic load numbers are accounted for, but it's still plenty for a lot of projects, and the integration with the rest of the DB, its availability, its not being another service you have to devops, it's definitely not something that should be simply dismissed out of hand as an option. Even the original 2K/s number they cite is a lot of messages for some systems that are more properly measured in seconds per message.

zbentley 2mo ago
> 5 orders of magnitude too small for another. Nitpick on an otherwise good post, but I don’t think there are very many 6billion RPS systems out there, and those that do exist are almost certainly using bespoke, purpose-built tools
- jerf 2mo ago
  Fair.
- odo1242 2mo ago
  The highest I could think of is WhatsApp, which gets ~1.6 million RPS on average, and they use MQTT
  - znpy 2mo ago
    DynamoDB scales much more than that. In one of their dynamodb papers they claimed that the amazon us retail website alone made like 89 millions rps during prime day, a few years ago.

nzoschke 2mo ago

I continue to love DBOS for how it just leverages Postgres (and now SQLite) properly. It's effortless to drop into an existing CRUD stack. Once you start down the "durable workflows" path, you start seeing them everywhere. My latest experiments are treating individual emails as durable workflows, where you, the people you're communicating with, agents and tools like GitHub or Attio all take turns in the flow. https://housecat.com/blog/gmail-durable-workflows-sandbox-vm https://housecat.com/blog/gmail-durable-workflows-sandbox-vm

mamcx 2mo ago

Is the optimization only possible using dbos? is not clear to me if this mean a way to tune normal PG

KraftyOne 2mo ago
The core optimization is to buffer notifications in-memory and send them in a batch instead of sending them as part of every transaction. So that's a general-purpose optimization for Postgres apps using LISTEN/NOTIFY.
- mamcx 2mo ago
  So this is not inside a trigger but on the app connected to pg?
  - gordonhart 2mo ago
    Yes, per the article they “scaled” Postgres to meet their requirements by altering their usage pattern to avoid hitting the bottleneck.

jrochkind1 2mo ago

If I understnad right, they are saying it scales (to theri needs) with a custom patch to pg changing their semantics, right? It does seem interesting, and possibly welcome if there were a configuration option or even a way to set individual notifies as serialized or not.

KraftyOne 2mo ago
To be clear, it's not a custom patch to pg itself, but an application-side buffering and batching optimization.
- jrochkind1 2mo ago
  Ah, thanks. I am not following at all how an application can do this.

acaloiar 2mo ago

Much of the FUD around using LISTEN/NOTIFY in production comes from people who have never done so. It of course has its limits, and we should remain aware of them. Much like the limits of every piece of tech in our stacks. Choose database queue technology https://news.ycombinator.com/item?id=37636841 https://news.ycombinator.com/item?id=37636841

hxtk 2mo ago
Personally I love it for cache invalidation. I used it on an older especially on project originally built without caching in mind that then added caching for immutable data without caching for mutable data in mind. It fell to me to add caching of mutable data. I found it rather convenient to put NOTIFY triggers on cached tables and have a LISTENer that will delete the corresponding rows from memcached when it gets a notification. It’s basically impossible to out-scale it in that use case because the scale is intrinsically linked to number of writes the leader in your database processes.
- muaazkhan 2mo ago
  and here was I thinking ( when creating same cache invalidation system ) that I was the only one that came up with this patch. LMAO

zenith605 2mo ago

[dead]

David_runai 2mo ago

[flagged]

tjadfsaj 2mo ago

Sure it "scales" if clients batch commands to amortize the per-request cost. The word "scale" does a lot of load-bearing, maybe it's just not a useful or productive word in practice.

sandeepkd 2mo ago

I think a lot of these kind of posts are standalone assessment of your problems, understanding and solutions. Its debatable to term something as lack of expertise if one is trying to work with default settings of a tool and expecting a certain performance. Everyone is doing a continuous learning with the failures. 1. What I find interesting is that the experiment seems to be using a DB server with 96 cores, 384 GB RAM (https://github.com/dbos-inc/dbos-postgres-benchmark/blob/main/terraform/main.tf#L85 https://github.com/dbos-inc/dbos-postgres-benchmark/blob/mai...). This is very critical part of any such experiment, it should have been called out. The database is vertically scalable and that too has its limits 2. Who is making connection, and from where has its own impact on performance and overall latency 3. 60k may seem big number, however in real world the things which bring the systems down are the bursts of traffic, not the regular traffic. Personally I would never start with such a big server unless I am a big business. Its > 100K cost for one production DB cluster if I include read replicas and cross region redundancy

elendilm 2mo ago
Agreed

d9127acbd6fe281 2mo ago

So in summary, Postgres NOTIFY actually scales if you make your application not write to the database? That's a bit of a tough sell...

abratabia 2mo ago

[flagged]

dang 2mo ago

Related, presumably: Postgres LISTEN/NOTIFY does not scale - https://news.ycombinator.com/item?id=44490510 https://news.ycombinator.com/item?id=44490510 - July 2025 (321 comments)

newswangerd 2mo ago

I went through this process when I was designing the sync server for Digital Carrot. In the end, I decided to just go with the simplest solution possible. In my case it's just a barebones Go gRPC service that uses an in memory channel to send notifications between connected clients. The reality is that this simple Go server will scale up to about 1000 simultaneously connected customers on about 2gb of RAM. I don't expect to have more than that many paying customers, and if I do I can always just throw a bigger VM at the problem. Engineers love to over complicate things in the name of infinite scalability, when in reality you can save a lot of time and effort by just understanding the scope of the actual problem you're trying to solve. Fingers crossed that this will become an issue for me some day, but until then most of us just don't need to worry about it!

anachronox 2mo ago
I had a similar setup, scaled pretty well with some GOGC tuning. I had a small, simple "router" using channels https://github.com/urjitbhatia/gopipe https://github.com/urjitbhatia/gopipe and except for the per connection 16ish kb network overhead per socket, you can get away with a lot of performance with a small hand rolled service.
znpy 2mo ago
1000 connections is a fairly low number by modern standards, c10k “challenges” are like twenty years old by now. The real questions are: - how many messages per second are you processing on that 2gb machine (and using how many cpus)? - does your message processing involve transaction handling, including saving data ti disk durably? No offense but it really seems you’re comparing apples and oranges, with your use case being much much simpler than the one described.
- newswangerd 2mo ago
  These are all very conservative back of the napkin calculations. Also, this isn't 1000 connections. It's 1000 customers, each of which can consume dozens of connections. My point here is that it is important to match the tech stack to the challenge you're facing. When I started thinking about how to solve this problem my first reaction was to design an overly complicated distributed message queue using PG Notify, Redis, Kafka or something along those lines. The key takeaway here is that I realized that I probably wouldn't end up with more than 1000 customers, so I just needed to design a system that could comfortably handle that level of traffic without much effort. If, by some miracle, my business goes crazy viral, I know that my cloud provider can probably handle up to 200,000 customers by just updating a slider in my dashboard, which is way more business than I want anyway. Engineers love to fantasize about Google levels of scale, but that's just not realistic for a lot of services.

qphe95 2mo ago

I'm reading the code for this and I'm like yeah it doesn't scale. Like forget about debugging this code, does anybody even know what it is doing?

luciana1u 2mo ago

[flagged]

vhiremath4 2mo ago

I once was the CTO of a company that serviced about 100k requests per day across all our services. We grew to millions and eventually 10's of millions, but, somewhere along the way, an engineer on our team decided he wanted to build a queue off LISTEN/NOTIFY semantics in order to take advantage of strong consistency with the rest of our data model, which seemed reasonable given LISTEN/NOTIFY is not that hard to understand and we did need consistency guarantees for this workflow and this would remove the need for yet another place data got stored and transfered. In practice, this eventually ended up being very awkward because extending the functionality (since we had "built" it) and had to work around internal pg semantics (we should have just moved off much sooner). It also did not scale well. We ended up getting a ton of disk contention on our RDS instance in non-obvious ways, and the vacuum runs on that table was a nightmare. Additionally, it was hard to get other engineers to really debug and take ownership of the system because they automatically viewed a queue (very easy to understand) implemented in a foreign way (off pg internals) as something "scary". It was emotional, not rational, but we are emotional beings, and I do not blame them. These were good engineers with a lot of other things on their plates. Obviously, this is all hand-wavy without discussing the internal schema, indeces, etc. that we had set up, but my main takeaway with core technology from this experience was to always reach for the dumb, expected, simple thing. Even if it adds another moving piece in the infra stack. Unless I need very strong data consistency guarantees, it's always better to use something like SQS, Redis queues, etc. where the understanding is that it is just a queue (or at least the API contract suggests simplicity), and then everything needs to work around it. The fewer mechanistic responsibilities per core data store, the better in my experience.

zmmmmm 2mo ago
It is so rare that a new moving part beats other factors. But the one thing I will say is that there's tremendous advantages to of all things, your queuing system being independent of other architectural pieces : it's the one component built to natively store and forward, so if you can keep its lifecycle separate then you can harness that to decouple other systems from each other during updates, troubleshooting, patch windows etc.
- 2mo ago

b-man 2mo ago

related: https://pgdog.dev/blog/scaling-postgres-listen-notify https://pgdog.dev/blog/scaling-postgres-listen-notify

elendilm 2mo ago

The tested machine appears big and with 96 vcpu + 384 gb yielding 20k writes sounds too low. Jumping to 60k is very good. But still too small a throughput for what the machine is capable of. Batching ensures you run at cpu & memory speeds and only pay significant latency for the flush - which usually linux kernel coalesces well if concurrent.

gunnarmorling 2mo ago
Yeah, with that machine spec, I think if anything, the post goes to show that LISTEN/NOTIFY does actually _not_ scale well. A CDC-based solution would give you a multiple of these numbers on much smaller (and cheaper) hardware.

villgax 2mo ago

Even AI generated art needs taste, looks so bland & off-point.

phamilton 2mo ago

Just sharing a data point and experience. We had a lot of success with LISTEN/NOTIFY when we paired it with a Rust graphql subscription broker. 10s of thousands of subscriptions, but only 3 or 4 LISTEN connections (one for each host). All changes would be pushed out to all hosts, who would each manage the actual user subscriptions and choose what to actually publish. This worked super well. In general, moving from hundreds of Ruby or Node hosts to just a few Rust hosts just allows so many simplifications and things that "don't scale" to actually work quite well.

hoodaly 2mo ago
I‘m interested, which graphql library for Rust can you recommend?
- rneswold 2mo ago
  I like 'async-graphql'. I tried 'juniper' but, at the time, it didn't have as many features. That may have changed over the last year or so since I looked at it.
- phamilton 2mo ago
  Any graphql library would work. I like async-graphql except compilation is a bear due to all the macros. We wired LISTEN up to subscriptions using tokio mpmc channels. It was a great moment of "fearless concurrency", it all just worked.

luciana1u 2mo ago

[flagged]

konstmonst 2mo ago

I had to use it in production and it abdolutely doesn't scale and actually looses messages if the load is high enough.

keynha 2mo ago

[dead]

dagss 2mo ago

I feel like the article is leaving the most important part out ; how to allocate that "offset" (sequence number) which allows consumers to keep tabs on how far they have read and query if there are new messages in the fallback. There are a few schemes, some more creative than others, but it is not a trivial problem to solve without complexity or possibility of lock contention (or races with consumers if you do it the wrong way). Most people I guess have writers acquire a lock, for instance on a single row in a state table, for allocating the next sequence number for an event topic. What is the best way? Perhaps a tool that reads CDC and writes allocated event sequence numbers to another table would work ok, or would that have long latency? And that CDC processor should then do the NOTIFY too. Also on the consumer side in some usecases batching can drastically improve throughput. You don't even use LISTEN/NOTIFY then. Just run the consumer in a loop and each iteration process all new unprocessed messages, and store your last sequence number processed between iterations.

issung 2mo ago

My recommendation to everyone out there willing to put in the effort of writing an article; don't put a naff low effort AI generated image at the top of it (or anywhere in it..). It turns me off before I've even read the first word.

MrBuddyCasino 2mo ago

That makes one wonder, why is there only an option for globally ordered NOTIFYs? I would expect to have a little more tuning knobs available: - explicitly unordered - ordered per table, but not globally

tonyx1998 2mo ago

[flagged]

stuaxo 2mo ago

There are so many in important things built that run perfectly fine on one postgres database, maybe redis as well and one to three of the smaller ec2 instances.

deleted 2mo ago

[deleted]

gatekeephqpro 2mo ago

[flagged]

eudamoniac 2mo ago

Something interesting is that postgres PostGIS index for location finding scaled well enough for Uber. They eventually switched to something else but I don't think it was due to scaling problems.

rlio 2mo ago

the article mentions lock contention on the global queue, but i think doesn’t mention the other problem with a fixed size global queue: a single slow reader on one channel can block all writes to all channels. (at least this was a failure mode a few years ago! perhaps it’s changed since i last looked)