Uber Technologies

How We Halved Go Monorepo CI Build Time

Before 2021, Uber engineers would have to take quite a taxing journey to make a code change to the Go Monorepo. First, the engineer would make their changes on a local branch and put up a code revision to our internal code review system, Phabricator. Next, our infrastructure would see the request and initiate a number of validation jobs on our CI. Those jobs would run build and test validation using the Bazel build system, check the coverage, do some other work, and report back to the user a red light (i.e., tests failed or some other issues) or green light. Next, the user, after seeing the “green light,” would get their code reviewed and then initiate a “land” request to the Submit Queue. The queue, after receiving their request, would patch their changes on the latest HEAD of the main branch and re-run these associated builds and tests to make sure their change would be valid at the current state of the repository. If everything looked good, the changes would be pushed and the revision would be closed.

Enabling Offline Inferences at Uber Scale

At Uber we use data from user support interactions to identify gaps in our products and create better, more delightful experiences for our users. Support interactions with customers include information about broken product experiences, any technical or operational issues faced, and even their general sentiment towards the product and company. Understanding the root cause of a broken product experience requires additional context, such as details of the trip or the order. For example, the root cause for a customer issue about a delayed order might be due to a bad route given to the courier. In this case, we would want to attribute the poor customer experience to courier routing errors so that the Maps team can fix the same.

Uber’s Real-Time Document Check

Introduction: Justification for Identity Verification: Latin America is a rich cultural region, known for its world-renowned gastronomy, its abundant biodiversity, and its welcoming population. However, socio-economic inequality has been a challenge for the region, and is generally considered a major contributing factor to high levels of violence.The platform is not immune to the environment in which it operates. Therefore, to be one step ahead of opportunistic users, Uber has created the Rider Identity Team with 3 main goals in mind: reduce rider anonymity by verifying riders, reduce the rate of conflicts caused by riders, and improve driver safety sentiment regarding new riders.

Data Race Patterns in Go

Uber has adopted Golang (Go for short) as a primary programming language for developing microservices. Our Go monorepo consists of about 50 million lines of code (and growing) and contains approximately 2,100 unique Go services (and growing). Go makes concurrency a first-class citizen; prefixing function calls with the go keyword runs the call asynchronously. These asynchronous function calls in Go are called goroutines. Developers hide latency (e.g., IO or RPC calls to other services) by creating goroutines. Two or more goroutines can communicate data either via message passing (channels) or shared memory. Shared memory happens to be the most commonly used means of data communication in Go.

USL – Uber’s Unified Signup and Login Stack

Introduction: Uber has operations in over 10,000 cities worldwide and its services include ridesharing, food delivery, package delivery, couriers, freight transportation, electric bicycle and motorized scooter rental, and ferry transport. Every year we have millions of users going through signup and login on our various apps. Over the years we've built independent signup and login experiences for each of our lines of business which allowed us to innovate and move a lot quicker. However, as we scaled and added additional lines of business, our experiences began to diverge leading to some of these inconsistencies being amplified. USL (unified signup and login) enables the vision of “One Uber Identity” through a unified signup and login experience across all Uber apps.

Better Load Balancing: Real-Time Dynamic Subsetting

Subsetting is a common technique used in load balancing for large-scale distributed systems. In this blog post, we will briefly introduce current Uber’s service mesh architecture that has been powering thousands of critical microservices in Uber since 2016. We will then discuss the challenges we faced when trying to scale the number of tasks in the mesh and issues with our initial subsetting approach. We’ll finish with how we came up with the real-time dynamic subsetting solution and its results in production.

Dynamic Data Race Detection in Go Code

Uber has extensively adopted Go as a primary programming language for developing microservices. Our Go monorepo consists of about 50 million lines of code and contains approximately 2,100 unique Go services. Go makes concurrency a first-class citizen; prefixing function calls with the go keyword runs the call asynchronously. These asynchronous function calls in Go are called goroutines. Developers hide latency (e.g., IO or RPC calls to other services) by creating goroutines within a single running Go program. Goroutines are considered “lightweight”, and the Go runtime context switches them on the operating-system (OS) threads. Go programmers often use goroutines liberally. Two or more goroutines can communicate data either via message passing (channels) or shared memory. Shared memory happens to be the most commonly used means of data communication in Go.

Presto® on Apache Kafka® At Uber Scale

Uber’s goal is to ignite opportunity by setting the world in motion, and big data is a very important part of that. Presto® and Apache Kafka® play critical roles in Uber’s big data stack. Presto is the de facto standard for query federation that has been used for interactive queries, near-real-time data analysis, and large-scale data analysis. Kafka is the backbone for data streaming that supports many use cases such as pub/sub, streaming processing, etc. In the following article we will discuss how we have connected these two important services together to enable a lightweight, interactive SQL query directly over Kafka via Presto at Uber scale.

Securing Kafka® Infrastructure at Uber

Uber has one of the largest deployments of Apache Kafka® in the world. It empowers a large number of real-time workflows at Uber, including pub-sub message buses for passing event data from the rider and driver apps, as well as financial transaction events between the backend services. As Kafka forms a critical component of Uber’s core workflows, it is important to secure the data being published and subscribed from the topics to maintain the integrity of the data and to provide an access control mechanism for who can publish/subscribe to a given topic.

Uber’s Emergency Button and The Technologies Behind It

Safety has long been a top priority at Uber, as Uber’s CEO Dara Khosrowshahi wrote in ‘Raising the Bar on Safety’ in September 2018. In order to #StandForSafety, the team at Uber has rolled out a set of features, such as Safety Center, Trusted Contacts, and the in-app Emergency Button, among others.

Avoiding CPU Throttling in a Containerized Environment

At Uber, all stateful workloads run on a common containerized platform across a large fleet of hosts. Stateful workloads include MySQL®, Apache Cassandra®, ElasticSearch®, Apache Kafka®, Apache HDFS™, Redis™, Docstore, Schemaless, etc., and in many cases these workloads are co-located on the same physical hosts. With 65,000 physical hosts, 2.4 million cores, and 200,000 containers, increasing utilization to reduce cost is an important and continuous effort. Until recently efforts were blocked due to CPU throttling, which indicates that not enough resources have been allocated.

One Stone, Three Birds: Finer-Grained Encryption @ Apache Parquet™

Overview: Data access restrictions, retention, and encryption at rest are fundamental security controls. This blog explains how we have built and utilized open-sourced Apache Parquet™'s finer-grained encryption feature to support all 3 controls in a unified way. In particular, we will focus on the technical challenges of designing and applying encryption in a secure, reliable, and efficient manner. We will also share our experiences with recommended practices to manage the system in production and at scale.

Introducing Ballast: An Adaptive Load Test Framework

As Uber's architecture has grown to encompass thousands of interdependent microservices, we need to test our mission-critical components at max load in order to preserve reliability. Accurate load testing allows us to validate if a set of services are working at peak usage and optimal efficiency while retaining reliability. Load testing those services within a short time frame comes with its unique set of challenges. Most of these load tests historically involved writing, running, and supervising tests manually. Moreover, the degree to which tests accurately represent production traffic patterns gradually decreases over time as traffic organically evolves, imposing a long-term maintenance burden. The scope of the load testing effort continuously increases as the number of services grows, incurring a hidden cost to adding new features.

Introducing Carbon Feed for Earners: The One-Stop Info Shop

After launching the Driver App in 2018 to over 2 million earners worldwide, we added content and functionality at a rapid pace. Although this really bolstered the platform, allowing for high-density and high-frequency content, and provided drivers and couriers with new ways to earn, it came with significant costs. For earners, it became increasingly difficult to find the information that they needed to make key decisions about work at any given time. For internal teams within Uber trying to emit information, there was pressure to be loud across multiple channels in order to reach earners effectively; teams had to, in essence, compete against one another to ensure that their intended messages reached the right audiences. As a result, collective goals were inadvertently superseded by individual teams lacking context.

DeepETA: How Uber Predicts Arrival Times Using Deep Learning

At Uber, magical customer experiences depend on accurate arrival time predictions (ETAs). We use ETAs to calculate fares, estimate pickup times, match riders to drivers, plan deliveries, and more. Traditional routing engines compute ETAs by dividing up the road network into small road segments represented by weighted edges in a graph. They use shortest-path algorithms to find the best path through the graph and add up the weights to derive an ETA. But as we all know, the map is not the terrain: a road graph is just a model, and it can’t perfectly capture conditions on the ground. Moreover, we may not know which route a particular rider and driver will choose to their destination. By training machine learning (ML) models on top of the road graph prediction using historical data in combination with real-time signals, we can refine ETAs that better predict real-world outcomes.

Project RADAR: Intelligent Early Fraud Detection System with Humans in the Loop

Introduction: Uber is a worldwide marketplace of services, processing thousands of monetary transactions every second. As a marketplace, Uber takes on all of the risks associated with payment processing. Uber partners who use the marketplace to provide services are paid for their work even if Uber was unable to collect the payment. Fraud response is thus a very important operational component of Uber’s global marketplace.Industry-wide, payment fraud losses are measured in terms of the fraction of gross amounts processed. Though only a small fraction of gross bookings, these losses impact profits significantly. Furthermore, if a fraudulent activity is not discovered and mitigated immediately, it could soon be further exploited, resulting in serious losses for the company. These dynamics make early fraud detection vital to the company’s financial health. Modern fraud detection systems are a combination of classic 1980s AI (also known as an “expert system”) and modern machine learning. We would like to share the journey on how we build the best-in-class automatic fraud detection system and process, leveraging both machine algorithms and human knowledge.

Cost Efficiency @ Scale in Big Data File Format

Background: Our Apache Hadoop®-based data platform ingests hundreds of petabytes of analytical data with minimum latency and stores it in a data lake built on top of the Hadoop Distributed File System (HDFS). We use Apache Hudi™ as our ingestion table format and Apache Parquet™ as the underlying file format. Our data platform leverages Apache Hive™, Apache Presto™, and Apache Spark™ for both interactive and long-running queries, serving the myriad needs of different teams at Uber. Uber’s growth over the last few years exponentially increased both the volume of data and the associated access loads required to process it. As data volume grows, so do the associated storage and compute costs, resulting in growing hardware purchasing requirements, higher resource usage, and even causing out-of-memory (OOM) or high GC pause. The main goal of this blog is to address storage cost efficiency issues, but the side benefits also include CPU, IO, and network consumption usage. We started several initiatives to reduce storage cost, including setting TTL (Time to Live) to old partitions, moving data from hot/warm to cold storage, and reducing data size in the file format level. In this blog, we will focus on reducing the data size in storage at the file format level, essentially at Parquet.

Capacity Recommendation Engine: Throughput and Utilization Based Predictive Scaling

