Blogs
Grab logo

Grab

Engineering blog · engineering.grab.com

215posts0this week0watchers

Feature trails

92
Feature trailActive

AI-led Research Simulation Platform

Grab has developed sim-rs, a self-contained simulator for marketplace operations, enabling rapid experimentation with dispatch strategies. This platform connects to AI agents via an autoresearch loop, automating the research cycle for discovering better strategies and keeping the simulator faithful to production behavior. Safeguards against specification gaming and performance improvements to the simulator itself are key components of this evolution.

1 post · 2026

Timeline

Feature trailActive

Automated Merchant Review Summary System

Grab has developed an Automated Merchant Review Summary System to transform unstructured customer reviews into concise, topic-based summaries. This system employs representative sampling, LLM-based summarization and quality control, and a feedback-driven regeneration pipeline to ensure summaries are accurate, relevant, and up-to-date. The goal is to provide consumers with easily scannable insights and merchants with actionable feedback on food quality, portion size, packaging, and value.

1 post · 2026

Timeline

Feature trailActive

Data Production Issue (DPI) Operationalization

Grab has evolved its data mesh operationalization by implementing an automated Data Production Issue (DPI) lifecycle. This system, orchestrated by Kinabalu, detects contract breaches via Genchi's data quality tests and automates triage, diagnosis (categorized into UPSTREAM_ERROR, PLATFORM_ERROR, JOB_ERROR, DATA_ERROR), and resolution. Hugo, the ingestion platform, plays a key role in diagnosing failures by consolidating signals and providing root cause analysis. Auto-resolution workflows handle common transient errors. The Data Health Workbench provides a centralized dashboard for monitoring and manual intervention. Future work includes advancing auto-resolution strategies, enriching the Data Health Workbench, and broadening diagnostics to include more infrastructure components like Flink.

16 posts · 2019–2026

Timeline

20192026
Feature trailActive

AI Assistant Routing and Context Management

Grab's AI Assistant for account managers, Jarvis Pro, has evolved with a 'route first, answer later' design. This system classifies user prompts to determine the appropriate task type, scope, and necessary context before generating an answer. This approach aims to prevent common errors by ensuring the system understands the user's intent and loads only relevant information, improving the accuracy and safety of AI-generated recommendations. The post details the router's design, memory management, and evaluation strategies, emphasizing the tradeoff between first token latency and response safety. Regression checks were implemented to reconcile metric discrepancies between reporting surfaces.

1 post · 2026

Timeline

Feature trailActive

AI Agent Framework

Grab's AI Gateway provides a centralized, unified interface for accessing multiple GenAI providers (OpenAI, Azure, AWS Bedrock, Google VertexAI, etc.). It streamlines access, enables experimentation with various LLMs, optimizes cost-efficiency through shared capacity, and enforces auditing and platformization benefits like monitoring, cost attribution, and rate limiting. The architecture acts as a reverse proxy, handling authentication, authorization, and rate limiting, while also supporting div. The LLM-Kit is a comprehensive framework designed to supercharge the setup of production-ready LLM applications, providing a pre-configured structure, integrated tech stack, built-in observability, efficient config and secret management, authentication, API documentation, Redis & vector database integration, a deployment pipeline, and seamless integration with LangSmith for evaluations. It has onboarded hundreds of GenAI applications and is the de facto choice for developers, saving an estimated 1.5 weeks per team before feature development.

3 posts · 2024–2026

Timeline

20242026
Feature trailActive

AI-Assisted Analytics

Grab's AI-Assisted Analytics initiative has evolved with Metasense V2, an LLM-powered system for data governance. This iteration enhances data classification by splitting the model into PII and non-PII taggers, refining prompts for better accuracy with complex data structures, and improving model capacity by reducing tag count and handling large tables. The integration of LangChain and LangSmith frameworks streamlines prompt experimentation, evaluation, and deployment, enabling rapid iteration. The Gemini orchestration service now integrates LLM classification for column-level tagging, addressing challenges with third-party tools and manual classification. It manages requests, aggregates them into batches, and employs rate limiting. The LLM is prompted to act as a column tag classifier, assigning tags based on table and column names, with a defined set of tags and a JSON output format. Techniques like clear articulation of requirements and few-shot learning are used for prompt engineering.

11 posts · 2019–2026

Timeline

20192026
Feature trailActive

Android Studio IDE Performance in Monorepo

Grab has evolved its Android Studio IDE performance by developing a custom Focus plugin. This plugin leverages pre-computed dependency graphs from the Gradle-to-Bazel migration workflow to allow developers to selectively sync only the modules they are actively working on, drastically reducing sync times and memory consumption. The plugin integrates seamlessly with Android Studio via an IntelliJ plugin, providing a user-friendly interface for module selection and dependency visibility, thereby improving developer productivity in large monorepos.

2 posts · 2020–2026

Timeline

20202026
Feature trailActive

Counter Service Storage Migration

Grab's Counter Service has evolved to provide a self-service platform for fraud detection, enabling data scientists and analysts to create and manage counters without direct engineering intervention. The system is designed for high scalability, handling billions of transactions daily by leveraging Aerospike for time-series data storage with a map-based schema for optimized storage and retrieval. This migration focused on decoupling storage concerns from business logic, redesigning the data model, and optimizing performance by removing a Redis cache and relying on Scylla's native caching. This has led to more balanced load and reduced latency during peak hours.

5 posts · 2017–2026

Timeline

20172026
Feature trailActive

Data Lake Modernization with Apache Iceberg

Grab has adopted Apache Iceberg as the foundational table format for its data lake, migrating from Hive Parquet. This transition addresses challenges with catalog latency, the small file problem, operational toil, and data consistency. A key component of this migration is the open-sourced UnifiedSparkCatalog, which provides significant improvements in query performance, reduced S3 API costs, and compute savings. The Talaria time-series database has evolved to use Go plugins for custom data processing.

6 posts · 2017–2026

Timeline

20172026
Feature trailActive

Distroless Image Adoption and Testing Automation

Grab is systematically migrating services to Distroless images to enhance security by reducing the attack surface. This involves a rigorous testing strategy to mitigate runtime failures caused by missing dependencies. An AI-powered agent has been developed to automate the scaffolding of medium tests for services lacking them, and to manage the Distroless image patching and verification loop. This automation significantly accelerates the adoption process and ensures the reliability of migrated services.

1 post · 2026

Timeline

Feature trailActive

Knowledge Graph Verification

Grab has evolved its knowledge graph verification process by operationalizing the search interface as a validation environment. This feedback-driven framework injects unverified candidate edges generated by LLMs into live search results and recommendation carousels. User micro-interactions are tracked and aggregated to calculate a confidence score, which is then used to promote verified edges or prune hallucinated ones. This system ensures the accuracy and integrity of the knowledge graph in dynamic catalogs.

