Loading…
Grab
Southeast Asia's leading everyday "super-app" that provides ride-hailing, food delivery, grocery shopping, and digital financial services.
- 243 posts summarised
- latest
The Good Stuff
Paid picks we use ourselves. Links carry a referral code — a subscription through one earns us a commission at no extra cost to you.
From their blog
Latest articles
From firefighting to building: How AI agents restored our team’s core productivity
Grab’s Analytics Data Warehouse team supports more than 1,000 monthly users and 15,000 tables, but repetitive questions about definitions, lineage, quality, and basic enhancements consumed about 40% of engineering time. It deployed a multi-agent AI system that routes Slack requests into enhancement or investigation pathways, using FastAPI and LangGraph for stateful, cyclical collaboration, Redis for caching and sessions, and PostgreSQL for persistent memory. Specialized agents query Trino, Hive, or Delta Lake, inspect GitLab code, check incidents and pipeline health, or prepare semi-automated code changes, while human reviewers approve production modifications. The system autonomously resolves most standard inquiries and some common enhancements, reducing resolution time by an order of magnitude and bringing simple answers to users within minutes. The resulting capacity shift reclaimed several FTEs worth of engineering bandwidth and moved hundreds of hours from reactive support to roadmap work.
Enabling R8 optimization at scale with AI-assisted debugging
Grab enabled R8 optimization for its Android app after repeated attempts were blocked by debugging difficulty, organization-wide testing demands, and slow build feedback. The effort targeted a roughly 10-year-old codebase exceeding 9 million lines and combined AI-assisted debugging, a pragmatic testing strategy, and infrastructure investment. Its QA build was configured to match production R8 processing. Beyond existing shrinking, optimization added techniques such as method inlining, class merging, constant folding, dead-code elimination, and devirtualization. After about 10 weeks with one engineer coordinating across teams, the project reported around 25% lower ANR rates, a 16% reduction in reference-device download size, and nearly 27% faster startup; the startup result combined R8 with corrected Baseline and Startup Profiles.
Reclaiming Terabytes: Optimizing Android image caching with TLRU
Grab’s Android app cached runtime images with DiskLruCache, but its 100 MB size limit did not remove stale content while the cache remained below capacity, contributing substantially to device storage usage. The team developed Time-Aware Least Recently Used (TLRU), which combines LRU size eviction with time-based expiration using last_accessed metadata and a TTL, while a minimum cache-size threshold protects a baseline of cached images. TLRU retains the 100 MB maximum and evicts entries when current_time minus last_accessed exceeds the TTL; the implementation also supports reading existing LRU journal files by ignoring timestamp suffixes, enabling safe rollback. Configuration was tuned through experiments using cache hit ratio, with a maximum acceptable decline of three percentage points. After production rollout, P95 total app size fell approximately 50 MB, while hit ratio stayed within target and infrastructure costs did not increase.
Cursor at Grab: Adoption and impact
Grab introduced Cursor in late 2024 as one of several AI coding assistants and reports rapid adoption across engineering and non-technical teams. Monthly active usage reached 98% of Tech Grabbers, weekly usage about 75%, and Cursor suggestions were accepted around 50% of the time, compared with a cited industry average of 30%. About half of users engage on at least 10 consecutive days monthly, while more than a third of merge requests incorporate Cursor; common uses include test generation, refactoring, code navigation, bug fixing, and routine automation. Grab built monorepo indexing and distributed preconfigured rules for environment-specific suggestions, while a fixed-effects regression effort is examining productivity; early findings report a statistically robust dose-response relationship, with gains increasing alongside usage intensity.
Docker lazy loading at Grab: Accelerating container startup times
Large Docker images for Airflow and Spark Connect caused minute-scale downloads, delaying cold starts and weakening autoscaling responsiveness. The post describes testing eStargz and Seekable OCI (SOCI) with containerd remote snapshotters, which expose registry-backed layers through a virtual lowerdir and fetch file content on demand. In production, SOCI delivered 30–40% faster startup times for Airflow and Spark Connect, while benchmark results showed SOCI matching standard images’ 5.0-second Airflow application startup; eStargz took 25.0 seconds. Configuration tuning increased download concurrency, unpack concurrency, and chunk size, reducing fresh-node image download time from 60 seconds to 24, a 60% improvement. Grab chose SOCI because Bottlerocket supports it natively, while noting that lazy loading redistributes rather than removes download work and requires workload-specific tuning.
From deployment slop to production reality: How BriX bridges the gap with enterprise-grade AI infrastructure
BriX addresses “deployment slop,” the gap between quickly built AI prototypes and enterprise production, where inconsistent versions, reliability failures, and security risks can block adoption. The platform centralizes production infrastructure so semi-technical domain experts can configure deployments rather than become DevOps specialists, covering scaling, monitoring, audit trails, access controls, data connections, and consistent behavior. BriX supports switching among models such as Claude, GPT, and Gemini; its Model Context Protocols (MCPs) provide standardized, pre-built connectors to approved enterprise data sources with built-in access controls and query logging. Centralized system prompts and context files enforce shared guardrails, while custom frontends and persistent, shareable reports extend use beyond chat interfaces. The stated result is a platform intended to turn deployment into a configuration task, helping teams move from prototypes to enterprise-grade tools in days rather than months.
Demystifying user journeys: Revolutionizing troubleshooting with auto tracking
Troubleshooting critical issues in the Grab app was hindered by incomplete user-journey data, because manually instrumenting hundreds of UI components left interaction gaps and delayed diagnosis. AutoTrack is a new SDK that records application state, user interactions, and UI screens in real time, creating an end-to-end session chronicle from launch through navigation. It tracks lifecycle transitions and launch mechanisms such as deeplinks and push notifications, while UIViewController, Activity, and Fragment lifecycle events identify the displayed screen. Screen metadata includes the full hierarchy as JSON; after personal information is redacted for GDPR/PDPA compliance, that data is used to train an AI model that generates an HTML representation of the screen and interactions. AutoTrack supports reproducing elusive bugs, automated issue assignment, UI test generation, and analytics-trigger validation, with future work adding network and performance signals, privacy guardrails, and automated triage.
How Grab is accelerating growth with real-time personalization using Customer Data Platform scenarios
Grab’s Customer Data Platform (CDP) introduced Scenarios to address the limits of daily batch attributes for real-time personalization across marketing and user journeys. The capability combines Scribe event triggers, geo-fencing, optional historical CDP data, and predictive models, with a self-serve GUI for configuring and validating event sequences and APIs for programmatic management. Incoming events are processed through Flink, with historical data evaluated in StarRocks and outputs written to Kafka, Amphawa, or both for downstream consumption; configured Scenarios become available within an hour and are designed for latency under 15 seconds. More than 12 implementations are live, including a Grab Unlimited abandonment intervention that notified users 15 minutes after signup drop-off and produced over a 3% uplift in subscriber conversions versus non-real-time acquisition campaigns. Planned work includes scalable Scenario sharding, multiple output destinations, and delayed triggering.
A Decade of Defense: Celebrating Grab's 10th Year Bug Bounty Program
Grab marks the tenth anniversary of its bug bounty program, launched with HackerOne and initially involving 23 researchers. Over the decade, it grew into a global community, partnering with more than 850 active HackerOne researchers to help protect over 187 million users across Southeast Asia. The program broadened its scope in 2023–2024, adding assets that included Indonesian financial services and AI systems, while introducing a mobile-specific bounty table and experimenting with campaigns and reward methods. Grab says it now ranks among HackerOne’s top 20 programs worldwide and top three in Asia, and credits live hacking events and regional club campaigns with expanding testing coverage and researcher relationships. Anniversary activities included invite-only campaigns in Germany, Morocco, and India, plus a broader campaign that received 461 submissions, with xchopath receiving the Best Hacker Bonus.
Real-time data quality monitoring: Kafka stream contracts with syntactic and semantic test
Kafka stream data can fail syntactically when actual records do not match expected schemas, or semantically when fields violate agreed patterns, ranges, or constants. The described platform addresses this gap with user-defined data contracts covering schema agreements, field-level semantic rules, stream configuration, and ownership metadata. An LLM recommends semantic rules from schemas and anonymized samples, while a transformation engine converts them into Test Runner configurations and inverse SQL queries. A long-running FlinkSQL Test Runner reads Kafka with its own consumer group, publishes issue events and stores them in AWS S3; Genchi sends Slack alerts and Coban shows violating fields and sample records. Deployed across 100+ critical topics, the solution provides real-time detection, alerting, and visibility, with future work targeting producer tracing, cross-field tests, completeness, freshness, and DTO change detection.
SpellVault’s evolution: Beyond LLM apps, towards the agentic future
SpellVault began as Grab’s no-code platform for building LLM apps, using Retrieval-Augmented Generation (RAG) and plugins to connect applications with knowledge sources and external systems. Users could ground responses in Wikis, Google Docs, text, and PDFs, invoke custom HTTP endpoints, and access apps through the web, Slack, or APIs. The platform later added citations, Python execution for mathematical problems, scheduled actions, and drag-and-drop Workflows combining LLM calls, code, and Knowledge Vault lookups, while its executor moved toward graphs with nodes, edges, and states. SpellVault now exposes apps and RAG through MCP, allowing external agents and compatible clients to invoke apps and search, retrieve, or add Knowledge Vault information; TinyMCP adds MCP capabilities to FastAPI as a router.
Grab's Mac Cloud Exit supercharges macOS CI/CD
Grab moved its macOS CI/CD infrastructure from a US cloud vendor to a colocation cluster in Malaysia, closer to its Git servers in Southeast Asia. The change followed growth from one office Mac Pro to more than 250 Mac minis, rising demand, job queues, and cloud costs that made ownership or colocation more attractive at scale. Grab selected bare-metal hardware after comparing cloud, colocation, and on-premises options, then migrated progressively while monitoring failure rates, performance, and reliability; the later infrastructure also uses zero-touch provisioning to reduce manual setup as the cluster grows. The migration produced projected savings of more than $2.4 million over three years and performance improvements of 20–40%, while the team chose allocated-kilowatt power commitments and retained bare metal because macOS virtualization’s performance or stability trade-offs did not justify it.
How we built a custom vision LLM to improve document processing at Grab
Grab developed a specialized Vision LLM for extracting text and key information from Southeast Asian identity cards, driver’s licenses, and registration certificates, where varied languages and layouts challenged traditional OCR and existing models. It selected Qwen2-VL 2B for its efficient size, SEA language tokenizer coverage, and dynamic native-resolution image handling, while synthetic Common Crawl text images and Documint supplied reviewed training labels for detection, orientation, OCR, and KIE. LoRA fine-tuning improved Latin-script documents but struggled with Thai, Vietnamese, and dense unstructured layouts, leading to two-stage full-parameter training with synthetic SEA text images followed by task-specific document fine-tuning. The fully fine-tuned 2B model raised Thai accuracy by 70 percentage points and Vietnamese accuracy by 40 points over baseline, while a custom roughly 1B-parameter model combining Qwen2-VL 2B’s vision encoder with Qwen2.5 0.5B’s decoder stayed within a 3-point accuracy gap across most document types and achieved lower latency.
Machine-learning predictive autoscaling for Flink
Grab’s Flink platform saw application count grow 2.5 times, making cost-effective, self-service CPU provisioning difficult for users who often relied on trial and error and over-provisioned resources. Reactive autoscaling with Adaptive Scheduler, Kubernetes HPA, and metrics such as CPU usage or consumer latency caused restart spikes, scaling spirals, fluctuations, and additional constraints when connectors such as Kafka reached fixed partition parallelism. Predictive Resource Advisor instead uses vertical scaling and predictive, deterministic CPU decisions, automatically collecting data, training models, and applying configuration changes. The source says applications using it experienced fewer autoscaling-related disruptions, adapted to workload growth and surges, and averaged more than 35% cloud infrastructure cost savings. It also reports simpler default-configuration deployment, while planned work includes memory tuning, improved burst handling, and more efficient model training.
Modernising Grab’s model serving platform with NVIDIA Triton Inference Server
Catwalk, Grab’s machine learning model serving platform, accumulated technical debt by maintaining separate inference engines for ONNX, PyTorch, TensorFlow, and vLLM, contributing to higher latency, lower throughput, and rising costs. The team evaluated NVIDIA Triton Inference Server and began consolidating those engines around it, initially adopting ONNX. The Triton manager combines a server manager, which retrieves and verifies models, prepares configurations, launches Triton, and monitors health, with a proxy that translates legacy API requests without requiring client code changes. Benchmarks showed at least five times the traffic capacity for a transformer model; rollout reached over 50% of online deployments in 10 days, while some larger models saw p90 latency fall from 120 ms to 20 ms.
Highly concurrent in-memory counter in GoLang
An overloaded database faced heavy traffic from campaign usage tracking, motivating an in-memory counter rather than an immediate SQL-to-NoSQL migration. Because exact counts were not required, increments could be cached in the application server and flushed periodically to reduce database queries and CPU use. The implementation uses Go’s Sync.Map, with LoadOrStore and CompareAndSwap for concurrent increments, plus LoadAndDelete to atomically remove values for asynchronous persistence; the source notes a fresh-map swap as an alternative locking optimization. On an Apple M4 Pro, the 2,000-key benchmark reported 53 ns/op and 1 billion operations per 60 seconds, versus 160 ns/op and 466 million operations for a Mutex-protected map, but Sync.Map used 88 B/op and four allocations. In production, update queries fell from 140 QPS to 45 QPS, master CPU from 35% to 18%, and replica CPU from 19% to 12%.
User foundation models for Grab
Grab describes a foundation model that learns from both tabular data and sequential clickstream interactions to represent users, merchants, and drivers across its superapp. Traditional recommender systems depended on manually engineered, task-specific features, which required substantial effort and did not capture evolving behavior holistically. The custom architecture addresses heterogeneous modalities including text, numerical values, IDs, images, and location data, combining long-term profiles with immediate intent. Grab pre-trains the model on a diverse corpus, then either extracts embeddings for downstream recommendation and prediction tasks or fine-tunes it to predict directly. The resulting reusable representations are reported to support applications such as ad optimisation, dual app prediction, fraud detection, and churn probability, while future work targets unified data, improved architecture, and greater training and inference efficiency.
Powering Partner Gateway metrics with Apache Pinot
Partner Gateway needed low-latency analytics for API traffic and response-time metrics across intervals from one hour to 30-day retrospectives, with a particular dataset potentially reaching approximately 6.8 billion rows in a 30-day period. Apache Pinot was selected as a distributed real-time OLAP datastore, using high-throughput ingestion and columnar, indexed, partitioned data for millisecond analytical queries. Initial aggregation queries on datasets over 150GB timed out for 20- to 30-day periods, exceeding 10 seconds and threatening a 300-millisecond SLA. The implementation routes metrics through Kafka and Apache Flink, then ingests Schema Registry-compatible messages into Pinot, while partitioning by metric name and adding aggregation-focused optimizations. For one metric, query latency fell from 5,072 to 35 milliseconds; Star-tree indexing improved speed but raised 30-day storage from 192GB to 373GB, with the additional AWS EBS cost described as minor.
Taming the monorepo beast: Our journey to a leaner, faster GitLab repo
Grab’s decade-old Go monorepo grew to 12.7 million commits, 73GB of Git-tree metadata, 176GB of blobs, 12 million references, and 444,000 files, causing replication lag, slow developer workflows, and GitLab operational bottlenecks. A staging proof of concept compared full and single-commit histories under production-like load: replication delay fell from 160–240 seconds to 1–2.5 seconds, nearly a 100x improvement. Because custom migration tooling processed about 100 commits per hour, the team retained commits reachable from more than 2,000 critical tags, one month of recent history, and simplified merge commits, while archiving older history. The resulting prune reduced commits by 99.9%, improved replication performance by 99%, preserved code and tags without data loss, and left teams with minor migration adjustments.
Data mesh at Grab part I: Building trust through certification
Grab began its Signals Marketplace data mesh journey in 2024 because its expanding, varied data ecosystem had ownership gaps, duplicated pipelines, central Data Engineering bottlenecks, broken downstream dependencies, inconsistent definitions, and uneven practitioner expertise. The decentralised model treats data as a product owned by domain teams, with Business Data Owners and Technical Data Owners accountable for upkeep, documentation, usability, and SLOs. Certification formalises expectations through data contracts covering schema, freshness, completeness, retention, change notice, and communication, while automated Data Production Incidents flag breached reliability guarantees for investigation. Using the percentage of queries hitting certified assets as its north star metric, Grab reports 75% of queries targeting certified assets, a 400% year-over-year increase in deprecated tables, and a 58% reduction in P80 datasets.
Topics they write about
All topics →Weekly digest
The best engineering reads, once a week.