Capacity is a key component of reliability. Uber's services require enough resources in order to handle daily peak traffic and to support our different kinds of business units. These services are deployed across different cloud platforms and data centers (“zones”). With manual capacity management, it often results in an over-provisioned capacity, which is insufficient for resource usage. Uber built an auto-scaling service, which is able to manage and adjust resources for thousands of micro services. Currently, our auto-scaling service is based on a pure utilization metric. We recently built a new system, Capacity Recommendation Engine (CRE), with a new algorithm that relies on throughput and utilization based scaling with machine learning modeling. The model provides us with the relationship between the golden signal metrics and service capacity. With reactive prediction, CRE helps us to estimate the zonal service capacity based on linear regression modeling and peak traffic estimation. Apart from capacity, the analysis report can also tell us different zonal service characteristics and performance regression. In this article, we will deep dive into CRE’s modeling and system architecture, and present some analysis of its results.

The New Version of Orbit (v1.1) is Released: The Improvements, Design Changes, and Exciting Collaborations

Introduction: The previous post gave an overview of Orbit, a Python package developed by Uber in order to perform Bayesian time-series analysis and forecasting. This post provides the details of the version 1.1 updates—in particular, changes in syntax of calling models, the new classes design, and the KTR (Kernel Time-varying Regression) model. Some news about external interests and additional use cases will be discussed as well.

How We Saved 70K Cores Across 30 Mission-Critical Services (Large-Scale, Semi-Automated Go GC Tuning @Uber)

As part of Uber engineering’s wide efforts to reach profitability, recently our team was focused on reducing cost of compute capacity by improving efficiency. Some of the most impactful work was around GOGC optimization. In this blog I want to share our experience with a highly effective, low-risk, large-scale, semi-automated Go GC tuning mechanism. Uber’s tech stack is composed of thousands of microservices, backed by a cloud-native, scheduler-based infrastructure. Most of these services are written in Go. Our team, Maps Production Engineering, has previously played an instrumental role in significantly improving the efficiency of multiple Java services by tuning GC. At the beginning of 2021, we explored the possibilities of having a similar impact on Go-based services. We ran several CPU profiles to assess the current state of affairs and we found that GC was the top CPU consumer for a vast majority of mission-critical services. Here is a representation of some CPU profiles where GC (identified by the runtime.scanobject method) is consuming a significant portion of allocated compute resources.

Cadence Multi-Tenant Task Processing

Cadence is a multi-tenant orchestration framework that helps developers at Uber to write fault-tolerant, long-running applications, also known as workflows. It scales horizontally to handle millions of concurrent executions from various customers. It is currently used by hundreds of different teams within Uber to support their business logic. As we onboard different use cases to Cadence, resource isolation became a pressing issue. Bursty traffic or workflow tasks from one customer usually consumes all the resources in a cluster, causing significant task processing delays for others. This is especially common and undesirable when batch processing jobs were triggered during month-ends, causing delays in human interactive and latency-sensitive workflows. Moreover, the traffic in the clusters may become so heavy that it ultimately overloads our downstream database.

CRISP: Critical Path Analysis for Microservice Architectures

Uber’s backend is an exemplar of microservice architecture. Each microservice is a small, individually deployable program performing a specific business logic (operation). The microservice architecture is a type of distributed computing system, which is suitable for independent deployments and scaling of software programs, and so is widely used across modern service-oriented industries. Uber has a few thousand microservices interacting with one another via remote procedure calls (RPC). A service request arriving at an entry point (aka end-point) to the Uber backend systems undergoes multiple “hops” through numerous microservice operations before being fully serviced. The life of a request results in complex microservice interactions. These interactions are deeply nested, asynchronous, and invoke numerous other downstream operations. As a result of this complexity, it is very hard to identify which underlying service(s) contribute to the overall end-to-end latency experienced by a top-level request.

How Uber Migrated Financial Data from DynamoDB to Docstore

Introduction: Each day, Uber moves millions of people around the world and delivers tens of millions of food and grocery orders. This generates a large number of financial transactions that need to be stored with provable completeness, consistency, and compliance. LedgerStore is an immutable, ledger-style database storing business transactions. LedgerStore provides signing/sealing of data to guarantee data completeness/correctness, strongly consistent indexes, and automatic data tiering. LedgerStore uses DynamoDB as its storage backend. Running LedgerStore in production for almost 2 years at Uber scale, we’d amassed a large amount of data as trips and orders volume grew. Over this period of time we realized that operating LedgerStore with DynamoDB as a backend was becoming expensive. Also having different databases in our portfolio creates fragmentation and makes it difficult to operate. Having first-hand experience building large scale storage systems at Uber, we decided to change the LedgerStore backend to be one of our in-house, homegrown databases. The 2 main principles we kept in mind were: 1) Efficiency, and 2) Technology consolidation. Following the first would yield us great results in the short term, while the second would put us on a solid long-term roadmap, having greater flexibility and operational ease. In this post today we are going to talk about rearchitecting some of the core components of LedgerStore on top of Docstore, Uber’s general-purpose multi-model database.

Introducing uGroup: Uber’s Consumer Management Framework

Apache Kafka is widely used across Uber’s multiple business lines. Take the example of an Uber ride: When a user opens up the Uber app, demand and supply data are aggregated in Kafka queues to serve fare calculations. When a ride request is accepted by a driver, push notifications in Kafka queue are sent to mobile devices. After a ride is finished, post-trip processing, including payment and receipt sending, leverages Kafka. During the entire operation, the data and messages flowing between services are also ingested into Apache Hive for data analytic purposes. In a word, Apache Kafka is a critical service that empowers Uber’s business. Given its high popularity, we are operating large scale Kafka clusters across multiple regions. We started our Kafka journey in early 2015 with a few-node Kafka cluster in one region. With the tremendous growth of Uber’s business and expansion of Kafka usages, we ran into scaling and operational issues, and got many interesting user requests from customers.

Improving HDFS I/O Utilization for Efficiency

Scaling our data infrastructure with lower hardware costs while maintaining high performance and service reliability has been no easy feat. To accommodate the exponential growth in both Data Storage and Analytics Compute at Uber, the Data Infrastructure team massively overhauled its approach in scaling the Apache Hadoop® Data File System (HDFS) by re-architecting the software layer in conjunction with a hardware redesign: HDFS Federation, Warm Storage, YARN co-location on HDFS data nodes, and increased YARN utilization improved the systems’ CPU & Memory usage efficiency. Combining multiple Hardware server designs (24 x 2TB HDD, 24 x 4TB HDD, 35 x 8TB HDD) into a unified design of 35 x 16TB HDD for 30% Hardware cost reduction.

Building Uber’s Fulfillment Platform for Planet-Scale using Google Cloud Spanner

Introduction: The Fulfillment Platform is a foundational Uber domain that enables the rapid scaling of new verticals. The platform handles billions of database transactions each day, ranging from user actions (e.g., a driver starting a trip) and system actions (e.g., creating an offer to match a trip with a driver) to periodic location updates (e.g., recalculating eligible products for a driver when their location changes). The platform handles millions of concurrent users and billions of trips per month across over ten thousand cities and billions of database transactions a day. In the previous article, we introduced the Fulfillment domain, highlighted challenges in the previous architecture, and outlined the new architecture. When designing the new architecture, we converged on leveraging Google’s Cloud Spanner, a NewSQL storage engine to satisfy the requirements of transactional consistency, horizontal scalability, and low operational overhead. This article describes how we leveraged Cloud Spanner for planet-scale architecture without sacrificing consistency guarantees and with low operational overhead.

Real-Time Exactly-Once Ad Event Processing with Apache Flink, Kafka, and Pinot

Uber recently launched a new capability: Ads on UberEats. With the new business came new challenges that needed to be solved at Uber, such as systems for Ad auctions, bidding, attribution, reporting, and more. This article focuses on how we leveraged open source technology to build Uber’s first “near real-time” exactly-once events processing system. We’ll dive into the details of how we achieved exactly-once processing as well as the inner workings of our event processing jobs.

YAML Generator for Funnel YAML Files: Streamlining the Mobile Data Workflow Process

At Uber, real-time mobile analytics events—generated by button taps, page views, and more—form the backbone of the mobile data workflow process. To process these events, our Mobile Data Platform Team designed and developed the Fontana library, which converts the nearly-one-million-QPS (queries per second) volume of events into easily digestible and useful analytics for Uber engineers. As part of this process, funnel YAML files are key config files that are used to define sequences of events for analysis. To this end, our team has also designed and developed the SuperFlurry application, which aids in creating and managing these files.

Jellyfish: Cost-Effective Data Tiering for Uber’s Largest Storage System

Problem: Uber deploys a few storage technologies to store business data based on their application model. One such technology is called Schemaless, which enables the modeling of related entries in one single row of multiple columns, as well as versioning per column. Schemaless has been around for a couple of years, amassing Uber’s data. While Uber is consolidating all the use cases on Docstore, Schemaless is still the source of truth for different pre-existing customer pipelines. As such, Schemaless uses fast (but expensive) underlying storage technology to enable millisecond-order latency at high QPS. Furthermore, Schemaless deploys a number of replicas per region to ensure data durability and availability in the face of different failure models. Accumulating more data while using expensive storage, Schemaless has increasingly become a key concern for cost and thus required attention. To this end, we carried out measurements for understanding data access patterns. We found that data is frequently accessed for a period of time, after which it is accessed less frequently. The exact period varies from one use case to another, however, old data must still be readily available upon request.

Streaming Real-Time Analytics with Redis, AWS Fargate, and Dash Framework

Introduction: Uber’s GSS (Global Scaled Solutions) team runs scaled programs for diverse products and businesses, including but not limited to Eats, Rides, and Freight. The team transforms Uber’s ideas into agile, global solutions by designing and implementing scalable solutions. One of the areas of expertise within GSS is the Digitization vertical. The Digitization team efficiently converts physical signals into digital assets and provides services in labeling, in-field testing, data curation and validations for maps, product incubation, freight BOL (bill of lading), Eats menu uploads, etc.

Enabling Seamless Kafka Async Queuing with Consumer Proxy

Uber has one of the largest deployments of Apache Kafka in the world, processing trillions of messages and multiple petabytes of data per day. As Figure 1 shows, today we position Apache Kafka as a cornerstone of our technology stack. It empowers a large number of different workflows, including pub-sub message buses for passing event data from the rider and driver apps, streaming analytics (e.g., Apache Flink, Apache Samza), streaming database changelogs to the downstream subscribers, and ingesting all sorts of data into Uber’s Apache Hadoop data lake. More than 300 microservices at Uber are leveraging Kafka for pub-sub message queueing between microservices. In the following article we will go in depth on this particular use case, and discuss both how we arrived at the Consumer Proxy, and what it has enabled.

How Data Shapes the Uber Rider App

Introduction: Data is crucial for our products. Data analytics help us provide a frictionless experience to the people that use our services. It also enables our engineers, product managers, data analysts, and data scientists to make informed decisions.The impact of data analysis can be seen in every screen of our app: what is displayed on the home screen, the order in which products are shown, what relevant messages are shown to users, what is stopping users from taking rides or signing up, and so on. With such a huge user base and wide range of features, support across all geographic regions is a complicated problem to solve. Furthermore, our app keeps expanding with new products, which mandates that the underlying tech also be flexible enough to evolve and support them. Data is the primary tool enabling this. The following article will focus on rider data in particular: how we collect and process it, and how that has informed concrete improvements to the Rider app.