1 post · 2023–2026

Timeline

20232026
Feature trailActive

TechDocs Platform and Documentation Culture

Grab's TechDocs platform, built on Helix and embracing a Docs-as-Code approach, has evolved to cultivate a high-quality documentation culture. This involves a multi-year strategy focusing on inventorying existing processes, finalizing and enforcing documentation policies, empowering creators with self-serve tools, and tracking metrics to celebrate wins. Key improvements include the TechDocs Editor, enhanced search and landing page experiences, clear ownership assignment for documents, and a poli. The platform has transitioned from a decentralized Docs-as-Code model with many repositories to a centralized repository to improve discoverability, consistency, and governance. This shift enables AI-driven enhancements for internal agents, improved quality assurance through automated linters and standardized templates, and a unified search experience powered by Glean. The contribution process is streamlined by a consistent editing environment, and detailed analytics provide insights into documentation maintenance. Automated syncs, training sessions, and continuous feedback were implemented to manage the transition.

4 posts · 2022–2026

Timeline

20222026
Feature trailActive

AI-Assisted Development Tooling

Grab's AI Gateway provides a centralized, unified interface for accessing multiple GenAI providers (OpenAI, Azure, AWS Bedrock, Google VertexAI, etc.). It streamlines access, enables experimentation with various LLMs, optimizes cost-efficiency through shared capacity, and enforces auditing and platform benefits like monitoring, cost attribution, and rate limiting. The architecture acts as a reverse proxy, handling authentication, authorization, and rate limiting, while also supporting div. The AI tool Cursor has been adopted widely, with 98% of Tech Grabbers becoming monthly active users and 75% using it weekly. Cursor's suggestion acceptance rate is around 50%, indicating relevant and critically reviewed suggestions. Engineers utilize Cursor for unit test generation, code refactoring, cross-repository navigation, bug fixing, and automation. Custom tooling was built for monorepo indexing and preconfigured rules to align with Grab-specific coding conventions. Beyond engineering, AI-assisted development is expanding to non-technical teams and product design for direct production fixes. Productivity gains are observed to scale with usage intensity.

9 posts · 2021–2026

Timeline

20212026
Feature trailActive

Android App Size Optimization

Grab has implemented Project Bonsai to systematically reduce Android app download and disk sizes. This initiative focuses on measurement, reduction, and containment strategies. Key technical efforts include developing a custom analytics tool (App Sizer) for detailed app binary analysis, optimizing DEX file size by addressing transitive R classes and third-party library bloat, and refining resource management through techniques like using vector images and WebP format, and enabling language resource optimization. This post details the successful enablement of R8 optimization for the Grab Android app, achieving significant improvements in app size, startup time, and stability through innovative AI-assisted debugging techniques, a pragmatic testing strategy, and an optimized feedback loop.

4 posts · 2020–2026

Timeline

20202026
Feature trailActive

App Performance Optimization

Grab has focused on improving app performance, specifically Time To Interactive (TTI), by optimizing app startup time and service tile rendering. Efforts included implementing tile caching, removing non-essential app start animations, adopting static linking on iOS to reduce binary loading time, and utilizing coroutines for parallel library initialization on Android. The team also enhanced their visualization and tracking of performance metrics using Metabase and migrated to an in-house experimentation platform.

1 post · 2019–2026

Timeline

20192026
Feature trailActive

Time-Aware Image Caching

Grab has evolved its image caching strategy by implementing a Time-Aware Least Recently Used (TLRU) cache. This enhancement builds upon the existing DiskLruCache foundation, introducing Time-To-Live (TTL) for automatic eviction of stale content, a minimum cache size threshold to protect essential images, and retaining the maximum cache size for storage management. The TLRU cache aims to reclaim terabytes of storage space by proactively removing outdated images without impacting use. The Drivers

2 posts · 2021–2026

Timeline

20212026
Feature trailActive

Container Image Optimization

Grab is optimizing container images to reduce startup times for data platforms like Airflow and Spark Connect. This involves implementing Docker image lazy loading using eStargz and Seekable OCI (SOCI) technologies, which significantly reduces image pull times and improves auto-scaling performance. The team has tuned SOCI configurations for further gains and observed substantial improvements in P95 startup times in production.

2 posts · 2021–2026

Timeline

20212026
Feature trailActive

Auto-tracking User Journeys for Troubleshooting

Grab has developed an AutoTrack SDK to comprehensively record application state, UI view state, and user interactions. This SDK aims to revolutionize troubleshooting by providing a detailed, real-time chronicle of user journeys from app launch to interaction completion. It captures application lifecycle transitions, launch mechanisms, and UI screen hierarchies. The captured screen hierarchy data is used to train an AI model that can generate an HTML representation of the user's screen and interaction.

2 posts · 2016–2025

Timeline

…20172026
Feature trailActive

Real-time Personalization Scenarios

Grab's CDP Scenarios feature has evolved to enable event-driven, real-time personalization. This includes integrating user-initiated events, geo-fencing, historical CDP data, and on-the-fly predictions. The system empowers marketers with a self-serve GUI and APIs for creating complex event sequences and validating them with synthetic data. Real-time Flink processing evaluates user historical data via StarRocks and performs predictions using pre-trained models. Outcomes are synced to Kafka or Amphawa (DynamoDB). Future enhancements include optimized Scenario sharding for scalable processing, enhanced signal distribution across multiple destinations, and advanced scheduling and delayed triggering of actions.

6 posts · 2021–2025

Timeline

20212026
Feature trailActive

Bug Bounty Program Evolution

Grab's Bug Bounty Program has evolved over 10 years from a private initiative to a global community, expanding its scope to include financial services and AI systems, introducing dedicated mobile security bounties, and experimenting with diverse reward methods. The program actively engages with researchers through live hacking events and exclusive club campaigns, fostering a collaborative defense network. This evolution is supported by dedicated internal cybersecurity teams and a focus on researcher-centric approaches.

1 post · 2025

Timeline

20252026
Feature trailActive

macOS CI/CD Infrastructure Migration

Grab has evolved its CI/CD infrastructure by developing Khone, an in-house GitOps solution. Khone enhances security, simplifies user experience, and promotes the DRY principle by automating Terraform resource provisioning. It includes a multi-stage pipeline with robust validation, security checkpoints, and remote pipeline configuration to prevent tampering. The solution supports infrastructure beyond Kubernetes and has achieved 100% uptime. This post details the iOS team's approach to continuous delivery automation by migrating macOS CI/CD infrastructure from a cloud vendor to a colocation cluster in Southeast Asia, significantly reducing network latency, improving performance by 20-40%, and achieving substantial cost savings. The migration involved a progressive rollout and rigorous comparison of job failure rates, performance, and reliability between the old and new clusters.

