Amazing post!

Absolutely, I’ve seen similar situations where everything looked successful in logs, but the real issue appeared later in processing or downstream systems. That gap between accepted and actually completed is often where the hardest debugging starts.

Great insights. Really well explained and highly relevant for anyone building reliable messaging infrastructure. Looking forward to reading more of your posts.

That makes a lot of sense. Once failover is visible and intentional, you’re no longer reacting to a black box — you’re designing around known behavior. I think that’s where a lot of teams struggle. They treat messaging as a simple API call, but in production it’s really an operational system with tradeoffs, metrics, and failure paths. When those parts are exposed, it stops feeling random and starts feeling manageable. That’s a big difference.

I’d probably lean toward control too, especially for critical traffic like OTP or transactional messages. Better delivery rates sound great until you can’t explain why results keep changing. Once routing decisions become invisible, debugging and planning get a lot harder. I think the best balance is controlled failover: clear metrics, visible route health, and switching based on defined rules instead of silent automation. For bulk traffic I’d be more flexible, but for anything important I’d take predictability over magic every time. Really interesting tradeoff though, because both sides matter depending on the use case.

This is honestly one of the clearer explanations I’ve seen of how SMS actually works behind the scenes. The part that clicked for me is the idea that you’re not really “sending a message”, you’re basically handing a request into a system that makes a bunch of decisions you normally never see. Most APIs just return “accepted” and that’s it, which is fine until something breaks and you have zero visibility. I also like how you frame routing as the core of everything not just delivery, but pricing, behavior, even validation. That’s usually completely hidden, so when costs or delivery change, it feels random from the outside. The route-based pricing + exposing things like route_id and message lifecycle makes a big difference. At least then you can reason about what’s happening instead of guessing. Curious though, how do you deal with situations where a route starts degrading? Do you keep it deterministic and fail, or switch routes dynamically? Feels like that’s where things get tricky in real-world usage