Building Scalable Streaming Pipelines for Near Real-Time Features

Background: Uber is committed to providing reliable services to customers across our global markets. To achieve this, we heavily rely on machine learning (ML) to make informed decisions like forecasting and surge. As a result, real-time streaming pipelines, which are used to generate the data and features for ML, have become more popular and important. At Uber, we leverage Apache Flink to build the real-time streaming pipelines, and build platforms like Gairos and AthenaX to simplify development. However, there are still many challenges, such as scalability, due to either the complexity of computation or the amount of real-time data to be processed. In this article, we will use the pipelines that generate demand and supply features, as an example to introduce some of the challenges we faced and how we solved them. In particular we will explain how we tune the real-time pipelines with the performance tuning framework.

Powering the Network Pricing Model with Near Real-Time Features

Background: Drivers within the same area may have quite different earnings, depending on the trips they take. For example, consider two hypothetical drivers in downtown San Francisco. Two riders request two rides: one is within downtown San Francisco, and the other is to Oakland, as shown in the image above. The distances for the two trips are similar. If we just price the trip based on distance, they will make the same amount of money for the current trip, while the driver going to Oakland will be less likely to get more trips there. Drivers tend to reject these trips if they have other choices. To reduce the variance of earnings for colocated drivers and the cancellation rate for trips going to non-busy areas, we price these trips differently, based on the network effect. Both the rider and driver pricing flows are being changed to compute network adjustments in real time. Both these pricing systems receive adjustments based on a common network model, which returns the relative change in GB (Gross Bookings) of enabling a specific trip, compared with an average trip from that same origin. The network model used requires some NRT (Near Real-Time) features. In this document, we will introduce some of the challenges we faced and how we solved them when building the real-time pipelines for computing and serving these features to online models.

Eats Safety Team On-Call Overview

Introduction: Our engineers have the responsibility of ensuring a consistent and positive experience for our riders, drivers, eaters, and delivery/restaurant partners.Ensuring such an experience requires reliable systems: our apps have to work when anyone needs them. A major component of reliability is having engineers on call to deal with problems immediately as they arise. We set up our on-call engineers for success through training, tools, and processes.In this article we will provide an overview of how we at the Eats Safety team ensure that our engineers are fully equipped to provide prompt, high-quality service—anywhere in the world, 24/7.

Unifying Support Content to Enable More Empathetic and Personalized Customer Support Experiences

Introduction Content quality is critical to the support experienced by Uber’s customers. Consider an Eater who reached out for help to cancel a very delayed order. The same resolution, such as refunding the charge, can be delivered alongside a robotic-sounding message, or one where the style and tone of the response conveys true empathy and acknowledges the user’s poor experience on our platform. As the natural expression of the support experience, and a bearer of brand promise, support content affects how people feel, and plays a major part in how they perceive the Uber brand. In addition, support content plays the role of educating users about the product behavior and about our policies while moving them to action. Finally, support content (such as knowledge base articles) also serves to deflect commonly asked questions and reduce the number of contacts handled by our agents. In short, support content is what a disgruntled customer first sees, and hence it is imperative that this content can placate and soothe the customer, whilst also resolving the core issue, transforming customer ire into customer delight.

Efficiently Managing the Supply and Demand on Uber’s Big Data Platform

With Uber’s business growth and the fast adoption of big data and AI, Big Data scaled to become our most costly infrastructure platform. To reduce operational expenses, we developed a holistic framework with 3 pillars: platform efficiency, supply, and demand (using supply to describe the hardware resources that are made available to run big data storage and compute workload, and demand to describe those workloads). In this post, we will share our work on managing supply and demand. For more details about the context of the larger initiative and improvements in platform efficiency, please refer to our earlier posts: Challenges and Opportunities to Dramatically Reduce the Cost of Uber’s Big Data, and Cost-Efficient Open Source Big Data Platform at Uber.

Cost-Efficient Open Source Big Data Platform at Uber

As Uber’s business has expanded, the underlying pool of data that powers it has grown exponentially, and thus ever more expensive to process. When Big Data rose to become one of our largest operational expenses, we began an initiative to reduce costs on our data platform, which divides challenges into 3 broad pillars: platform efficiency, supply, and demand. In this post we will discuss our efforts to improve the efficiency of our data platform and bring down costs.

Challenges and Opportunities to Dramatically Reduce the Cost of Uber’s Big Data

Big data is at the core of Uber’s business. We continue to innovate and provide better experiences for our earners, riders, and eaters by leveraging big data, machine learning, and artificial intelligence technology. As a result, over the last four years, the scale of our big data platform multiplied from single-digit petabytes to many hundreds of petabytes.Uber’s big data stack is built on top of the open source ecosystem. We run some of the largest deployments of Hadoop, Hive, Spark, Kafka, Presto, and Flink in the world. Open source software allows us to quickly scale up to meet Uber’s business needs without reinventing the wheel.

How Uber Achieves Operational Excellence in the Data Quality Experience

Uber delivers efficient and reliable transportation across the global marketplace, which is powered by hundreds of services, machine learning models, and tens of thousands of datasets. While growing rapidly, we’re also committed to maintaining data quality, as it can greatly impact business operations and decisions. Without data quality guarantees, downstream service computation or machine learning model performance quickly degrade, which requires a lot of laborious manual efforts to investigate and backfill poor data. In the worst cases, degradations could go unnoticed, silently resulting in inconsistent behaviors.

Uber’s Finance Computation Platform

For a company of our size and scale, robust, accurate, and compliant accounting and analytics are a necessity, ensuring accurate and granular visibility into our financials, across multiple lines of business.Most standard, off-the-shelf finance engineering solutions cannot support the scale and scope of the transactions on our ever-growing platform.  The ride-sharing business alone has over 4 billion trips per year worldwide, which translates to more than 40 billion journal entries (financial microtransactions). Each of these entries has to be produced in accordance with Generally Accepted Accounting Principles (GAAP), and managed in an idempotent, consistent, accurate, and reproducible manner.

Pinot Real-Time Ingestion with Cloud Segment Storage

Apache Pinot is an open source data analytics engine (OLAP), which allows users to query data ingested from as recently as a few seconds ago to as old as a few years back. Pinot’s ability to ingest real-time data and make them available for low-latency queries is the key reason why it has become an important component of Uber’s data ecosystem. Many products built in Uber require real-time data analytics to operate in our mobile marketplace for shared rides and food delivery. For example, the chart in Figure 1 shows the breakdown of Uber Eats job states over a period of minutes. Our Uber Eats city operators need such insights to balance marketplace supply and demand, and detect ongoing issues. 

Uber’s Fulfillment Platform: Ground-up Re-architecture to Accelerate Uber’s Go/Get Strategy

Uber’s mission is to help our consumers effortlessly go anywhere and get anything in thousands of cities worldwide. At its core, we capture a consumer’s intent and fulfill it by matching it with the right set of providers. Fulfillment is the “act or process of delivering a product or service to a customer.” The Fulfillment organization at Uber develops platforms to orchestrate and manage the lifecycle of ongoing orders and user sessions with millions of active participants. 

Containerizing Apache Hadoop Infrastructure at Uber

Introduction: As Uber’s business grew, we scaled our Apache Hadoop (referred to as ‘Hadoop’ in this article) deployment to 21000+ hosts in 5 years, to support the various analytical and machine learning use cases. We built a team with varied expertise to address the challenges we faced running Hadoop on bare-metal: host lifecycle management, deployment and automation, Hadoop core development, and customer facing portals. With the growing complexity and size of Hadoop infrastructure, it became increasingly difficult for the team to keep up with the various responsibilities around managing such a large fleet. Fleet-wide operations using scripts and tooling consumed a lot of engineering time. Bad hosts started piling up without timely repairs. As we continued to maintain our own bare-metal deployment for Hadoop, the rest of the company made significant progress in the microservices world. Solutions for container orchestration, host lifecycle management, service mesh, and security laid the foundations, making management of microservices far more efficient and less cumbersome. In 2019, we started a journey to re-architect the Hadoop deployment stack. Fast forward 2 years, over 60% of Hadoop runs in Docker containers, bringing major operational benefits to the team. As a result of the initiative, the team handed off many of their responsibilities to other infrastructure teams, and was able to focus more on core Hadoop development. This article provides a summary of problems we faced, and how we solved them along the way.

‘Orders Near You’ and User-Facing Analytics on Real-Time Geospatial Data

By its nature, Uber’s business is highly real-time and contingent upon geospatial data. PBs of data are continuously being collected from our drivers, riders, restaurants, and eaters. Real-time analytics over this geospatial data could provide powerful insights. In this blog, we will highlight the Orders near you feature from the Uber Eats app, illustrating one example of how Uber generates insights across our geospatial data. Orders near you was a recent collaboration between the Data and Uber Eats teams at Uber. The project's goal was to create an engaging and unique social experience for eaters. We hoped to inspire new food and restaurant discovery by showing what your neighbors are ordering right now. Since this feature is part of our home feed, we needed it to be fast, personalized, and scalable.

Analyzing Customer Issues to Improve User Experience

Introduction The primary goal for customer support is to ensure users’ issues are addressed and resolved in a timely and effective manner. The kind of issues users face and what they say in their support interactions provides a lot of information about the product experience, any technical or operational gaps and even their general sentiment towards the product / company. At Uber, we don’t stop at just resolving user issues. We also use the issues reported by customers to improve our support experience and our products. This article describes the technology that makes it happen. Support Data at Uber Support

Customer Support Automation Platform at Uber

High Level Overview of the Problem Introduction If you’ve used any online/digital service, chances are that you are familiar with what a typical customer service experience entails: you send a message (usually email aliased) to the company’s support staff, fill out a form, expect some back and forth with a customer service representative (CSR), and hopefully have your issue resolved. This process can often feel inefficient and slow. Typically, this might be attributable to the tooling/processes made available to CSRs for solving your issue. For any given issue, the CSR has to navigate standard operating procedures (SOPs, a.k.a. flow) with

Tuning Model Performance

Introduction Uber uses machine learning (ML) models to power critical business decisions. An ML model goes through many experiment iterations before making it to production. During the experimentation phase, data scientists or machine learning engineers explore adding features, tuning parameters, and running offline analysis or backtesting. We enhanced the platform to reduce the human toil and time in this stage, while ensuring high model quality in production. Hyperparameter Optimization             Searching through a large hyperparameter search space is expensive due to the curse of dimensionality, which holds true even for Bayesian optimization techniques that are

Elastic Distributed Training with XGBoost on Ray

Introduction Since we productionized distributed XGBoost on Apache Spark™ at Uber in 2017, XGBoost has powered a wide spectrum of machine learning (ML) use cases at Uber, spanning from optimizing marketplace dynamic pricing policies for Freight, improving times of arrival (ETA) estimation, fraud detection and prevention, to content discovery and recommendation for Uber Eats. However, as Uber has scaled, we have started to run distributed training jobs with more data and workers, and more complex distributed training patterns have become increasingly common. As such, we have observed a number of challenges for doing distributed machine learning and deep learning at