4 posts · 2017–2025

Timeline

20172026
Feature trailActive

Facial Recognition System

Grab has developed and implemented a comprehensive facial recognition system for various applications, including identity verification for consumers and partners, and electronic Know Your Customer (e-KYC) processes for financial services. The system comprises image preprocessing (detection and alignment), face anti-spoofing mechanisms to detect screen replay and printed photo attacks, and feature extraction to generate distinguishing embeddings. Downstream applications include face verification. This post details the development of a custom, lightweight Vision LLM to improve document processing, specifically for eKYC, by overcoming limitations of traditional OCR and proprietary LLMs. The custom model, built from scratch, achieves comparable accuracy to larger models with significantly reduced latency and improved SEA language support. It involves a multi-stage training process including projector alignment, vision tower enhancement, language-specific visual training, and task-centric fine-tuning.

2 posts · 2022–2025

Timeline

20222026
Feature trailActive

Managed Airflow Platform

Grab has established a dedicated team and platform to manage and provision Apache Airflow instances for various engineering teams. This platform standardizes deployment, scaling, dependency management, monitoring, and alerting for Airflow, reducing operational overhead and enabling faster adoption for teams requiring scheduling and orchestration capabilities. The platform leverages Kubernetes for isolated Airflow instances, Terraform for infrastructure management, and a common base Docker image. This post introduces a machine-learning predictive autoscaling solution for Flink applications, specifically targeting CPU provisioning for TaskManagers. It addresses the limitations of reactive autoscaling by forecasting workload based on source topic throughput and using a regression model to predict required CPU. This aims to prevent restart spikes, reactive spirals, and fluctuations, while also tackling the challenge of limited parallelism in certain connectors by focusing on vertical scaling.

2 posts · 2020–2025

Timeline

20202026
Feature trailActive

ML Model Serving Platform Modernization

Grab's ML model serving platform, Catwalk, has evolved from a multi-framework, multi-engine approach to a unified platform leveraging NVIDIA Triton Inference Server. This migration addresses technical debt, performance degradation, and cost inefficiencies. The initial phase focused on integrating Triton for ONNX models, introducing a 'Triton manager' component for seamless drop-in replacement, backward compatibility, and zero-downtime migration. Subsequent phases aim to onboard other ML frameworks. The platform has further evolved to replace Helm charts with Kubernetes CRDs for better deployment control, and then to a high-code, self-served, process-managed platform with the Catwalk Orchestrator, enabling bundled deployments and mandatory load testing. Future plans include Catwalk serverless, data serving, and LLM serving.

3 posts · 2019–2025

Timeline

20192026
Feature trailCooling

Highly Concurrent In-Memory Counter

Grab's Counter Service has evolved into a self-service platform for fraud detection, enabling data scientists and analysts to create and manage counters without direct engineering intervention. The system is designed for high scalability, handling billions of transactions daily by leveraging Aerospike for time-series data storage with a map-based schema for optimized storage and retrieval. This migration focused on decoupling storage concerns from business logic, redesigning the data model, and implementing a highly concurrent in-memory counter with periodic flushing to reduce database load. The use of Sync.Map in GoLang has shown significant performance improvements over traditional mutex-based approaches for high-concurrency, read-heavy workloads.

1 post · 2019–2025

Timeline

20192026
Feature trailCooling

ML Feature Store Evolution

Grab's ML feature store has evolved from Amphawa to a feature-table centric design using Amazon Aurora Postgres. This new design addresses challenges with high-cardinality features, high-dimensional data, and complex feature management. Key improvements include contextual retrieval for composite keys, atomic updates for entire collections of features, and isolation of read/write capacity. The ingestion workflow now emphasizes atomicity and reproducibility, landing feature tables in the data lake.

2 posts · 2025

Timeline

20252026
Feature trailCooling

API Rate Limiting

Grab has implemented a highly scalable API request rate limiting solution called Quotas to mitigate service abuse and cascading failures. The system uses an asynchronous processing pipeline with Kafka at its core, allowing client services to make immediate throttling decisions without significant latency impact. It supports global rate limiting by aggregating API usage stats and making decisions periodically, with client SDKs updating local in-memory caches. The system is designed for horizontal scalability. This post details the integration of Apache Pinot for powering Partner Gateway metrics, focusing on low-latency analytical queries for API traffic status codes and response times. Optimizations include partitioning by metric name, using columns based on aggregation intervals, and implementing a Star-tree index in Apache Pinot to handle large datasets and meet SLA requirements.

8 posts · 2016–2025

Timeline

…20172026
Feature trailCooling

Git Monorepo Optimization

Grab has evolved its approach to managing Go modules within a monorepo, addressing challenges with vendoring, private repository access, inconsistent Go versions, and implementing an automated dependency upgrade system (AutoVend Bot). This has improved build integrity, developer productivity, and security by ensuring dependencies are up-to-date. This post details the initial challenges and solutions for adopting Go modules in a multi-module monorepo, focusing on the transition from the 'vendor' directory to Go modules.

2 posts · 2020–2025

Timeline

20202026
Feature trailCooling

GitLab Upgrade and Operationalization

Grab has evolved its GitLab upgrade strategy from a significant backlog to a consistent, efficient routine. This involved detailed preparation, systematic execution of upgrades (including stateful and stateless components), and the development of robust testing and rollback procedures. The team learned to optimize deployment times, leverage version skipping for faster catch-up, and address challenges like Gitaly sync issues, NFS deprecation, and resource right-sizing. This has led to a 50% reduction in upgrade time and enabled catching up on 24 months of upgrades in 11 months.

3 posts · 2022–2025

Timeline

20222026
Feature trailCooling

Service Mesh Evolution (Consul to Istio)

Grab has evolved its service mesh infrastructure from a Consul-based setup with a fallback mechanism (Catcher) to Istio. This migration addresses challenges with single points of failure, limited advanced features, and multi-cluster support. The new architecture utilizes multiple, resilient Istio control planes deployed on dedicated Kubernetes clusters, supporting both HTTP and gRPC traffic across multi-cloud and multi-organization environments. The migration journey involved cross-cloud (GCP to AWS) and cross-mesh connectivity, with a focus on stability, advanced traffic management, and enhanced security policies.

2 posts · 2016–2025

Timeline

…20172026
Feature trailCooling

Reinforcement Learning Framework for Dispatch Systems

Grab has developed and researched advanced techniques for optimizing the dispatch system, which matches bookings with drivers. This includes exploring the application of Reinforcement Learning (RL) through frameworks like DispatchGym to improve matching efficiency and cost-effectiveness. Additionally, research has focused on improving the theoretical and practical aspects of the matching algorithm itself, particularly by optimizing the computation of the cost matrix in bipartite matching problems. DispatchGym provides a research framework for RL studies, integrating an RL optimization approach and a dispatch simulation using the Gymnasium API, enabling rapid exploration and iteration of RL applications. It addresses challenges in aligning reward functions with business goals and sensitivity to control levers, empowering data scientists to refine contextual bandit approaches for optimizing dispatch hyperparameters.

