Modern message brokers promise scalability, reliability, and decoupling—but ordering is where things get complicated. As developers, we assume that messages are processed in the order they were sent. In reality, distributed systems make this surprisingly difficult. Partitions, retries, competing consumers, redelivery, and parallel processing all introduce subtle ways for ordering to break down. In this talk, we'll explore how message ordering actually works across some of the popular brokers, what guarantees they provide, and where those guarantees end. More importantly, we'll look at how to use these guarantees to achieve ordered processing, why strict ordering often conflicts with scalability and resilience, and when designing for out-of-order messages is the better choice. You will learn: - When ordering is guaranteed - and when it isn't - How different brokers implement ordering and how to use their guarantees to achieve ordered processing - Why retries and failures can silently break ordering - When strict ordering is necessary and when it is a trap - Practical patterns to design systems that remain correct even when messages arrive out of order By the end, you'll understand the trade-offs behind ordered messaging and how to design systems that embrace the realities of distributed systems.