Continuous Integration and Deployment for Machine Learning Online Serving and Models

Introduction At Uber, we have witnessed a significant increase in machine learning adoption across various organizations and use-cases over the last few years. Our machine learning models are empowering a better customer experience, helping prevent safety incidents, and ensuring market efficiency, all in real time. The figure above is a high level view of CI/CD for models and service binary. One thing to note is we have continuous integration (CI)/continuous deployment (CD) for models and services, as shown above in Figure 1. We arrived at this solution after several iterations to address some of MLOps challenges, as the number of

Efficient and Reliable Compute Cluster Management at Scale

Introduction Uber relies on a containerized microservice architecture. Our need for computational resources has grown significantly over the years, as a consequence of business’ growth. It is an important goal now to increase the efficiency of our computing resources. Broadly speaking, the efficiency efforts in compute cluster management involve scheduling more workloads on the same number of machines. This approach is based on the observation that the average CPU utilization of a typical cluster is far lower than the CPU resources that have been allocated to it. The approach we have adopted is to overcommit CPU resources, without compromising the

Handling Flaky Unit Tests in Java

Introduction to Flaky Tests Unit testing forms the bedrock of any Continuous Integration (CI) system. It warns software engineers of bugs in newly-implemented code and regressions in existing code, before it is merged. This ensures increased software reliability. It also improves overall developer productivity, as bugs are caught early in the software development lifecycle. Hence, building a stable and reliable testing system is often a key requirement for software development organizations.  Unfortunately, by definition, flaky unit tests undercut this requirement. A unit test is considered flaky if it returns different results (pass or fail) on any two executions, without any

The Evolution of Data Science Workbench

In October 2017, we published an article introducing Data Science Workbench (DSW), our custom, all-in-one toolbox for data science, complex geospatial analytics, and exploratory machine learning. It centralizes everything required to perform data preparation, ad-hoc analyses, model prototyping, workflow scheduling, dashboarding, and collaboration in a single-pane, web-based graphical user interface.  In this article, we reflect on the evolution of DSW over the last 3 years. We review our journey by looking at how DSW’s usage has evolved to include and supercharge the workflows of more than just data scientists, dive into how the choices we made when designing the platform

Scaling of Uber’s API gateway

As a recap from the last article, Uber’s API Gateway provides an interface and acts as a single point of access for all of our back-end services to expose features and data to Mobile and 3rd party partners. Two major components for a system like API Gateway are configuration management and runtime. The runtime component is responsible for authenticating, authorizing, transforming, and routing requests to appropriate downstream services, and passing responses back to Mobile. The configuration management component is responsible for managing the workflow for developers to easily configure their endpoints on the gateway. This includes making sure the configured

Fraud Detection: Using Relational Graph Learning to Detect Collusion

As Uber grew in popularity and scale among legitimate customers, it also attracted the attention of financial criminals in the cyberspace. One type of fraudulent behavior is collusion, a cooperative fraud action among users. For example, users collude by taking fake trips with stolen credit cards resulting in chargeback (a bank-initiated refund for a credit card purchase). In this article we show a case study of applying a cutting-edge, deep graph learning model called relational graph convolutional networks (RGCN) to detect such collusion. Graph learning methods have been extensively used in fraud detection and recommendation tasks . For example, at

The Architecture of Uber’s API gateway

API gateways are an integral part of microservices architecture in recent years. An API gateway provides a single point of entry for all our apps and provides an interface to access data, logic, or functionality from back-end microservices. It also provides a centralized place to implement many high-level responsibilities, including routing, protocol conversion, rate limiting, load shedding, header enrichment and propagation, data center affinity enforcement, security auditing, user access blocking, mobile client generation, and others. In our last article, we walked through multiple generations of Uber's API gateway evolution and our design choices in each phase. In this article, we

Introducing Orbit, An Open Source Package for Time Series Inference and Forecasting

Orbit is a general interface for Bayesian time series modeling. The goal of Orbit development team is to create a tool that is easy to use, flexible, interitible, and high performing (fast computation). Under the hood, Orbit uses the probabilistic programming languages (PPL) including but not limited to Stan and Pyro for posterior approximation (i.e, MCMC sampling, SVI). Below is a quadrant chart to position a few time series related packages in our assessment in terms of flexibility and completeness. Orbit is the only tool that allows for easy model specification and analysis while not limiting itself to a small

pprof++: A Go Profiler with Hardware Performance Monitoring

Motivation for a Better Go Profiler Golang is the lifeblood of thousands of Uber’s back-end services, running on millions of CPU cores. Understanding our CPU bottlenecks is critical, both for reducing service latencies and also for making our compute fleet efficient. The scale at which Uber operates demands in-depth insights into codes and microarchitectural implications. While the built-in Go profiler is better than having no profiler compared with several other languages, the de facto CPU profiler in Go has serious limitations on Linux-based systems (and likely on other OSes as well) and lacks many of the details needed for fully

Optimal Feature Discovery: Better, Leaner Machine Learning Models Through Information Theory

Introduction  Suppose you own a production ML model that already works reasonably well. You know that adding relevant and diverse sources of signal to your model is a sure way to boost performance, but finding new features that actually improve performance can be a slow and tedious process of trial and error.  At the start of your search, you might look to reuse features developed for other projects, or you might choose to prototype new features that you suspect would benefit your model. In either case, there could be hundreds to thousands of potential new features to explore, many of

Automating Merchant Live Monitoring with Real-Time Analytics: Charon

At Uber, live monitoring and automation of Ops is critical to preserve marketplace health, maintain reliability, and gain efficiency in markets. By the virtue of the word “live”, this monitoring needs to show what is happening now, with prompt access to fresh data, and the ability to recommend appropriate actions based on that data. Uber’s data platform provides the self-serve tools which empower the Ops teams to build their own live monitoring tools, and support their regional teams by building rich solutions.  For this project, the requirement was to provide merchant level monitoring and handle the edge cases which remain

Freight Pricing with a Controlled Markov Decision Process

Intro Uber Freight was launched in 2017 to revolutionize the business of matching shippers and carriers in the huge and inefficient freight trucking industry (around $800B annual spend in the US). We believe, and have demonstrated, that a technology-first freight broker and marketplace can provide better opportunities to carriers, and superior outcomes to shippers and communities alike.  One of the wasteful processes we set out to eliminate through technology is the lengthy haggling between traditional freight brokers and carriers for the price of a load (a shipment in freight lingo). This practice stems from a lack of transparency on freight

Flipr: Making Changes Quickly and Safely at Scale

Uber’s many software systems require a high volume of changes every day. Because of our systems’ size and complexity, it is a significant challenge to implement these changes without unintended consequences, ultimately slowing down developer productivity. Flipr is a big part of Uber’s solution to solving this problem. Flipr is a tool that we created for dynamic configuration management, such as feature flags, allowlists, incremental rollout, and other advanced use cases.

Uber’s Journey Toward Better Data Culture From First Principles

Data powers Uber Uber has revolutionized how the world moves by powering billions of rides and deliveries connecting millions of riders, businesses, restaurants, drivers, and couriers. At the heart of this massive transportation platform is Big Data and Data Science that powers everything that Uber does, such as better pricing and matching, fraud detection, lowering ETAs, and experimentation. Petabytes of data are collected and processed per day and thousands of users derive insights and make decisions from this data to build/improve these products. Problems beyond scale While we are able to scale our data systems, we previously didn’t focus enough

Navigating to the Technical Program Management and Learning Team

Spread across 4 continents, the Technical Strategy, Program Management, and Learning team is composed of Technical Program Managers (TPMs), Technical Writers, Technical Strategists, and Technical Training Program Managers. Uber TPMs play a critical role in executing high-impact, company-wide initiatives and continuously improving processes to increase the effectiveness of our Product and Engineering organizations. On the Learning side, Program Managers and Technical Writers increase engineer impact and productivity by understanding pain points and providing learning solutions for technical and leadership skills.  As one of Uber’s most global and diverse engineering teams, we support hundreds of cross-functional teams around the globe who serve over 90

Elastic Deep Learning with Horovod on Ray

Introduction In 2017, we introduced Horovod, an open source framework for scaling deep learning training across hundreds of GPUs in parallel.  At the time, most of the deep learning use cases at Uber were related to the research and development of self-driving vehicles, while in Michelangelo, the vast majority of production machine learning models were tree models based on XGBoost. Now in 2021, the state of deep learning is changing.  Increasingly, deep learning models are outperforming tree-based models for tabular data problems, and more deep learning models are moving from research to production.  As a result, we’ve had to rethink

Applying Machine Learning in Internal Audit with Sparsely Labeled Data

As machine learning continues to evolve, transforming the various industries it touches, it has only begun to inform the world of audit. As a data scientist and former CPA Auditor, I can understand why this is the case. By nature, auditing is a field that focuses on the fine details and investigates any exceptions, while machine learning typically seeks to extrapolate broad patterns. Where auditing focuses on analyzing historical events, machine learning solutions tend to predict future events. Lastly, most auditors lack the necessary education or coding skill set to proficiently experiment with machine learning in their work. Below I

How Uber Deals with Large iOS App Size

Uber’s iOS mobile Apps for Rider, Driver, and Eats are large in size. The choice of Swift as our primary programming language, our fast-paced development environment and feature additions, layered software and its dependencies, and statically linked platform libraries result in large app binaries. Reducing application size is critical to our customer experience. Moreover, Apple’s app-download-size limitations prohibit large app downloads over the air. 

Evolving Schemaless into a Distributed SQL Database

In 2016 we published blog posts (I, II) about Schemaless - Uber Engineering’s Scalable Datastore. We went over the design of Schemaless as well as explained the reasoning behind developing it. In this post today we are going to talk about the evolution of Schemaless into a general-purpose transactional database called Docstore. 

Fast and Reliable Schema-Agnostic Log Analytics Platform

At Uber, we provide a centralized, reliable, and interactive logging platform that empowers engineers to work quickly and confidently at scale. The logs are tagged with a rich set of contextual key value pairs, with which engineers can slice and dice their data to surface abnormal or interesting patterns that can guide product improvement. Right now, the platform is ingesting millions of logs per second from thousands of services across regions, storing several PBs worth, and serving hundreds of queries per second from both dashboards and programs.  Since starting with ELK for logging in 2014, our system traffic volume and

Uber’s Real-time Data Intelligence Platform At Scale: Improving Gairos Scalability/Reliability

Members of our engineering team introducing Gairos. Uber’s real-time data processing, storage, and querying platform to facilitate streamlined and efficient data exploration at scale.

The Journey Towards Metric Standardization

At Uber, business metrics are vital for discovering insights about how we perform, gauging the impact of new products, and optimizing the decision making process. The use cases for metrics can range from an operations member diagnosing a fares issue at the trip level to a machine learning model for dynamic pricing that shapes a balanced and robust marketplace in real time at global scale.

Disaster Recovery for Multi-Region Kafka at Uber