4 posts · 2017–2025

Timeline

20172026
Feature trailCooling

Enterprise Authentication with Dex

Grab has implemented Dex as a federated OpenID Connect provider to centralize and standardize enterprise authentication across internal applications. This initiative aims to streamline access management, enhance developer velocity, and improve user experience by integrating various Identity Providers (IdPs) through OIDC. Key features include token exchange for secure service-to-service communication and a 'kill switch' mechanism for IdP outages to ensure service continuity. The next phase involves leveraging this foundation for a unified authorization model.

1 post · 2025

Timeline

20252026
Feature trailCooling

Spark Observability Platform with StarRocks

Grab has evolved its Spark observability by migrating from the TIG stack (Telegraf, InfluxDB, Grafana) to a unified platform leveraging StarRocks. This new architecture addresses fragmented user experience, operational overhead, and data management challenges by using StarRocks as a single source for real-time and historical data, enabling direct Kafka ingestion, and providing a custom web application (Iris UI) for a unified, user-friendly interface. Superset integration is maintained for real-time analysis. This post details the adoption of structured logging to improve the observability of Grab's backend systems, focusing on the implementation of a new Golang library that supports dynamic log levels, consistent JSON structuring via the Common Grab Log Schema (CGLS), and improved log correlation and causal ordering. This initiative aims to reduce Mean Time To Resolve (MTTR) by making logs more queryable and understandable, and to manage logging costs more effectively by enabling dynamic log level adjustments and focusing structure on essential fields.

6 posts · 2019–2025

Timeline

20192026
Feature trailCooling

Passwordless Authentication with Passkeys

Grab has introduced Passkey, a passwordless authentication method leveraging the FIDO standard. This system allows users to authenticate using device biometrics or screen locks, enhancing security by being phishing-resistant and eliminating the need to store secrets on Grab's servers. The implementation involves backend and frontend components interacting with user authenticators, with detailed WebAuthn parameters for both passkey creation and sign-in flows. Supported environments include Google Password Manager and iCloud Keychain.

1 post · 2024

Timeline

20242026
Feature trailCooling

Temporal Workflow Orchestration for Membership System

GrabUnlimited has migrated its membership system from a legacy architecture to Temporal, a workflow orchestration engine. This migration addresses challenges in scalability, concurrency, resiliency, and idempotency that arose from rapid subscriber growth. The new system uses Temporal workflows to manage membership purchases and renewals, replacing SQS and Redis locks with Temporal's built-in features like infinite retries, exponential backoff, and timers. This has resulted in an 80% reduction in open production incidents and improved membership experience.

1 post · 2024

Timeline

20242026
Feature trailCooling

Messaging System Redesign

Grab's real-time data platform (Coban) has evolved its data integration capabilities by adopting Kafka Connect for seamless data movement into and out of Apache Kafka. This enables Change Data Capture (CDC) from databases like MySQL and replication to disaster recovery sites, supporting various data sources and sinks. The system leverages Debezium for MySQL/Aurora binlog processing and Lambda functions for DynamoDB stream processing, ensuring data consistency and reducing load on source databases. This post details a custom time-based switchover logic for migrating stream processing functionality to a new service with zero data loss and duplication, handling high volumes of real-time traffic.

5 posts · 2018–2024

Timeline

20182026
Feature trailCooling

Product Configuration Management SDK Optimization

GrabX's product configuration management SDK has been optimized to reduce initialization time and resource usage. This involved phasing improvements: concurrent loading of subscribed and common data, concurrent download and in-memory loading of large configurations, and eliminating the disk persistence fallback mechanism. These changes have significantly reduced initialization times, with potential for up to a 90% reduction.

2 posts · 2024

Timeline

20242026
Feature trailQuiet since 2024

Android Live Activity Implementation

Grab has successfully implemented a Live Activity-like feature for its Android application, mirroring the functionality previously available on iOS. This involved developing a workaround for the absence of a native 'Push Token' concept on Android by using custom notifications. The implementation focuses on providing real-time order updates for Food and Mart, with a design intended for extensibility to other verticals like Express and Transport. Key technical components include a LiveActivityIntegrationManager, LiveActivityAttributes, and LiveActivityManager for handling registration, payload mapping, and rendering.

1 post · 2024

Timeline

20242026
Feature trailQuiet since 2024

Marketing Campaign Impact Measurement

Grab's internal marketing campaign platform, Trident, has evolved with a powerful campaign builder UI that uses a node tree structure. This UI translates into a set of treatments for event processing, enabling complex campaign logic like counters, delays, and limits. The system stores both the node tree and treatments, along with their mapping, to handle campaign updates and executions. This post details the development of a Marketing Attribution Model (MAM) and the use of hold-out groups to evaluate the business impact of individual campaigns, including statistical significance calculations.

5 posts · 2021–2024

Timeline

20212026
Feature trailQuiet since 2024

ML Notebook Experimentation Platform

Chimera Sandbox is a scalable Notebook service platform that facilitates rapid experimentation and development of ML solutions. It offers deep integration with Grab's AI Gateway for LLM access, provides various compute instances (CPU/GPU), and integrates with internal Spark engines for data processing. The platform also includes features like real-time collaboration, an AI Gallery for guided experimentation, and cost attribution. It is built on Grab's ML compute infrastructure running on Kubernetes.

1 post · 2024

Timeline

20242026
Feature trailQuiet since 2024

In-house Translation Service

Grab has evolved its translation capabilities by developing an in-house translation service to improve quality and cost efficiency. This involved implementing on-the-fly language detection using Lingua, with a fallback to a third-party service. To enhance translation quality, a custom lightweight translation model was trained using synthetic data generated from a larger LLM, incorporating domain-specific context and a post-translation quality check to mitigate issues like number mutation. Caching was implemented to reduce costs, and system messages were optimized for translation.

1 post · 2019–2024

Timeline

20192026
Feature trailQuiet since 2024

Profile-Guided Optimization (PGO) for Go Services

Grab has adopted Profile-Guided Optimization (PGO) for its Go services to improve performance and resource utilization. This involves collecting CPU profile data from production services and feeding it back into the Go compiler during the build process. Initial experiments on services like TalariaDB have shown significant reductions in CPU usage (around 10%), memory usage (around 30%), and persistent volume usage (around 38%). The effectiveness of PGO varies across services, with some requiring more effort than the gains provided, such as in the Catwalk service. Future improvements to `go-build` and PGO support for monorepo services are expected to drive greater adoption.

2 posts · 2023–2024

