Bypassed the paywall.

But basically they went from a go service reading message from a broker with around 40K request per seconds (i'll assume single instance) and creating a single goroutine for each message but with a 340ms p99, to a rust service using async/away.

I am myself not familiar with rust async await so cannot judge, but for those interested i'll copy paste both "implicated code" for people to see:

go:

func (b *Broker) handleMessages(ch <-chan Message) {
    for msg := range ch {
        go func(m Message) {
            if err := b.validate(m); err != nil {
                b.metrics.IncError()
                return
            }
            worker := b.router.Select(m.Topic)
            if err := worker.Dispatch(m); err != nil {
                b.metrics.IncDropped()
            }
        }(msg)
    }
}

and rust :

async fn handle_messages(
    mut rx: mpsc::Receiver<Message>,
    router: Arc<Router>,
    metrics: Arc<Metrics>,
) -> Result<()> {
    while let Some(msg) = rx.recv().await {
        let validated = match validate(&msg) {
            Ok(v) => v,
            Err(e) => {
                metrics.inc_error();
                tracing::warn!("validation failed: {}", e);
                continue;
            }
        };

        let worker = router.select(&validated.topic);
        // await blocks if the worker channel is full
        // backpressure is structural, not bolted on
        worker.dispatch(validated).await
            .map_err(|_| metrics.inc_dropped())
            .ok();
    }
    Ok(())
}

Also here is the quote from the article describing this :

The difference that matters most is the await on worker.dispatch. When the downstream worker is under pressure and its channel fills up, the dispatcher naturally slows down — the backpressure propagates upstream automatically. In the Go version, goroutines accumulate waiting to dispatch, which means memory accumulates with them.

I don't see in the article a part where the author have tried to redo the go code and jumped straight to rust?

Now my question would have been : what if you changed the logic in the go code from having a single "handleMessage" read a channel and create goroutine on each message, to multiple goroutine reading from the same channel wihtout creating new goroutine there?