Apache Kafka at Uber Uber has one of the largest deployments of Apache Kafka in the world, processing trillions of messages and multiple petabytes of data per day. As Figure 1 shows, today we position Apache Kafka as a cornerstone to Uber’s technology stack and build a complex ecosystem on top of it to empower a large number of different workflows. These include a pub/sub message bus to pass event data from the rider and driver apps, enabling a streaming analytics platform (e.g. Apache Samza, Apache Flink), streaming database changelogs to the downstream subscribers, and ingesting all sorts of data

Uber’s Real-Time Push Platform

Uber builds multi-sided marketplaces handling millions of trips every day across the globe. We strive to build real-time experiences for all our users. The nature of real time marketplaces make them very lively. Over the course of a trip, there are multiple participants that can modify and view the state of an ongoing trip and need real-time updates. This creates the need to keep all active participants and apps synced with real-time information, whether it’s through pickup time, arrival time, and route lines on the screen, or nearby drivers when you open the app.  A key dimension of growth was

No Code Workflow Orchestrator for Building Batch & Streaming Pipelines at Scale

We built uWorc, or Universal Workflow Orchestrator, on our guiding principles. It includes a simple drag and drop interface that can manage the entire life cycle of a batch or streaming pipeline, without having to write a single line of code.

Horovod v0.21: Optimizing Network Utilization with Local Gradient Aggregation and Grouped Allreduce

The Horovod community continues to grow, recently surpassing 10k stars on GitHub and reaching graduation status within the Linux Foundation for AI & Data. Today, we’re excited to announce v0.21, which brings a number of powerful new features to the Horovod community that make training deep learning models at scale faster and easier than ever before.

Turning Metadata Into Insights with Databook

To help our teams easily discover and understand this data better, we built Databook. This is Uber’s in-house platform which surfaces and manages the metadata related to various data entities such as datasets, internal dashboards, business metrics, and more.

Meet the 2020 Safety Engineering Interns: COVID Edition

 This summer, the Safety team had interns distributed across six cities, three time zones, working on eight different products for 12 weeks. With the transition to remote work due to COVID-19, it was not the usual summer in store for us.

Operating Apache Pinot @ Uber Scale

Introduction Uber has a complex marketplace consisting of riders, drivers, eaters, restaurants and so on. Operating that marketplace at a global scale requires real-time intelligence and decision making. For instance, identifying delayed Uber Eats orders or abandoned carts helps to enable our community operations team to take corrective action. Having a real-time dashboard of different events such as consumer demand, driver availability, or trips happening in a city is crucial for day-to-day operation, incident triaging, and financial intelligence.  Over the last few years, we’ve built a self-service platform to power such use cases, and many others, across different parts of

Building from the Baltics: Meet the Uber Engineering Team in Vilnius, Lithuania

The Uber Vilnius office is home to members of our Production Engineering, Infrastructure, Storage Platform, and Developer Tools team.

Ludwig v0.3 Introduces Hyper-parameter Optimization, Transformers and TensorFlow 2 support

In February 2019, Uber released Ludwig, an open source, code-free deep learning (DL) toolbox that gives non-programmers and advanced machine learning (ML) practitioners alike the power to develop models for a variety of DL tasks. With use cases spanning text classification, natural language understanding, image classification, and time series forecasting, among many others, Ludwig gives users the ability to easily train and test DL models, and the power to tweak parameters for exploring architectures, comparing models, and improving performance. Today, we are excited to release Ludwig version 0.3, featuring several updates that take our framework to the next level. With

Revolutionizing Money Movements at Scale with Strong Data Consistency

Uber as a platform invites its users to leverage it, earn from it, and be delighted by it. Serving more than 18 million requests per day, in 10,000+ cities, has enabled people to move freely and to think broadly while earning a livelihood on it. As one of the underlying engines, Uber Money fulfills some of the most important aspects of people’s engagement in the Uber experience. A system like this should not only be robust, but should also be highly available with zero-tolerance to downtime, after our success mantra: “To collect and disburse on-time, accurately and in-compliance”. While we

Spearheading Open Source: A Conversation with Jim Jagielski, Staff Technical Program Manager with the Uber Open Source Program Office

Jim Jagielski's fascination with open source software began out of necessity. He was working at NASA Goddard in the 1980s, and the agency had just received fancy new Macintosh computers loaded with Apple's new A/UX operating system. There was only one problem: None of the tools Jagielski needed ran on A/UX. It fell to Jagielski to port everything himself. 'That’s what got me involved in open source,' says Jagielski. 'The idea of being able to take this source code, add patches to it, get it running on your system, and then provide those patches upstream so the community benefited—that seemed

Designing Edge Gateway, Uber’s API Lifecycle Management Platform

The making of Edge Gateway, the highly-available and scalable self-serve gateway to configure, manage, and monitor APIs of every business domain at Uber.

Standing for Safety: Meet the Uber Sao Paulo Tech Team

Located in the heart of Latin America’s largest city, the Uber Sao Paulo Tech Center was founded in late 2018 as a company-wide hub for Safety Tech. The team is composed of product managers, UX designers, engineers and data scientists. As part of Uber’s mission to put the safety of our users first, our Sao Paulo-based Tech team is responsible for improving our global processes and services to keep riders, drivers, eaters, and delivery-partners safe. Our teams in Sao Paulo are responsible for planning and developing new features that help to prevent incidents on our platform and help users travel

Introducing Domain-Oriented Microservice Architecture

Introduction Recently there has been substantial discussion around the downsides of service oriented architectures and microservice architectures in particular. While only a few years ago, many people readily adopted microservice architectures due to the numerous benefits they provide such as flexibility in the form of independent deployments, clear ownership, improvements in system stability, and better separation of concerns, in recent years people have begun to decry microservices for their tendency to greatly increase complexity, sometimes making even trivial features difficult to build. As Uber has grown to around 2,200 critical microservices, we experienced these tradeoffs first hand. Over the last

Engineering Failover Handling in Uber’s Mobile Networking Infrastructure

The network communication for all of Uber’s mobile applications are powered by the edge and the mobile networking infrastructures. The edge infrastructure provides secure connectivity for the HTTPS traffic originating from the mobile apps to the backend services. Uber’s edge infrastructure combines the global presence of public cloud platforms that help reduce app latencies with the additional ability to fallback to our own managed data-centers when required for enhanced reliability.

Fiber: Distributed Computing for AI Made Simple

Fiber is a Python-based distributed computing library for modern computer clusters. Instead of programming only a single desktop or laptop, users can leverage this system to program the whole computer cluster. It was originally developed to power large-scale parallel scientific computation projects like POET, and Uber has used it to power similar projects.

Editing Massive Geospatial Data Sets with nebula.gl

Uber built and open sourced nebula.gl, a tool set for full-featured geospatial editing in the web browser, to better visualize large-scale data sets.

Profiles in Coding: Diana Yanakiev, Uber ATG, Pittsburgh

Diana Yanakiev, an engineering manager with Uber ATG, discusses her career journey from electrical engineering to building self-driving vehicles.

Building a Large-scale Transactional Data Lake at Uber Using Apache Hudi

The Apache Hudi team at Uber reflects on the open source project's history as it graduates to a Top Level Project under the Apache Software Foundation.

Introducing Neuropod, Uber ATG’s Open Source Deep Learning Inference Engine

Developed by Uber ATG, Neuropod is an abstraction layer that provides a universal interface to run models across any deep learning framework.

Inside Uber ATG’s Data Mining Operation: Identifying Real Road Scenarios at Scale for Machine Learning

Uber ATG's self-driving vehicles data mine a multitude of real-world scanerios to answer the age-old question: "how does the pedestrian cross the road?"

Meta-Graph: Few-Shot Link Prediction Using Meta-Learning

Uber AI introduces Meta-Graph, a new few-shot link prediction framework that facilitates the more accurate training of ML models with new graph data.

Profiles in Coding: Christabelle Bosson, Uber Elevate, San Francisco

Christabelle Bosson, a senior airspaces services engineer, discusses her journey from NASA to Uber Elevate and shares advice for aspiring engineers.

Developing the Next Generation of Coders with the Dev/Mission Uber Coding Fellowship

Participants will take courses taught by Uber engineers and work with Code for San Francisco on projects that benefit the local community.

Introducing Athenadriver: An Open Source Amazon Athena Database Driver for Go

Uber ATG built Athenadriver, an open source Amazon Athena database driver for Go, to facilitate communication between our data analytics tools and the cloud.

Building Uber’s Go Monorepo with Bazel

When Uber adopted the open source Bazel build system, our engineers found many opportunities to contribute improvements to how Bazel works with a large Go monorepo.

Announcing a New Framework for Designing Optimal Experiments with Pyro

Uber AI releases a new framework on top of Pyro that lets experimenters seamlessly automate optimal experimental design (OED) for quicker model iteration.

Monitoring Data Quality at Scale with Statistical Modeling

Uber employs statistical modeling to find anomalies in data and continually monitor data quality.

Enhanced POET: Open-Ended Reinforcement Learning through Unbounded Invention of Learning Challenges and their Solutions

Building upon our existing open-ended learning research, Uber AI released Enhanced POET, incorporating an improved algorithm and more training environments.

Introducing Piranha: An Open Source Tool to Automatically Delete Stale Code

Uber developed Piranha to seamlessly delete code related to obsolete feature flags, leading to improved developer productivity and a cleaner codebase.

Fostering a Culture of Sponsorship: Introducing Uber’s Engineering and Sponsorship Development Program

Designed by Uber's Office of the CTO, the Engineering Sponsorship and Development Program pairs participants with sponsors and helps them hone technical leadership skills.

Why We Leverage Multi-tenancy in Uber’s Microservice Architecture

Multi-tenancy lets Uber tag requests coming into our microservice architecture, giving us the flexibility to route requests to specific components, such as during testing scenarios.

Celebrating International Women’s Day: Meet the Women Building Uber’s Global Platform

To celebrate International Women's Day, we spoke with women from across the company whose work helps deliver impactful experiences for Uber users worldwide.

Introducing Uber’s Open Source Principles

Uber shares our principles and goals for using and contributing open source software, providing visibility into our company's approach to open source.

Under the Hood of Uber ATG’s Machine Learning Infrastructure and Versioning Control Platform for Self-Driving Vehicles

Managing multiple machine learning models to enable self-driving vehicles is a challenge. Uber ATG developed a model life cycle for quick iterations, continuous delivery, and dependency management.

Profiles in Coding: Rick Boone, Core Infrastructure, San Francisco

Rick Boone, Strategic Advisor for Uber's Core Infrastructure group, talks about his journey from his work in site reliability to his current role in long-term planning for infrastructure health and scalability.

Tricks of the Trade: Tuning JVM Memory for Large-scale Services

Uber engineers share their learnings on how to tune a Java Virtual Machine so as to avoid long pauses and other issues with garbage collection.

Engineering the Future of Maps at Uber

Maps live at the core of Uber's services, and our engineers use a variety of technologies, from machine learning to natural language processing to metrics, to make sure our maps are as accurate as possible.

Building the Future of Mobility from the Pacific Northwest: Meet the Uber Seattle Tech Team

The Uber Seattle Tech team is responsible for building a diverse range of technologies, from developer tools to our data platform architecture.