Timeline

20232026
Feature trailQuiet since 2024

Feature Toggles and A/B Testing Platform

Grab's Experimentation Platform (ExP) has evolved to provide a unified, scalable, and cost-effective system for running controlled experiments across the organization. It supports various assignment strategies, prevents inter-experiment interference, and automates data pipelines for real-time analysis. The platform enables teams to test new features, analyze causal relationships, and make data-driven product decisions, significantly increasing the number of concurrent experiments and computed metrics. This post details the evolution of the batch data pipeline supporting ExP, focusing on data ingestion, transformation, and storage in the data lake to support analytical queries, time series analysis, and democratized data access.

4 posts · 2018–2024

Timeline

20182026
Feature trailQuiet since 2024

Content Moderation System

Grab has developed a comprehensive content moderation system for its marketplaces (GrabFood, GrabMart) that combines automated and manual processes. The automated component utilizes in-house machine learning algorithms to scan daily listings for policy and regulatory violations, ensuring efficiency and consistency. Manual moderation by human reviewers provides contextual understanding and judgment for complex cases flagged by the automated system. This system also includes collaboration with Google.

1 post · 2024

Timeline

20242026
Feature trailQuiet since 2023

Kafka on Kubernetes Fault Tolerance

Grab's real-time data streaming platform (Coban) has enhanced the fault tolerance and cost efficiency of its Kafka deployments. This includes enabling Kafka consumers to fetch from the closest replica to reduce cross-AZ traffic, upgrading Kafka clusters to version 3.1 with a phased rollout, and implementing rack-awareness for brokers and consumers. The platform also addresses increased end-to-end latency, graceful broker isolation during rotation, and potential load skewage across AZs by exposin

7 posts · 2020–2023

Timeline

20202026
Feature trailQuiet since 2023

Road Localization in GrabMaps

GrabMaps has evolved its map data processing by integrating hyperlocal data and leveraging big data solutions to improve map accuracy. This includes processing OpenStreetMap data, converting it to Parquet, and identifying hyperlocal attributes like road direction and speed limits. The system enhances map data with inputs from ride/delivery GPS pings and KartaView imagery, leading to improved accuracy of turn-by-turn navigation (GrabNav) through features like road localization, language, driving.

6 posts · 2020–2023

Timeline

20202026
Feature trailQuiet since 2023

Unsupervised Graph Anomaly Detection for Fraud

Grab has evolved its fraud detection capabilities by developing and implementing an in-house unsupervised machine learning model called GraphBEAN for detecting anomalous patterns in bipartite graphs. This model, which accepts node and edge attributes, can identify both node-level and edge-level anomalies without requiring labeled data. The system constructs bipartite graphs from consumer-merchant interactions in GrabFood and GrabMart, trains the GraphBEAN model, and then uses anomaly scores and network-based features to identify fraudulent syndicates. Future work includes diving deeper into graph infrastructure and database development using AWS Neptune.

6 posts · 2022–2023

Timeline

20222026
Feature trailQuiet since 2023

Ad Server Infrastructure

Grab has evolved its ad serving infrastructure to include a scalable lookalike audience platform. This platform leverages user and audience embeddings for efficient audience creation and retrieval. Key improvements include a high-performance in-memory retrieval service with passenger embedding compression, and an embedding-based audience creation pipeline using a small neural network. The system aims to reduce SLA for audience creation, improve scalability, increase updating frequency, and lower operational costs. The ad server itself is a microservice-based system that handles targeting, capping, pacing, scoring, ranking, and pricing of ads, utilizing Elasticsearch for ad targeting and ScyllaDB for storing real-time statistics like budget spent and ad impression counts. Latency, graceful fallbacks, and global optimization are key design principles. Future work includes optimizing real-time ad decisions with ML, expanding ad types, and scaling services.

1 post · 2022–2023

Timeline

20222026
Feature trailQuiet since 2023

Kubernetes CPU Allocation for Go Applications

Grab's real-time data platform team, Coban, has been optimizing the performance of Go applications running on Kubernetes. This post details the challenges encountered with CPU throttling and Vertical Pod Autoscaler (VPA) when using non-integer CPU allocations. The team discovered that the `AUTO-GOMAXPROCS` setting in Go rounds down non-integer CPU values, leading to performance degradation and consumer lag. By ensuring VPA proposes integer CPU values (especially for high-resource pipelines) and by setting a minimum integer CPU value for critical pipelines, they improved performance and resource utilization.

1 post · 2023

Timeline

20232026
Feature trailQuiet since 2023

iOS CI Infrastructure Observability

Grab has evolved its iOS CI infrastructure by integrating observability tools to diagnose and resolve issues like unstable tests and high CPU utilization. This involved analyzing Xcode performance, optimizing deep link testing by mocking dependencies, improving simulator boot permissions, monitoring HTTP traffic, analyzing GitLab load runner performance, returning HTTP responses to a local mock server, using explicit waiting commands instead of sleep, and tracking failure states to improve test stability and reliability.

3 posts · 2017–2023

Timeline

20172026
Feature trailQuiet since 2023

Shift-Left Testing Adoption

Grab has evolved its software development lifecycle by adopting a comprehensive shift-left testing strategy. This involves software engineers conducting acceptance testing using Given/When/Then criteria, incorporating Definition of Ready (DoR) and Definition of Done (DoD) for improved quality standards, and implementing a balanced testing strategy that includes unit, UI component, backend integration, and end-to-end (E2E) testing. This has led to a significant reduction in production issues and bugs found during development.

1 post · 2023

Timeline

20232026
Feature trailQuiet since 2023

Technology Stack Standardization

OVO has standardized its web development technology stack to Vue.js to improve maintainability, reduce complexity for new hires, and accelerate delivery times. This involved a detailed comparison of React and Vue, focusing on scalability, stability, and market usage, ultimately selecting Vue for its alignment with operability, simplicity, and evolvability principles. The implementation includes defining project boilerplates, updating UI libraries, and maintaining existing React services with sta

1 post · 2023

Timeline

20232026
Feature trailQuiet since 2023

Attribute-Based Access Control (ABAC) for Kafka Control Plane

Grab has migrated its Kafka Control Plane (KCP) from Role-Based Access Control (RBAC) to Attribute-Based Access Control (ABAC) to simplify access management, reduce operational overhead, and improve scalability. This involved implementing user and resource attributes, an evaluation engine using Open Policy Agent (OPA) with Rego policies, and integrating with the IAM service and HRMS. The transition has led to optimized resource allocation, simplified management of new resources, reduced delays for access requests, and better governance over resource ownership and costs.

1 post · 2023

Timeline

20232026
Feature trailQuiet since 2023

Geohash Plugin Zoom Freeze

