Message Center - Redesigning the messaging experience on the Grab superapp

Summary

Grab redesigned its messaging infrastructure from GrabChat to Message Center to overcome two-party chat limitations and support complex superapp requirements like group conversations and varied user roles. The architecture separates core processing logic from message delivery by splitting the system into a backend processor and an independently scalable postman service. Communication relies on an in-house TCP gateway named Hermes that proxies client payloads via gRPC, alongside Apache Kafka streams and Amazon SQS delay queues. Custom client-server acknowledgements and a DynamoDB event store ensure reliable message delivery even across dropped mobile TCP connections and offline reconnects.

Context

Grab's legacy chat system, GrabChat, was designed strictly for two-party chats and could not support group messaging, custom multi-user UI logic, translation, profanity filtering, or system-generated notifications across the expanding superapp.

Approach / What changed

Grab built Message Center with decoupled message-center backend and postman delivery services connected through Apache Kafka and Amazon SQS, using a TCP gateway (Hermes) that proxies traffic over gRPC, a custom bidirectional ACK protocol, DynamoDB event state tracking, and fallback push notifications via Hedwig.

Takeaways

• Decoupling the message processing backend from the postman delivery service enables message delivery to scale independently when group chats multiply outbound message volume.
• Because standard TCP packets lack inherent application-layer response guarantees, a bidirectional ACK system with idempotent event IDs is necessary to verify delivery and avoid cascading retry loops.
• When client TCP connections drop, Message Center triggers push notifications via Hedwig and records pending events in DynamoDB, replaying undelivered messages once the client reconnects and notifies Hermes.

Related reading

• Grab · Nov 17, 2023

  Road localisation in GrabMaps

  Grab needed to localise nearly 30 million road segments across more than 10,000 area boundaries in Southeast Asia to attach hyperlocal attributes like language, driving side, and vehicle access rules. Testing direct geometric inclusion between complex road polylines and boundary polygons proved computationally prohibitive for daily map generation pipelines. To optimize this process, Grab introduced geohashes as rectangular proxies, precomputing geohash coverage across borders and road segments before joining the datasets in parallel. To resolve misclassification errors near borders without sacrificing performance, the team evaluated geohash coverage percentages and refined boundary-touching geohashes with polygon clipping. A laptop benchmark on a subset of data reduced runtime from 38 minutes with geometric intersection to 78 seconds using the geohash approximation.

  Roxana Crisan

• Grab · Apr 28, 2022

  Graph Networks - Striking fraud syndicates in the dark

  Grab's Integrity team faced escalating threats from organized fraud syndicates operating device farms and GPS spoofing tools that mimic normal user behavior. To overcome the limitations of traditional rule-based systems, Grab built a Graph-based Prediction Platform that links entities across shared attributes to expose hidden network structures. The architecture includes a scalable graph database platform holding over one billion nodes, powering real-time graph visualization for analysts alongside a configurable network feature extraction system. In addition, the team deployed Graph Neural Networks to capture structural correlations across transaction networks. These systems collectively help detect coordinated promo abuse, payment fraud, and complex money laundering schemes.

  Muqi Li

• Grab · Jun 1, 2023

  PII masking for privacy-grade machine learning

  Data engineers at Grab require real-world streaming data to tune machine learning models, but user personal data cannot be exposed in non-production environments. To solve this, the data streaming team implemented an automated masking pipeline between production and staging Kafka clusters. Developers explicitly tag Personally Identifiable Information (PII) types in Protocol Buffers schemas, which a CI script validates against a keyword list before packaging the schemas into Scala JARs. An in-house Apache Flink application running in production consumes the unmasked streams, applies dynamic and consistent transformations like keyed HMACs or seeded random values, and produces sanitised records to staging. Untagged new fields in schema updates are automatically dropped by the deserialiser until the masking application is redeployed, preventing accidental data leaks.

  Fabrice Harbulot

• Grab · Nov 8, 2023

  Graph modelling guidelines

  Graph modelling uses graph theory to represent real-world entities, relationships, and properties through nodes and edges, unlocking insights across interconnected datasets. The process begins with defining domain concepts, mapping entities and relationships, and assigning relevant descriptive properties to both nodes and edges. Practitioners choose between graph structures such as property graphs or Resource Description Framework models before optionally developing a structural schema. Data is then imported or generated to populate storage systems such as Neo4j, Amazon Neptune, Azure Cosmos DB, or in-memory data structures. Finally, the graph is visualised and analysed using algorithmic methods like shortest path calculation, centrality measurement, and community detection.

  Wenxiang Lu