Building a Backtesting Service to Measure Model Performance at Uber-scale

We built a backtesting service to better assess financial forecast model error rates, facilitating improved forecast performance and decision making.

Counting Calories: How We Improved the Performance and Developer Experience of UberEats.com

Uber engineers describe rewriting the Uber Eats web app using Fusion.js to make it more performant and increase developer velocity.

Women in Data Science at Uber: Moving the World With Data in 2020—and Beyond

In October 2019, Uber hosted our second annual Moving The World With Data meetup, showcasing some of our most interesting data science challenges in 2019.

Women in Data Science at Uber: Moving the World With Data in 2020—and Beyond

In October 2019, Uber hosted our second annual Moving The World With Data meetup, showcasing some of our most interesting data science challenges in 2019.

Designing a Production-Ready Kappa Architecture for Timely Data Stream Processing

We implemented a Kappa architecture at Uber to effectively backfill streaming data at scale, ensuring accurate data in our platform.

Engineering SQL Support on Apache Pinot at Uber

We engineered full SQL support on Apache Pinot to enable quick analysis and reporting on aggregated data, leading to improved experiences on our platform.

Open Sourcing Manifold, a Visual Debugging Tool for Machine Learning

Introduced in January 2019, Manifold is a visual debugging tool that enables users to quickly identify performance issues in machine learning models.

Uber Visualization Highlights: Displaying City Street Speed Clusters with SpeedsUp

As part of Uber Visualization's all-team hackathon, we built SpeedsUp, a project using machine learning to process average speeds across a city, cluster the results, and overlay them on a street map.

Uber Open Source in 2019: Community Engagement and Contributions

Uber recounts its many engagements with the open source community during 2019, from contributing projects to joining and founding new open source support organizations.

Year in Review: 2019 Highlights from the Uber Engineering Blog

To cap off 2019, the Uber Engineering Blog editors present a selection of popular articles covering a range of topics, from AI to mobile development.

Uber Infrastructure in 2019: Improving Reliability, Driving Customer Satisfaction

In 2019, Uber's Infrastructure team built new systems to enable resource savings, efficiency gains, and greater resilience across our tech stack.

Uber AI in 2019: Advancing Mobility with Artificial Intelligence

In 2019, Uber AI built tools and systems that leverage ML to improve location accuracy and enhance real-time forecasting, among other applications.

Uber AI in 2019: Advancing Mobility with Artificial Intelligence

In 2019, Uber AI built tools and systems that leverage ML to improve location accuracy and enhance real-time forecasting, among other applications.

Generative Teaching Networks: Accelerating Neural Architecture Search by Learning to Generate Synthetic Training Data

Generative Teaching Networks automatically generate training data, learning environments, and curricula to help AI agents rapidly learn.

Uber’s Data Platform in 2019: Transforming Information to Intelligence

In 2019, Uber's Data Platform team leveraged data science to improve the efficiency of our infrastructure, enabling us to compute optimum datastore and hardware usage.

Productionizing Distributed XGBoost to Train Deep Tree Models with Large Data Sets at Uber

We share technical challenges and lessons learned while productionizing and scaling XGBoost to train distributed gradient boosted algorithms at Uber.

Controlling Text Generation with Plug and Play Language Models

Uber AI's Plug and Play Language Model gives NLP practitioners the flexibility to plug simple attribute models into a large, unconditional language model.

Food Discovery with Uber Eats: Using Graph Learning to Power Recommendations

By leveraging graph learning techniques to power our Uber Eats recommendation system, we created a more seamless and individualized eater experience.

Uber Goes to NeurIPS 2019

Uber is presenting 11 papers at NeurIPS 2019, as well as sponsoring workshops including Women in Machine Learning and Black in AI.

RxCentral: Uber’s Open Source Library for Seamless Bluetooth Integrations

Uber introduces RxCentral, an open source library to reliably and repeatedly connect Bluetooth devices using a platform-agnostic, reactive design.

RxCentral: Uber’s Open Source Library for Seamless Bluetooth Integrations

Uber introduces RxCentral, an open source library to reliably and repeatedly connect Bluetooth devices using a platform-agnostic, reactive design.

Announcing the 2020 Uber AI Residency

Uber's 2020 AI Residency will focus on initiatives related to our self-driving car project through Uber Advanced Technology Group (ATG).

Optimizing Observability with Jaeger, M3, and XYS at Uber

Uber’s observability engineers present their work on distributed tracing (Jaeger), sampling (XYS), and metrics processing (M3).

Global Tech in the Great Outdoors: Meet Uber’s Boulder Tech Office

Meet a few of the engineers from Uber's Boulder, Colorado office, working on everything from maps to new mobility to large-scale distributed systems.

Global Tech in the Great Outdoors: Meet Uber’s Boulder Tech Office

Uber’s Colorado tech office, home to engineers, product managers, program managers, and data scientists, combines relaxed living with large-scale impact. 

Uber Visualization Highlights: How Urban Symphony Adds an Audio Dimension to Visualization

As part of Uber Visualization's all-team hackathon, we built Urban Symphony, a visualization that adds an audio component to traffic speed patterns.

Introducing Menu Maker: Uber Eats’ New Menu Management Tool

To simplify the Uber Eats experience for our restaurant-partners, we built Menu Maker, a web-based tool for seamlessly managing menus on the Uber Eats app.

Conducting Better Business with Uber’s Open Source Orchestration Tool, Cadence

Uber engineers describe Cadence, Uber’s open source workflow orchestration tool, its architecture, and its use in a series of informative presentations.

Improving Pickups with Better Location Accuracy

Uber built beacon to improve vehicle location accuracy on our platform, leading to more seamless rider pickup and dropoff experiences.

Taking City Visualization into the Third Dimension with Point Clouds, 3D Tiles, and deck.gl

With deck.gl version 7.3, Uber’s visualization tool now supports rendering geospatial data sets formatted according to the OGC 3D Tiles community standard.

Get to Know Uber ATG at ICCV, CoRL, and IROS 2019

Attending ICCV, CoRL, or IROS 2019? Learn about Uber ATG's recent research in artificial intelligence by checking out our workshops, posters, and keynotes.

IT Engineering: Meet the Team that Keeps Uber Moving

Uber's IT Engineering team builds the tools and systems that help other Uber employees do their jobs. Meet a few of these remarkable behind-the-scenes engineers.

Evolving Michelangelo Model Representation for Flexibility at Scale

To accommodate additional ML use cases, Uber evolved Michelangelo's application of the Apache Spark MLlib library for greater flexibility and extensibility.

Evolving Michelangelo Model Representation for Flexibility at Scale

To accommodate additional ML use cases, Uber evolved Michelangelo's application of the Apache Spark MLlib library for greater flexibility and extensibility.

Building a Better Big Data Architecture: Meet Uber’s Presto Team

Uber has embraced Presto, a high performance, distributed SQL query engine, and joined the Presto Foundation. Meet the Uber engineers who contribute to and use Presto on a daily basis.

Searchable Ground Truth: Querying Uncommon Scenarios in Self-Driving Car Development

When developing Uber's self driving car systems, engineers found a way to identify edge case scenarios amongst terabytes of sensor data representing real-world situations.

On Internships, Career Advice, and Reaching 15B Rides: A Conversation with Uber CTO Thuan Pham

CTO Thuan Pham sat down with former intern, now employee, Sudhanshu Mishra to talk about his early experiences in the technology industry and growing Uber.

Uber Joins LF Presto Foundation to Advance Open Source Analytics

Uber is honored to join the Presto Foundation, a new initiative hosted by the Linux Foundation, to advance the open source data processing community.

Introducing Hypothesis GU Funcs, an Open Source Python Package for Unit Testing

Uber introduces Hypothesis GU Func, a new extension to Hypothesis, as an open source Python package for unit testing.

Gaining Confidence and Improving Android Developer Workflows as a Software Engineering Intern at Uber

Ankit Agrawal reflects on his internship with Uber Engineering, working on the Developer Experience team to build a feature that would highlight code errors in an IDE.

Science at Uber: Improving Transportation with Artificial Intelligence

Uber Chief Scientist Zoubin Ghahramani explains how artificial intelligence went from academia to real-world applications, and how Uber uses it to make transportation better.

Bringing Uber Freight to Chicago: A Conversation with Engineering Manager Tory Schober

Engineering manager Tory Schober talks about creating an Uber Freight engineering team in Chicago, and how that team will benefit from being close to its customer base.

Three Approaches to Scaling Machine Learning with Uber Seattle Engineering

At an April 2019 meetup on ML and AI at Uber Seattle, members of our engineering team discussed three different approaches to enhancing our ML ecosystem.

Science at Uber: Powering Machine Learning at Uber

Logan Jeya, Product Manager, explains how Uber's machine learning platform, Michelangelo, makes it easy to deploy models that enable data-driven decision making.

Introducing LCA: Loss Change Allocation for Neural Network Training

Uber AI Labs proposes Loss Change Allocation (LCA), a new method that provides a rich window into the neural network training process.

Introducing Cyborg, an Open Source iOS Implementation of Android VectorDrawable

We built Cyborg, an open source implementation of VectorDrawable for iOS, to more easily implement designs across our apps.

Best Practices for Unit Testing in React Version 16

Uber ATG Web Platform intern Anat Kleiman shares her advice for testing React version 16 components when altering application logic.

Using GraphQL to Improve Data Hydration in our Customer Care Platform and Beyond

Uber Engineering details how GraphQL integrated into our Customer Care platform, making for more targeted queries and reducing server load.

Science at Uber: Innovating Across Digital and Physical Worlds

Waleed Kadous, Principal Engineer at Uber, enjoys tackling technical challenges that bridge the digital and physical duality of Uber's problem space.

Building the New Uber Freight App as Lists of Modular, Reusable Components

We redesigned the Uber Freight app with RIBs, our open source plugin architecture, to enable quicker feature rollouts and an improved user experience.

Advancing AI: A Conversation with Jeff Clune, Senior Research Manager at Uber

Jeff Clune, Senior Research Manager, discusses his work in AI, journey to Uber, and Presidential Early Career Award for Scientists and Engineers (PECASE).

Science at Uber: Making a Real-world Impact with Data Science

Suzette Puente, Uber Data Science Manager, shares how she applies her graduate work in statistics to forecast traffic patterns and generate better routes.

Less is More: Engineering Data Warehouse Efficiency with Minimalist Design

Data science helps Uber determine which tables in a database should be off-boarded to another source to maximize the efficiency of our data warehouse.

Science at Uber: Applying Artificial Intelligence at Uber

Zoubin Ghahramani, Head of Uber AI, discusses how we use artificial intelligence techniques to make our platform more efficient for users.

Enabling Collaboration through Open Source: Highlights from Uber Open Summit Sofia 2019

At the Uber Open Summit Sofia 2019, we showcased how open source software in AI, site reliability, and other domains are driving the future of engineering.

Migrating Functionality Between Large-scale Production Systems Seamlessly

With zero downtime, Uber's Payments team embarked on a migration that would allow authorization hold logic to be written once and used across products.