Grab's Geohash JOSM plugin has been enhanced with a 'zoom freeze' feature, allowing users to toggle the display of new geohashes during zoom-in/zoom-out operations. This improves map readability and user experience by preventing unnecessary geohash updates. The feature also disables options for explicitly displaying larger or smaller geohashes when zoom freeze is active.

1 post · 2023

Timeline

20232026
Feature trailQuiet since 2022

Driver Telematics and Safety Analysis

Grab has developed an in-house telematics engine that uses mobile phone sensors (accelerometer, gyroscope, GPS) to collect and analyze driver-partner driving behavior. This system detects events like harsh braking, acceleration, cornering, and unsafe lane changes to improve passenger safety and inform insurance premium calculations. The architecture includes on-device processing for crash detection and backend processing for generating safety reports after each ride. Key technical challenges addressed include sensor data time synchronization, hardware axis bias, sensor noise, and data compression for network efficiency. The system aims to extend telematics to all bookings across Grab verticals and add more on-device rules for event detection.

1 post · 2022

Timeline

20222026
Feature trailQuiet since 2022

Rule Backtesting System

Grab has evolved its fraud detection capabilities by developing Griffin, an in-house anti-fraud risk rule engine. This system allows data scientists and analysts to create, manage, and deploy complex rules through a web portal, moving away from manual rule implementation in code. Griffin handles data orchestration for predictions and executes rules efficiently, making billions of predictions daily with low latency. It supports dynamic datasets, complex logic with Python-based rule execution, and a cloud-agnostic Spark-based data pipeline for backtesting. The system also includes a web portal for managing jobs and downloading results, and integrates with Kafka for historical event storage.

1 post · 2022

Timeline

20222026
Feature trailQuiet since 2022

Fare Storage and Event Sourcing

Grab's Order Platform has evolved its database solution to handle millions of orders daily by separating transactional (OLTP) and analytical (OLAP) workloads. DynamoDB is used for OLTP with a focus on stability, scalability, and cost-effectiveness, employing strategies like Global Secondary Indexes (GSIs) with sparse indexing for ongoing orders and Time To Live (TTL) for data retention. MySQL RDS serves as the OLAP database for historical and statistical queries, utilizing partitioning for data. The Fare Storage system has been refactored to use Event Sourcing and CQRS patterns, with DynamoDB as the event store and a cache for reads. Optimistic locking and transaction IDs are used to ensure data integrity and idempotency. A schema-less metadata approach via an SDK decouples clients from the storage service.

1 post · 2020–2022

Timeline

20202026
Feature trailQuiet since 2022

Internal Knowledge Management Automation

Grab has evolved its internal knowledge management by implementing an AI-driven system to automate FAQ responses on Slack. This system leverages vendor solutions, starting with a proof of concept and vendor selection based on user voting and technical requirements. The initial rollout focused on prioritizing active Slack channels and educating employees on its usage. The system also includes a feature for crowdsourcing and managing internal glossaries and acronyms, significantly expanding its knowledge base.

1 post · 2022

Timeline

20222026
Feature trailQuiet since 2022

Points Issuance Platform (Abacus)

Grab's Abacus platform has evolved to manage points issuance for GrabRewards and OVOPoints, supporting a growing number of products and external partnerships. It handles complex point calculation logic with various multipliers (vertical, EPPF, payment type, tier) and ensures robust, fault-tolerant processing through SQS queues and an idempotent ledger. The system also incorporates activity-based points expiry and integrates with downstream services via Kafka for behavioral analysis.

1 post · 2022

Timeline

20222026
Feature trailQuiet since 2022

Biometric Authentication System

Grab has enhanced its identity and access management by implementing biometric authentication, leveraging device-specific secure enclaves and public/private key pairs. This system aims to strengthen security against social engineering and reduce costs associated with SMS OTPs. The implementation involves client-server trust establishment, secure key management within device enclaves, and a robust enrollment flow. Future plans include SDK integration and broader adoption across teams.

1 post · 2022

Timeline

20222026
Feature trailQuiet since 2021

Frontend Asset Optimization

GrabFood.com has implemented a series of optimizations to significantly reduce JavaScript asset sizes, leading to faster page load times, reduced data costs for users and the company, faster build times, and lower cloud infrastructure expenses. These optimizations include dependency analysis, lazy loading, unifying duplicate modules, leveraging ES Modules for tree-shaking, replacing libraries with browser Web APIs, and avoiding Node.js dependencies.

1 post · 2021

Timeline

20212026
Feature trailQuiet since 2021

ETL Pipeline Orchestration with Ratchet

Grab's Lending team utilizes the Go library Ratchet for building custom data pipelines and handling ETL tasks. This system orchestrates batch processing, restructuring and rescheduling of loans, and creating user profiles. The Ratchet library, written in Go, allows for concurrent processing of data through Data Processors organized into stages within a pipeline. The Azkaban service manages these pipelines, with Job Processors defining the Extract, Transform, and Load stages. A specific use case involves whitelisting merchants by processing CSV files uploaded via an internal portal, extracting data from S3, transforming it through validation and API calls, and skipping the load step as transformed data is not stored.

1 post · 2021

Timeline

20212026
Feature trailQuiet since 2021

App Modularization

Grab has adopted a comprehensive app modularization strategy to break down its monolithic Android application into smaller, independent, and interchangeable modules. This approach aims to improve code maintainability, reduce code conflicts, accelerate development cycles, and enhance collaboration among development teams. The strategy involves creating base/core modules (Networking, Analytics, etc.), shared library modules (Styling, Common-UI), feature modules (Payments, Wallet), and kit modules to enable inter-module communication. This has led to significant improvements in build times and developer experience, with over 1,000 modules in the Grab app.

1 post · 2021

Timeline

20212026
Feature trailQuiet since 2021

Customer Support Workforce Routing

Grab has evolved its customer support operations by building an in-house workforce routing system. This system addresses limitations of third-party solutions by enabling granular priority management for requests, allowing for bespoke product customization to handle specific use cases like bulk configuration changes and dynamic queue limits, and providing enhanced reporting and analytics for agent productivity and performance. The solution uses separate queues for different priority levels and em

1 post · 2021

Timeline

20212026
Feature trailQuiet since 2021

Context Management and Memory Leak Debugging

Grab has evolved its approach to managing context and deadlines in its microservice architecture to improve resilience and prevent cascading failures. This includes a deep dive into Go's context package, emphasizing the correct configuration of timeouts and deadlines to avoid resource leaks and ensure efficient operation. The post details strategies for setting appropriate timeout values based on SLAs and latency data, and explains how context propagation allows servers to cancel work when deadl

2 posts · 2019–2021

Timeline

20192026
Feature trailQuiet since 2021

Fraud Risk Rule Engine

Grab's fraud detection and prevention capabilities are enhanced by Griffin, an in-house anti-fraud risk rule engine. Archivist, a new distributed tracing, statistics, and feedback system, complements Griffin by providing a centralized, performant, and flexible platform for logging, storing, and querying ML/rule-based prediction events. Archivist supports user-defined entities and custom fields, a shared dedicated service for event processing, and a user portal for querying, prediction stats, and

1 post · 2019–2021

Timeline

20192026
Feature trailQuiet since 2021

Continuous Delivery Automation

Grab has evolved its continuous delivery process with the development of Conveyor, an in-house solution built on Spinnaker. This evolution focuses on achieving deployment hermeticity, ensuring that deployments are reproducible and consistent regardless of the environment or execution count. Conveyor integrates application code, static configuration, and dynamic configuration as versioned artifacts, enabling hermetic deployments that improve confidence in production changes and simplify rollbacks. The system supports a tailored user interface and a pipeline-as-code DSL for easier adoption and extensibility.

2 posts · 2020–2021

Timeline

20202026
Feature trailQuiet since 2021

Performance Marketing Automation

Grab's performance marketing capabilities have evolved with CARA, an in-house automation tool for managing and refreshing ad creatives at scale. This system addresses challenges of complex ad account structures and the need for hyperlocal strategies, automating the identification and replacement of underperforming ad assets to improve clickthrough and conversion rates.

1 post · 2021

Timeline

20212026
Feature trailQuiet since 2020

Redis Data Consistency and Replication

Grab has evolved its Redis data consistency and replication strategies by addressing issues where pipeline calls could crash Redis clusters. This involved analyzing the Go-Redis client's behavior during node unreachability, specifically how it maps commands to nodes and the delay in state updates. The team identified that a single command failure within a pipeline could cause the entire pipeline to fail, and that the client's one-minute state refresh interval led to prolonged unavailability when nodes were patched for security vulnerabilities like Meltdown. To mitigate performance impacts, Grab added additional shards to clustered Redis instances and provisioned more nodes or switched to Redis Cluster for non-clustered instances. For systems requiring significant code changes, service teams implemented data sharding across multiple nodes. These mitigations were performed over 24 hours to ensure no consumer-facing impact during peak traffic.

3 posts · 2018–2020

Timeline

20182026
Feature trailQuiet since 2020

Data Access Gateway for Presto

Grab's DataGateway has evolved to manage user access and cluster selections for its Presto ecosystem, providing a single endpoint for interactive querying and ETL jobs. It enforces schema, table, and field-level access control, seamlessly handles cluster scaling and migrations across multi-cloud environments (AWS and Azure), and captures audit trails of user activities. The system is deployed on Kubernetes for high availability and scalability, and includes an administration UI for managing clusters and user access.

1 post · 2020

Timeline

20202026
Feature trailQuiet since 2020

Go Modules in Monorepo

Grab has evolved its approach to managing Go modules within a monorepo, addressing challenges with vendoring, private repository access, inconsistent Go versions, and implementing an automated dependency upgrade system (AutoVend Bot). This has improved build integrity, developer productivity, and security by ensuring dependencies are up-to-date. This post details the initial challenges and solutions for adopting Go modules in a multi-module monorepo, focusing on the transition from the 'vendor' folder to Go modules, handling incompatible dependencies with 'replace' directives and empty 'go.mod' files, and addressing maintenance issues like dependency inheritance and implicit updates. The use of 'go mod graph' for dependency analysis is also highlighted.

2 posts · 2020

Timeline

20202026
Feature trailQuiet since 2020

Web Chat Platform

Grab has developed an in-house chat platform for web, enabling real-time communication between passengers and drivers during bookings, and for customer support. This involved a hybrid approach using JavaScript SharedWorker and BroadcastChannel APIs to manage multiple browser tabs and maintain a single TCP connection to the backend, overcoming the limitations of the existing unicast TCP gateway. The initial implementation focused on a simple TCP server and evolved to a service-oriented architecture utilizing Grab's infrastructure, with a client-side message handling protocol to mitigate server resource consumption and ensure message delivery reliability.

2 posts · 2017–2020

Timeline

20172026
Feature trailQuiet since 2019

End-to-End User Scenario Simulation Platform

Grab has developed Marionette, an internal platform for simulating end-to-end user scenarios in the transport domain. It allows developers and QAs to create and run simulations without depending on actual passenger and driver apps, by simulating user actions, setting up test data, and managing cohorts for isolated testing. Interactions can be done via UI, SDK (Go), or RESTful APIs, enabling comprehensive testing of booking flows, driver/passenger behaviors, and various cities/taxi types.

1 post · 2019

Timeline

20192026
Feature trailQuiet since 2019

Domain-Driven Design Implementation

Grab has adopted Domain-Driven Design (DDD) principles to refactor its codebase for the GrabPlatform's partner integration website. This involved gathering domain knowledge from product teams, breaking down the domain into bounded contexts (e.g., Project, Product, Developer), identifying entities and value objects, creating repository interfaces for data access, and implementing domain events for inter-context communication. This approach aims to improve code structure, maintainability, and developer experience.

1 post · 2019

Timeline

20192026
Feature trailQuiet since 2019

Principal Engineer Role and Responsibilities

Grab has defined the role and responsibilities of a Principal Engineer, emphasizing technical leadership, system architecture, problem-solving, and mentorship. This role focuses on improving system quality, driving migrations, and fostering technical excellence across large engineering organizations (Tech Families). Principal Engineers are expected to set standards for engineering excellence, manage complex systems, translate vague problems into actionable items, and drive consensus. They also play a key role in technical ownership, identifying system gaps, prioritizing effectively, and understanding business impact. Communication, writing, public speaking, and driving meetings are critical skills, alongside mentoring and continuous learning.

1 post · 2019

Timeline

20192026
Feature trailQuiet since 2019

Automated Toll Fare Calculation

Grab has evolved its fare calculation system to automatically incorporate Electronic Road Pricing (ERP) charges and other tolls across various countries. This involves collecting precise geographical coordinates of toll gantries, understanding country-specific tolling rules (e.g., different rates for vehicle types, couple gantries), and implementing a dynamic fare calculation mechanism. A feedback loop with driver-partners and an ERP Workflow tool are in place to ensure data accuracy and handle ad-hoc changes.

1 post · 2019

Timeline

20192026
Feature trailQuiet since 2019

React Native Adoption for Mobile Apps

Grab has adopted React Native for developing cross-platform mobile application components, starting with the GrabPay Merchant App and extending to modules within the Grab Passenger app (Express, Transaction History, Postpaid BillPay). This initiative aims to achieve code reusability across Android and iOS, minimize maintenance effort, match native performance standards, and optimize engineering resource utilization. Key technical aspects include developing bridging libraries for communication between native and React Native modules, standardizing component libraries, and managing API calls and localization through bridges. The team is also moving towards TypeScript and 100% unit test coverage.