Science at Uber: Powering Uber’s Ridesharing Technologies Through Mapping

Dawn Woodard, Director of Data Science, considers travel time prediction one of Uber's most interesting mapping problems.

Science at Uber: Bringing Research to the Roads

Uber Principal Engineer Waleed Kadous discusses how we assess technologies our engineering teams can leverage to improve the reliability and performance of our platform.

Introducing Uber Poet, an Open Source Mock App Generator for Determining Faster Swift Builds

Uber Poet, an open source mock application generator, helped us make our overall Swift build times faster for iOS development.

Building a More Seamless Web Booking Flow for Uber

We redesigned Uber's web-based booking flow for riders who prefer a browser over the app, simplifying pickup options and speeding up interactivity.

Showcasing the Technologies and Teams from Uber’s European Engineering Sites

During our 2019 Uber European Technology Showcase, teams across the company discussed how we build products that drive safe and reliable transportation.

Ludwig v0.2 Adds New Features and Other Improvements to its Deep Learning Toolbox

Ludwig version 0.2 integrates with Comet.ml, adds a new serving funtionality, and incorporates the BERT text encoder, among other new features.

Science at Uber: Building a Data Science Platform at Uber

Uber Director of Data Science Franziska Bell discusses how we created data science platforms at Uber, letting employees of all technical skills perform forecasts and analyze data.

Introducing EvoGrad: A Lightweight Library for Gradient-Based Evolution

Uber AI Labs releases EvoGrad, a library for catalyzing gradient-based evolution research, and Evolvability ES, a new meta-learning algorithm.

Making Apache Spark Effortless for All of Uber

Uber engineers created uSCS, a Spark-as-a-Service solution that helps manage Apache Spark jobs throughout large organizations.

Introducing the Plato Research Dialogue System: A Flexible Conversational AI Platform

The Plato Research Dialogue System enables experts and non-experts alike to quickly build, train, and deploy conversational AI agents.

MoneyCon ’19: Uber Hosts its First FinTech Engineering Conference

Uber's MoneyCon brought together industry leaders to discuss the latest technologies and key learnings in the payments and finance engineering space.

Visualizing City Cores with H3, Uber’s Open Source Geospatial Indexing System

In a selection of presentations delivered at a June 2019 Uber meetup, we discuss how to use H3, our open source hexagonal indexing system.

Solving for Urban Air Travel: A Q&A with François Sillion, Director of Uber ATCP

As head of Uber's Advanced Technologies Center in Paris, Francois Sillion and his team are responsible for supporting the R&D behind Uber Air.

Gaining Insights in a Simulated Marketplace with Machine Learning at Uber

Uber's Marketplace simulation platform leverages ML to rapidly prototype and test new product features and hypotheses in a risk-free environment.

Using Causal Inference to Improve the Uber User Experience

Uber Labs leverages causal inference, a statistical method for better understanding the cause of experiment results, to improve our products and operations.

No Coding Required: Training Models with Ludwig, Uber’s Open Source Deep Learning Toolbox

Uber AI's Piero Molino discusses Ludwig's origin story, common use cases, and how others can get started with this powerful deep learning framework.

Setting the Pace: A Q&A with Jennifer Anderson, Senior Director of Engineering at Uber

Jennifer Anderson, a veteran of Silicon Valley technology companies, leads Uber's Product Platform organization, which hosts our core services. In this interview, she describes her organization and the lessons she has learned.

Learnings in Web Development: Design Patterns, Elm, and Progressive Enhancement

Uber's Destination:Web meetup series gives great insight about the most current web building tools and techniques. These three videos from Uber presenters offer tips on a mysterious design pattern, the Elm language, and Progressive Enhancement.

Power On: Accelerating Uber’s Self-Driving Vehicle Development with Data

Uber ATG develops powerful data processing and analysis systems that help make interactions between self-driving vehicles and pedestrians safe.

Second Uber Science Symposium: Showcasing Developments in Programming Systems and Tools

On May 3, 2019, Uber’s Programming Systems Team hosted the Programming Systems and Tools Track of the company’s Second Uber Science Symposium.

Activity/Service as a Dependency: Rethinking Android Architecture for the Uber Driver App

Architecting the Uber driver app for Android, which needs to run for extended periods of time in the background, involved a unique idea where Activities and Services were not included in the structural foundations.

Uber Open Source: Catching Up with Felix Cheung, Data Platform Engineering Manager

Uber Engineering Manager and open source software community member Felix Cheung talks about his work with the Apache Software Foundation, open source at Uber, and XGBoost, a machine learning library for optimized distributed gradient boosting.

Second Uber Science Symposium: Exploring Advances in Behavioral Science

The Behavioral Science Track of the Second Uber Science Symposium featured a full day of presentations delivered by leading researchers in the field.

Visualizing Traffic Safety with Uber Movement Data and Kepler.gl

Learn how to use Kepler.gl for data visualization through our tutorial, where we show how easy it is to load multiple datasets into Kepler.gl to visualize traffic safety in Manhattan.

Employing QUIC Protocol to Optimize Uber’s App Performance

Implementing QUIC protocol against TCP over cellular networks on our apps led to a reduction of 10-30 percent in tail-end latencies for HTTP traffic.

Uber Engineering Celebrates Take Your Kids to Work Day

During Uber's Take Your Kids to Work Day celebrations, parents from across the company gave their children a taste of the working world.

Uber Joins Urban Computing Foundation, Contributes Kepler.gl as Organization’s First Hosted Project

In addition to joining the Urban Computing Foundation, Uber is contributing Kepler.gl, an open source geospatial analysis tool, as the organization's first hosted project.

Deconstructing Lottery Tickets: Zeros, Signs, and the Supermask

Uber builds upon the Lottery Ticket Hypothesis by proposing explanations behind these mechanisms and deriving a surprising by-product: the Supermask.

Introducing the Uber Research Publications Site

Uber's Chief Scientist announces the launch of the Uber Research Publications Site, a portal for showcasing our contributions to the research community.

Measuring Kotlin Build Performance at Uber

To determine if it made sense to adopt Kotlin for our Android monorepo, Uber's Mobile Engineering team measured Kotlin build performance at scale across a variety of project structures.

Improving Uber’s Mapping Accuracy with CatchME

CatchMapError (CatchMe) is a system that automatically catches errors in map data with anonymized GPS traces from the driver app.

Consistent Data Partitioning through Global Indexing for Large Apache Hadoop Tables at Uber

Performing updates of individual records in Uber's over 100 petabyte Apache Hadoop data lake required building Global Index, a component that manages data bookkeeping and lookups at scale.

Uber Submits Hudi, an Open Source Big Data Library, to The Apache Software Foundation

We submitted Hudi to the Apache Incubator to ensure the long-term growth and sustainability of the project under The Apache Software Foundation.

Optimizing M3: How Uber Halved Our Metrics Ingestion Latency by (Briefly) Forking the Go Compiler

Noticing increased latency in our metrics platform, Uber engineers track down a bug related to stack growth in a goroutine, resulting in a fix elevated to the Go open source GitHub repository.

Introducing Base Web, Uber’s New Design System for Building Websites in React

Base Web is a React component library which implements the Base design language to act as a device-agnostic foundation for easily creating web applications.

Learning on the Go: Engineering Efficiency with Concise Documentation

Uber Technical Writer Shannon Brown offers three tips for creating concise, meaningful documentation.

Uber Open Source: Catching Up with Celina Ward, M3 Observability Engineer

Celina Ward discusses her journey to engineering, what it was like to present at Kubecon 2018, and what’s next for M3, Uber's open source metrics platform.

Bridging the Gap from Sofia to San Francisco: A Conversation with Engineering Manager Marin Dimitrov

Uber Engineering Manager Marin Dimitrov shares his best practices for motivating an engineering team, keeping connected when your headquarters office is over 6,000 miles and 10 hours away, and leveraging open source software.

Scaling Mobile Device Management for macOS with Chef at Uber

Uber's IT Engineering team scaled mobile device management on macOS by leveraging open source tools and custom API-driven Chef cookbooks.

Build a ‘Hello World!’ Application in 5 Minutes with Fusion.js

In this short tutorial, we show you how to build a Hello World! application using Fusion.js, an open source universal web framework suitable for building interactive web applications.

Improving the User Experience with Uber’s Customer Obsession Ticket Routing Workflow and Orchestration Engine

Uber adopted workflow orchestration and Cadence, our open source orchestration engine, to better handle customer support ticket routing at scale.

Building a Real-time Earnings Tracker into Uber’s New Driver App

What began as a means of showing Uber's driver-partners their real-time earnings quickly became an extensible means of communicating not just earnings, but also incentives and other useful information within our new driver app.

Uber Case Study: Choosing the Right HDFS File Format for Your Apache Spark Jobs

Uber's Maps Collection and Reporting (MapCARs) team shares best practices when choosing which HDFS file formats are optimal for use with Apache Spark.

Solving Big Data Challenges with Data Science at Uber

How engineers and data scientists at Uber came together to come up with a means of partially replicating Vertica clusters to better scale our data volume.

Accessible Machine Learning through Data Workflow Management

Uber engineers offer two common use cases showing how we orchestrate machine learning model training in our data workflow engine.

Announcing the Uber Open Summit Sofia 2019

The next Uber Open Summit, where we present our latest and most impactful open source projects, will be in Sofia, Bulgaria on April 20, 2019.

DBEvents: A Standardized Framework for Efficiently Ingesting Data into Uber’s Apache Hadoop Data Lake

Uber engineers discuss the development of DBEvents, a change data capture system designed for high data quality and freshness that is capable of operating on a global scale.

Data Science at Scale: A Conversation with Uber’s Fran Bell

We spoke to Data Science Director Fran Bell about machine learning at Uber and what she finds most challenging—and rewarding—about her work.

Mitigating Risk in a Three-Sided Marketplace: A Conversation with Trupti Natu and Neel Mouleeswaran on the Uber Eats Risk Team

We sat down with a risk strategy manager and a risk engineer to discuss how they build solutions to minimize risk in the Uber Eats three-sided marketplace.

Open Sourcing Peloton, Uber’s Unified Resource Scheduler

First introduced by Uber in November 2018, Peloton manages resources across large-scale, distinct workloads, combining separate compute clusters.

Using Machine Learning to Ensure the Capacity Safety of Individual Microservices

Uber leveraged machine learning to design our capacity safety forecasting tooling with a special emphasis on calculating a quality of reliability score.

Introducing Kraken, an Open Source Peer-to-Peer Docker Registry

Developed by Uber, Kraken is an open source peer-to-peer Docker registry capable of distributing terabytes of data in seconds.

The Uber Engineering Internship Experience: European Edition

Engineering interns from Uber's European offices talk about their experiences, including the projects they worked on, the people they worked with, and the social activities they engaged in.

Architecting a Safe, Scalable, and Server-Driven Platform for Driver Preferences with RIBs

Our driver app's new server-driven preferences section enables driver-partners to customize their experiences to make the app better fit into their lives.

Managing Uber’s Data Workflows at Scale

In this article, we discuss Uber's journey toward a unified, multi-tenant, and scalable data workflow management system.