1 post · 2019

Timeline

20192026
Feature trailQuiet since 2019

Restaurant Location Accuracy Improvement

Grab has evolved its restaurant location accuracy by leveraging driver-partner GPS data and timestamps to infer pickup locations. This involves filtering GPS data based on quality metrics, defining 'at the restaurant' based on time spent within a radius and longest streak analysis, and ranking restaurants for manual verification based on order volume, pickup location deviation, and distance. This system has led to a reduction in median error distance and a 5x decrease in cancellations due to incorrect restaurant locations.

2 posts · 2019

Timeline

20192026
Feature trailQuiet since 2019

Dynamic Mock Server for Mobile App Testing

Grab has developed Loki, a dynamic mock server for local box testing of mobile apps. Loki simulates backend services over HTTP and TCP protocols, allowing developers to test complex use cases without external dependencies. It supports runtime response generation via JavaScript injection, sequential responses for API endpoints, and configurable message delimiters for TCP. Loki can run in Docker containers locally or in CI, with pluggable storage options (MySQL, in-memory cache, Redis) to manage mock expectations.

2 posts · 2018–2019

Timeline

20182026
Feature trailQuiet since 2019

System Resiliency Patterns and Chaos Engineering

Grab has evolved its system resiliency by implementing chaos engineering practices. This involves intentionally introducing failures into services and components to test the resilience of dependent systems. The Experimentation Platform (ExP) is leveraged to orchestrate application-level chaos, injecting failures like latencies and memory leaks. A dedicated SDK and UI have been developed to simplify the creation and execution of chaos experiments, allowing engineers to define ideal system behavior.

2 posts · 2018–2019

Timeline

20182026
Feature trailQuiet since 2019

Demand Forecasting and Peak Shifting

Grab has developed a 'Travel Trends Widget' that leverages historical supply and demand data and machine learning to forecast pricing trends for the next two hours. This aims to help passengers plan their trips to avoid peak demand periods, thereby 'peak-shifting' demand. The widget displays aggregated historical surge data in an interpretable visual format, providing tips and information to encourage users to adjust their travel times. The development process was agile and collaborative, involving the Analytics team and product managers.

1 post · 2019

Timeline

20192026
Feature trailQuiet since 2018

Mock Server Framework for Local Testing

Grab has developed and adopted Mockers, a Go SDK and CLI tool, to enable comprehensive local box testing of microservices. This framework simulates microservice dependencies via mock servers, allowing for functional, resiliency, and contract testing earlier in the development lifecycle. Mockers supports HTTP and gRPC services, automatically generates mock servers from API specifications, and integrates with a chaos SDK for resiliency testing. This has led to earlier bug detection, reduced testing costs, and improved developer productivity.

1 post · 2018

Timeline

20182026
Feature trailQuiet since 2018

Microservice Framework (Grab-Kit)

Grab has developed Grab-Kit, a Go microservice framework designed to standardize and accelerate the creation and operation of distributed services. It provides scaffolding, default library configurations, automatic initialization, context propagation, and runtime framework configuration to abstract away distributed system design complexities. Grab-Kit generates service definitions from proto files, enforces a consistent middleware stack for logging, circuit breaking, and stats, and automates dashboard generation. This has led to significant increases in productivity and improvements in the stability and availability of services.

1 post · 2018

Timeline

20182026
Feature trailQuiet since 2018

Database Timeout Handling

Grab has evolved its understanding and debugging of database connection timeouts in Rails applications. This post details the investigation into production outages caused by database failovers and the subsequent analysis of ActiveRecord connection pooling, checkout_timeout, connect_timeout, and read_timeout configurations. Experiments were conducted using Toxiproxy to simulate network issues and understand how these timeouts affect application behavior and thread availability. The findings highlight the importance of correctly configuring these timeouts to prevent application slowdowns and ensure resilience during database disruptions.

1 post · 2018

Timeline

20182026
Feature trailQuiet since 2017

Cache Sharding and Scaling

Grab's Common Data Service (CDS) has evolved its caching strategy to horizontally scale its Redis-based cache system. This involved implementing a custom sharding mechanism to distribute cache keys across multiple ElasticCache instances, addressing the limitations of single-threaded Redis and the potential bottleneck of a centralized proxy like Twemproxy. The new design allows for increased caching capacity and improved P99 latency under heavy load. This post details an investigation into Redis key expiration consistency issues on read replicas, revealing that slaves do not expire keys unless explicitly told by the master, and that passive expiration is too slow at scale. The findings led to recommendations to upgrade Redis versions more frequently and pay closer attention to cache invalidation strategies during software design.

2 posts · 2017

Timeline

20172026
Feature trailQuiet since 2017

Frontend Development Study Guide

Grab has developed a comprehensive study guide for its web team to navigate the complexities of modern front-end development. This guide introduces concepts like Single-Page Applications (SPAs), modern JavaScript (ECMAScript 2015+), component-based UI development with React, state management with Flux/Redux, CSS-in-JS, testing frameworks (Jest/Enzyme), linting (ESLint/Stylelint), static typing with Flow, build systems (Webpack), and package management (Yarn). It aims to onboard new engineers and backend developers quickly by explaining Grab's chosen technologies and providing learning resources.

1 post · 2017

Timeline

20172026
Feature trailQuiet since 2017

DNS Resolution Behavior

This post investigates and explains the differences in DNS resolution behavior between Go's native resolver, Cgo, and C, particularly concerning RFC 6724 (3484) and IPv6. It details how disabling IPv6 affects IP address sorting and identifies that Go's native resolver implements only a partial subset of RFC 6724 rules, lacking source address selection, which leads to different outcomes compared to Cgo/C resolvers.

1 post · 2017

Timeline

20172026
Feature trailQuiet since 2017

ELB Health Check Monitoring and Debugging

Grab has evolved its understanding and debugging of Elastic Load Balancer (ELB) health check behavior. This post details an investigation into unexpected increases in health check metrics, which were initially mistaken for new instance scaling. The root cause was identified as the coexistence of old and new ELB nodes during scaling events, leading to a doubling of health checks. This led to a refinement in monitoring practices, separating dependency health checks from ELB health checks and emphasizing the importance of understanding the nuances of ELB behavior during scaling events.

2 posts · 2015–2017

Timeline

…20172026
Feature trailQuiet since 2016

API and SDK User Experience

Grab is evolving its approach to API and SDK design by emphasizing User Experience (UX) for both human programmers and other systems. This involves applying UX principles to the design of interfaces, considering factors like usability, efficiency, and developer productivity. The goal is to create more intuitive, robust, and maintainable APIs and SDKs that reduce complexity and improve the overall developer workflow.

1 post · 2016

Timeline

…20172026