Profiles in Coding: Tatiana Romanova, Uber Payments Platform, Amsterdam

Uber SRE Tatiana Romanova discusses her computer science background, journey to Uber, and work maintaining our Payments Platform.

Creating Custom Plugins with Fusion.js, Uber’s Open Source Web Framework

In addition to providing official plugins, Fusion.js enables developers to build and integrate their own plugins by leveraging dependency injection.

Horovod Adds Support for PySpark and Apache MXNet and Additional Features for Faster Training

Horovod adds support for more frameworks in the latest release and introduces new features to improve versatility and productivity.

Pyro Accepted by the LF Deep Learning Foundation as a Hosted Project

Created by Uber in 2017, Pyro was voted in by the Linux Foundation Deep Learning Technical Board as the latest incubation project to join its foundation.

Uber Open Source: Catching Up with Fritz Obermeyer and Noah Goodman from the Pyro Team

We spoke with Fritz Obermeyer and Noah Goodman, Pyro project co-leads, about how the software plays into our commitment to growing open source at Uber.

Meet Uber Sofia’s Women in Tech

Uber Sofia is also home to a vibrant community of women technologists, from software engineers and data analysts to designers and program managers.

Introducing AVS, an Open Standard for Autonomous Vehicle Visualization from Uber

Uber announces the release of the Autonomous Visualization System (AVS) as an open source project. AVS is a standard for creating a visual environment based on sensor data from autonomous vehicles, with playback available in multiple formats, including the web and video.

Modeling Censored Time-to-Event Data Using Pyro, an Open Source Probabilistic Programming Language

Censored time-to-event data is critical to the proper modeling and understanding of customer engagement on the Uber platform.

Engineering Uber Beacon: Matching Riders and Drivers in 24-bit RGB Colors

Uber explains how we built the connection between the driver app and the Uber Beacon device, which displays a color remotely selected through a rider's app.

First Uber Science Symposium: Discussing the Next Generation of RL, NLP, ConvAI, and DL

The Uber Science Symposium featured talks from members of the broader scientific community about the the latest innovations in RL, NLP, and other fields.

Introducing Ludwig, a Code-Free Deep Learning Toolbox

Uber AI developed Ludwig, a code-free deep learning toolbox, to make deep learning more accessible to non-experts and enable faster model iteration cycles.

Why Financial Planning is Exciting… At Least for a Data Scientist

Data Scientist Marianne Borzic Ducournau discusses the models she uses to predict important business metrics at Uber.

Building Locally, Scaling Globally: Meet the Tech Team at Uber New York City

Uber’s new office in midtown Manhattan is home to more than a dozen teams, hundreds of employees (and growing), and a wide variety of engineering roles.

Increasing Representation at Uber through The Hidden Genius Project

In its first year, the Career Prep Program, a collaboration between Uber and The Hidden Genius Project, demonstrated how technology-focused companies can embrace and reinforce values of diversity and inclusion among engineers, while having a positive impact in the community.

Introducing AresDB: Uber’s GPU-Powered Open Source, Real-time Analytics Engine

AresDB, Uber's open source real-time analytics engine, leverages GPUs to enable real-time computation and data processing in parallel.

How Uber Leverages Applied Behavioral Science at Scale

Uber Labs utilizes insights and methodologies from behavioral science to build products that are intuitive and enjoyable for users on our platform.

Expanding Access: Engineering Uber Lite

Many people around the world use Android phones based on hardware developed in 2015 and earlier. Uber engineers explain how they developed a lightweight rider app to serve this global audience.

Aarhus Engineering Internship: Building Aggregation Support for YQL, Uber’s Graph Query Language for Grail

Uber intern Lau Skorstengaard shares his experience working on YQL, the graph query language for our in-house infrastructure state aggregation platform.

Manifold: A Model-Agnostic Visual Debugging Tool for Machine Learning at Uber

Uber built Manifold, a model-agnostic visualization tool for ML performance diagnosis and model debugging, to optimize our model iteration process.

Building a Scalable and Reliable Map Interface for Drivers

How Uber engineers designed the map interface for our new driver app, making it focus on the most relevant information for users.

Creating a Zoo of Atari-Playing Agents to Catalyze the Understanding of Deep Reinforcement Learning

Uber AI Labs releases Atari Model Zoo, an open source repository of both trained Atari Learning Environment agents and tools to better understand them.

POET: Endlessly Generating Increasingly Complex and Diverse Learning Environments and their Solutions through the Paired Open-Ended Trailblazer

Uber AI Labs introduces the Paired Open-Ended Trailblazer (POET), an algorithm that leverages open-endedness to push the bounds of machine learning.

From Self-Driving Cars to Optimizing Claims Efficiency: My Unconventional Journey to Insurance Engineering

Engineering manager Lili Kan discusses the challenges—and opportunities—of building insurance products for the Uber platform.

From Self-Driving Cars to Optimizing Claims Efficiency: My Unconventional Journey to Insurance Engineering

Engineering manager Lili Kan discusses the challenges—and opportunities—of building insurance products for the Uber platform.

How to Ship an App Rewrite Without Risking Your Entire Business

Uber engineers outline how they shipped two binaries in one Android app, enabling a safe rollout of our new driver app while maintaining support for the previous version.

How to Ship an App Rewrite Without Risking Your Entire Business

Uber engineers outline how they shipped two binaries in one Android app, enabling a safe rollout of our new driver app while maintaining support for the previous version.

Women in Data Science at Uber: Moving the World With Data

During an October 2018 meetup, members of our Women in Statistics, Data, Optimization, and Machine Learning group (WiSDOM) presented on their work at Uber.

Women in Data Science at Uber: Moving the World With Data

During an October 2018 meetup, members of our Women in Statistics, Data, Optimization, and Machine Learning group (WiSDOM) presented on their work at Uber.

Profiles in Coding: Sylvain Francois, Uber Freight

For Uber's Profiles in Coding series, we interview Uber Freight engineer Sylvain Francois to find out the nature of his daily work and his best tips for coders.

Profiles in Coding: Sylvain Francois, Uber Freight

For Uber's Profiles in Coding series, we interview Uber Freight engineer Sylvain Francois to find out the nature of his daily work and his best tips for coders.

How Uber Beacon Helps Improve Safety for Riders and Drivers

The Uber Beacon leverages visual signaling, an accelerometer, and a gyroscope to improve the accuracy of in-app safety features.

How Uber Beacon Helps Improve Safety for Riders and Drivers

The Uber Beacon leverages visual signaling, an accelerometer, and a gyroscope to improve the accuracy of in-app safety features.

Year in Review: 2018 Highlights from the Uber Engineering Blog

Our editors spotlight some of the year's most popular articles, from an overview of our Big Data platform to a first-person account of an engineer's immigrant journey.

Year in Review: 2018 Highlights from the Uber Engineering Blog

Our editors spotlight some of the year's most popular articles, from an overview of our Big Data platform to a first-person account of an engineer's immigrant journey.

Year in Review: 2018 Highlights from Uber Open Source

Brian Hsieh, Uber's Open Source program lead, reflects on open source accomplishments, project launches, and collaborations in 2018.

Year in Review: 2018 Highlights from Uber Open Source

Brian Hsieh, Uber Open Source Program Lead, reflects on his team’s accomplishments, project launches, and collaborations in 2018.

Four Ways Uber Visualization Made an Impact in 2018

Uber's Head of Urban Computing & Visualization reflects on his team's work visualizing data to better understand urban mobility in 2018—and beyond.

Four Ways Uber Visualization Made an Impact in 2018

Uber's Head of Urban Computing & Visualization reflects on his team's work visualizing data to better understand urban mobility in 2018—and beyond.

Interning at Uber: Building the Uber Eats Menu Scheduler

Computer science student Jonathan Levi recounts his experience as an intern at Uber during the Summer, 2018, including building a useful project for the Uber Eats team.

Interning at Uber: Building the Uber Eats Menu Scheduler

Computer science student Jonathan Levi recounts his experience as an intern at Uber during the Summer, 2018, including building a useful project for the Uber Eats team.

Horovod Joins the LF Deep Learning Foundation as its Newest Project

Horovod, Uber's distributed training framework, joins the LF Deep Learning Foundation to help advance open source innovation in AI, ML, and deep learning.

Horovod Joins the LF Deep Learning Foundation as its Newest Project

Horovod, Uber's distributed training framework, joins the LF Deep Learning Foundation to help advance open source innovation in AI, ML, and deep learning.

Open Source at Uber: Meet Alex Sergeev, Horovod Project Lead

We spoke with Alex Sergeev, Horovod project lead, to discuss his path to open source and what excites him about the future of distributed deep learning.

Open Source at Uber: Meet Alex Sergeev, Horovod Project Lead

We spoke with Alex Sergeev, Horovod project lead, to discuss his path to open source and what excites him about the future of distributed deep learning.

Scaling Cash Payments in Uber Eats

Uber's new driver app leverages its offline mode along with a cash-drop system organized around restaurants so that Uber Eats customers can pay for deliveries with cash.

Scaling Cash Payments in Uber Eats

Uber's new driver app leverages its offline mode along with a cash-drop system organized around restaurants so that Uber Eats customers can pay for deliveries with cash.

Faster Neural Networks Straight from JPEG

Uber AI Labs introduces a method for making neural networks that process images faster and more accurately by leveraging JPEG representations.

Faster Neural Networks Straight from JPEG

Uber AI Labs introduces a method for making neural networks that process images faster and more accurately by leveraging JPEG representations.

The Billion Data Point Challenge: Building a Query Engine for High Cardinality Time Series Data

Part of Uber's open source M3 metrics system, our query engine can support real-time, large-scale computation and multiple query languages.

The Billion Data Point Challenge: Building a Query Engine for High Cardinality Time Series Data

Part of Uber's open source M3 metrics system, our query engine can support real-time, large-scale computation and multiple query languages.

Introducing Makisu: Uber’s Fast, Reliable Docker Image Builder for Apache Mesos and Kubernetes

Uber built Makisu, our open source Docker image builder, to enable the quick, reliable generation of Dockerfiles in Mesos and Kubernetes ecosystems.

Introducing Makisu: Uber’s Fast, Reliable Docker Image Builder for Apache Mesos and Kubernetes

Uber built Makisu, our open source Docker image builder, to enable the quick, reliable generation of Dockerfiles in Mesos and Kubernetes ecosystems.

Uber Joins the Linux Foundation’s OpenChain Project as a Platinum Member

As part of the OpenChain Project’s governing board, Uber will help create best practices and define standards for open source software compliance.

Uber Joins the Linux Foundation’s OpenChain Project as a Platinum Member

As part of the OpenChain Project’s governing board, Uber will help create best practices and define standards for open source software compliance.

Engineering Uber’s Next-Gen Payments Platform

During a September 2018 meetup, Uber's Payments Platform team discusses how this technology supports the company's growth across our global markets.

Engineering Uber’s Next-Gen Payments Platform

During a September 2018 meetup, Uber's Payments Platform team discusses how this technology supports the company's growth across our global markets.