`
`EXHIBIT M1
`
`
` This claim chart is meant to be illustrative for
`
`purposes of meeting Plaintiff's pleading obligations
`and should not be construed as binding or limiting.
`
`
`
`
`
`
`
`Case 2:23-cv-02165-WSH Document 1-14 Filed 12/22/23 Page 2 of 250
`
`Ameranth
`
`U.S. Patent No. 11,842,415
`
`Claim Chart
`
`improved and
`1. An
`intelligent web server
`computer with multi-
`modes of contact, multi-
`communications
`protocols, multi-user
`and parallel operational
`capabilities for use in a
`hospitality
`market
`comprising:
`
`DoorDash develops, tests, integrates, uses, operates, manages, and maintains a
`‘parallel operational’ based cluster set of interconnected and improved “Intelligent
`Web Servers with multi modes of contact”, utilizing Machine Learning (ML) with
`parallel operational capabilities for multi-users, via multi-communications protocols
`while integrating with its “central data platform” (i.e. “master database”). This system
`meets all the limitations of the ‘415 claims, as is detailed below, to complete remotely
`initiated hospitality food and drink delivery and pick-up tasks triggered by and from
`consumers, produced by merchants (restaurants, etc.), and delivered by Dashers. The
`DoorDash Flywheel diagram, shown below, makes evident that the DoorDash
`operates in accordance with its overall series of linked services and via its “360 degree
`picture” central (“Flywheel") and technology platform framework:
`
`
`
`This was confirmed on August 17, 2022, by DoorDash’s Vice President of Analytics
`and Data Science Jessica Lachs in an interview on “Leveraging Data to Delight
`Customers Despite a Challenging Supply Chain” (See Exh. #98) in which she states:
`
`“And so for us, it’s really about collecting as much information as we can about
`all sides of the marketplace, bringing all of that data together into a central data
`platform, where all of that data is accessible no matter the source. Whether it is
`coming from our production systems, transactional data, whether it is event data
`in our apps, whether that’s the consumer app, the dasher app, the merchant app…
`whether it is coming from our CRM systems. All of that data needs to come in to
`one central place so that we can tie it together and use the insights together to
`create a 360 degree picture of what’s happening on our platform and off our
`platform so that we can use that information not just to provide accurate menus
`
`1
`
`
`
`
`
`
`
`Case 2:23-cv-02165-WSH Document 1-14 Filed 12/22/23 Page 3 of 250
`
`and inventory for consumers but also so we can send the right email
`communications to consumers, to dashers, so that we really have a full picture of
`what’s happening and can use that for personalization and to help all three sides
`of our marketplace really optimize that they are at their peak efficiency.”
`
`“So, for us, we want data to be easily accessible to all the different teams that
`need access to it. Analytics, being one of the largest customers of data at
`DoorDash, of course, but the way we think about our data models is really about
`increasing accessibility and consistency to that data. So, having all of our data in
`one central place and making sure that it is high in performance and so like query
`speeds are fast and that data models are thoughtful, so that it makes it a lot easier
`for data scientists, analysts, operators, product managers to be able to query the
`data that is needed and use the data in our production, in our production systems
`as well. So, we try to be thoughtful about how we structure our data models and
`how we ensure that all of the different production systems tie together into that
`central, as you mentioned, that central data lake.”
`
`The DoorDash Life Cycle of a Delivery Order
`
`In the blog article from the DoorDash Engineering team titled “Next-Generation
`Optimization for Dasher Dispatch at DoorDash” (see Exh. 84) they state that the
`DoorDash platform “…powers an on-demand marketplace involving real-time order
`demand and dasher [(drivers)] supply. Consumers ask for goods to be delivered from
`a merchant to their location. To fulfill this demand, [DoorDash] present dashers with
`delivery routes, where they move between picking up orders at merchants and
`delivering them to consumers”, followed by the diagram below:
`
`Moreover, they assert the intelligence of their platform “Our dispatch system seeks
`high dasher efficiency and fulfillment quality by considering driving distance, time
`waiting for an order to be ready, delivery times as seen by the consumer, and more.
`Given incomplete information about the world, the system generates many
`predictions, such as when we expect an order to be ready for pickup, to model the
`real-world scenarios. With this data, the dispatch system generates future states for
`every possible matching and decides the best action to take, given our objectives of
`efficiency and quality.” See also Note 1 and Note 2 below.
`
`
`
`
`
`2
`
`
`
`Case 2:23-cv-02165-WSH Document 1-14 Filed 12/22/23 Page 4 of 250
`
`NOTE 1: To the extent, if any that DoorDash contends that it does not infringe, one
`or more of the ‘415 claim elements, they infringe under the Doctrine of Equivalents
`(DOE).
`
`NOTE 2: One or more of the 149 exhibits shown below, are incorporated into the
`support for their infringement of each of the elements the ‘415 claim elements.
`
`How DoorDash Work for Restaurants
`
`In the DoorDash Blog article “How Does DoorDash Work for Restaurants?” (See
`Exh. 116), DoorDash states:
`
` “Restaurants can grow online with DoorDash by driving more sales on the app
`and through their own website, using Delivery, Pickup, and DashPass to unlock
`the active (and hungry) customer base.”
`
`Regarding how customers place DoorDash Orders, the article states:
`
`“Restaurants can grow online with DoorDash by driving more sales on the app
`and through their own website, using Delivery, Pickup, and DashPass to unlock
`the active (and hungry) customer base.
`
`When customers are ready to place an order on Marketplace, they browse
`restaurants on the DoorDash app or website. Customers can search for their
`favorite establishments, or filter restaurants by cuisine, location, promotions and
`more. They enjoy the ease and convenience of browsing thousands of restaurants
`in a single app, as well as the ability to track orders and get restaurant-quality
`food anytime, anywhere.
`
`Customers can also place orders through Storefront, an online ordering system
`that gives restaurants direct, commission-free orders through their website,
`social media, and Google Search & Maps.
`
`Once the customer chooses a restaurant, they place their order, pay for it on the
`app or online, and receive an estimated delivery time. That's when restaurants
`receive the order via their chosen order protocol.
`
`Regarding how restaurants receive DoorDash Orders, the article states:
`
`“The order protocol is the way that restaurants receive orders from DoorDash.
`Restaurants can choose to receive orders on the device of their choice to maximize
`their off-premise efficiency. Storefront orders are processed in the same way as
`Marketplace orders. Restaurants have two options for their DoorDash order
`protocol.
`
`Option 1: Use the POS integration
`
`Maximize efficiency by integrating DoorDash with your point of sale (POS)
`system or aggregator. DoorDash integrates with leading POS and technology
`systems, including Square, Toast, Deliverect, ItsaCheckmate, Redcat and many
`more.
`
`This allows you to receive DoorDash orders directly to your POS system and then
`straight to your kitchen, which reduces the risk of human error. DoorDash also
`has an open API which enables partners to build integrations to manage their
`menu, store, and order data.
`
`3
`
`
`
`
`
`Case 2:23-cv-02165-WSH Document 1-14 Filed 12/22/23 Page 5 of 250
`
`Option 2: Use a tablet
`
`You can download the DoorDash Order Manager app, our all-in-one tool for
`receiving, organizing, and tracking pickup and delivery orders. DoorDash can
`also provide a tablet for you for a small weekly fee. Just order it by contacting
`support or choosing the option when signing up for DoorDash.
`
`
`
`With the Order Manager app, restaurant operators can adjust prices and menu
`items in real time, including deactivating (and reactivating) specific items that
`are out of stock. The Order Manager app also helps restaurant managers
`coordinate with Dashers, prepare for large scheduled orders, pause orders when
`it gets too busy, and contact both the customer and DoorDash support.
`
`When a customer places a DoorDash order, you will receive a notification on the
`Order Manager app allowing you to quickly and efficiently process orders. Just
`be sure your tablet volume is on loud and the device is placed somewhere that is
`easily accessible by staff.”
`
`The article also discusses using the Business Manager App for iPhone or Android:
`
`Bonus: Business Manager App
`
`“Download the Business Manager App on the App Store or Google Play Store to
`manage your restaurant on the go. The Business Manager app makes it easy to
`track orders and review performance, all from your phone. Monitor a Dasher's
`location, access 24/7 support, mark items out of stock, update store hours, get
`analytics, and more from the app.”
`
`In the blog article by the DoorDash Engineering team title “Transforming MLOps at
`DoorDash with Machine Learning Workbench”, states how DoorDash has developed
`an internal Machine Learning (ML) Workbench to enhance data operations and
`support their data scientists, analysts, and AI/ML engineers. The importance of ML
`at DoorDash is emphasized, given its applications across the platform's ecosystem
`involving customers, Dashers, and merchants. The ML Workbench serves as a
`centralized hub for tasks in the machine learning lifecycle, including building,
`training, tuning, and deploying machine learning models. (See Exh. 121)
`
`DoorDash's ML Workbench streamlines the machine learning process by providing a
`space for data collection, organization, and use in ML algorithms. It was designed
`with user-centered principles, aiming to create a best-in-class internal tool that is
`functional, usable, aesthetically pleasing, and integrates well with DoorDash's
`internal tools ecosystem. The development strategy was iterative, focusing on
`understanding user pain points, designing solutions, running user tests, and
`optimizing for better velocity and productivity.
`
`Key components of the ML Workbench include front-end UI (Portal), Admin
`(Middleware), and Backend + 3rd Party Services. Through user research and
`interviews, DoorDash categorized users into admins, end users, and operators,
`tailoring the Workbench's features to their needs. Features such as model viewing,
`testing predictions, and model performance monitoring were added to streamline
`daily workflows and accelerate model development velocity.
`
`
`
`4
`
`
`
`Case 2:23-cv-02165-WSH Document 1-14 Filed 12/22/23 Page 6 of 250
`
`
`
`The implementation of the ML Workbench has led to significant improvements in the
`efficiency and user experience of DoorDash's engineering and data science teams.
`The tool facilitated better observability of features and models, and the future vision
`includes diversifying adoption, improving feature and model observability, and
`continuing a user-centric development approach.
`
`This ML Workbench and its capabilities align well with Claim 1 of the patent, as it is
`an embodiment of an interconnected, intelligent web server network with multi-
`modes of contact, multi-communications protocols, and multi-user and parallel
`operational capabilities. The master database's role within this framework is also
`showcased, where it integrates with the network of web servers and is accessible via
`a database API, which intelligently learns, updates, and stores data. The Workbench's
`integration with various ML lifecycle stages and its emphasis on efficiency and
`reliability reflect the innovations described in Claim 1, particularly in the context of
`improving network efficiency and reliability.
`
`The accused instrumentality meets this limitation under the doctrine of equivalents
`because the accused instrumentality performs substantially the same function, in
`substantially the same way to achieve substantially the same result. For example,
`DoorDash operates a network of interconnected "Intelligent Web Servers with multi
`modes of contact" that utilize Machine Learning (ML) for parallel operational
`capabilities, serving multiple users through various communication protocols while
`integrating with a central data platform, also known as the "master database." This
`system effectively meets the core elements of the claim preamble, enabling DoorDash
`to remotely initiate and complete hospitality food and drink delivery and pick-up
`tasks, all triggered by consumers, facilitated by merchants (such as restaurants), and
`executed by Dashers. The interconnectedness of these web servers, as depicted in the
`DoorDash Flywheel diagram, mirrors the multi-user and parallel operational
`capabilities described in the claim preamble.
`
`
`
`See Exh. 1 - 149
`
`
`
`at least one said web
`server computer which
`
`As stated above, as to the ‘at least one said web server’, and confirmed below,
`DoorDash develops, tests, integrates, uses, operates, manages, and maintains a
`
`5
`
`
`
`
`
`Case 2:23-cv-02165-WSH Document 1-14 Filed 12/22/23 Page 7 of 250
`
`accessed,
`be
`can
`controlled and provide
`results, statistics and/or
`reports
`to a system
`administrator via a web
`based interface;
`
`“distributed computing” platform of clustered set of interconnected and vastly
`improved “Intelligent Web Servers with multi modes of contact”. DoorDash uses a
`combination of web server hardware, software, and networking services to create a
`very powerful and effective online web-based hospitality system, as confirmed
`below.
`
`The DoorDash web server system includes a website, mobile website, APIs, mobile
`apps (iOS and Android), and backend-for-frontend (BFF) architecture and
`functionality. Their interconnected web servers, as is shown herein, is a DoorDash
`engineered custom developed set of interconnected web servers while including
`several well-known and widely used web server-based technologies.
`
`A webserver serves content (images, text, menu, video, audio, video stream, etc.) over
`the internet (or network) to a calling device (client) that runs on computer hardware.
`There can be one or more calling clients at any given moment. The computer
`hardware that the webserver runs on can be any device with a network connection
`(laptop, server computer, mobile device, etc.).
`
`To serve content, a webserver listens on a network port (virtual point where network
`connections start and end) for a request from a client (browser, mobile app, webapp,
`desktop app, etc.) sent via a networking communication protocol (i.e., HTTP or
`HTTPS). The webserver interprets and processes that request and returns a response
`to the client with the resources requested (text, images, menus, code, etc.). Depending
`on the scale of the webserver running web application(s), for example the DoorDash
`system, more powerful linked computer servers or sets/clusters of servers will be used
`to run a bigger system.
`
`Each web server has an IP address associated with it that allows it to communicate
`with other computers over the internet. When a user types in a name of a website in
`the browser, such as DoorDash.com, the Domain Name System (DNS) finds the
`correct IP Address of that domain name and directs the user accordingly (see Exh.
`83). Using the “ping” command from any Windows or MacOS PC on DoorDash.com
`returns the IP address of 104.18.29.209, as screen in this screenshot:
`
`
`
`6
`
`
`
`Case 2:23-cv-02165-WSH Document 1-14 Filed 12/22/23 Page 8 of 250
`
`
`
`In the blog article “Improving Web Page Performance at DoorDash Through Server-
`Side Rendering with Next.JS” (see Exh. 1) by the DoorDash Engineering Team, they
`affirm multiple facts regarding the DoorDash system including the use of a webserver
`and how it works. Specifically, they state that that they needed to upgrade the user
`experience for desktop and mobile and employ Google’s web metrics as a benchmark
`for creating a faster web service. Furthermore, they state that they use Next.js,
`Express.js, Node.js as part of their web server system, technologies which are very
`popular today with developers and are in fact web server (backend) technologies.
`Lastly, and more importantly, they state that their system needed more “flexibility”
`from the web server hosting and therefore they decided to build and implement their
`own custom web server using next.js and express.js. The article states the following:
`
`“The DoorDash app was running on a client-side system prone to loading issues,
`poor SEO, and other issues. By moving to server-side rendering, we hoped that
`we could upgrade a number of key elements, including:
`
`Enhancing the user experience: We wanted to improve the user experience by
`shortening page-load times. This aligns with the recent introduction of Google’s
`web metrics that favor fast, lightweight pages on modest mobile devices. These
`metrics have significant influence on the page rank assigned by Google.
`
`Enabling Bundle Size Optimization: Our existing client-side rendered single-page
`app (CSR, SPA) was becoming difficult to optimize because the size of the
`JavaScript and other resource bundles had become bloated.
`
`
`
`7
`
`
`
`Case 2:23-cv-02165-WSH Document 1-14 Filed 12/22/23 Page 9 of 250
`
`Improving SEO: We set out to deliver optimal SEO metadata using server-side
`rendered content. Whenever possible, it is better to deliver fully formed web
`content to search engines rather than waiting for client-side JavaScript to render
`the content. One approach: Move API calls from the client browser (north-south)
`to the server-side (east-west), where performance typically is better than on a
`user’s device.”
`
`“Many engineers at DoorDash are huge fans of the Next.js team and Vercel.
`Vercel’s infrastructure was built for Next.js, providing both an amazing developer
`experience and a hosting infrastructure that make working with Next.js easy and
`maximally optimized.”
`
`“At DoorDash, however, we needed a little more flexibility and customization
`than Vercel could offer when it comes to how we deploy, build, and host our apps.
`We opted instead for the custom-server approach to serving pages via Next.js
`because it provided us more flexibility in how we hosted our app within our
`existing Kubernetes infrastructure.”
`
`“Our custom server is built with Express.js and leverages our in-house
`JavaScript server toolkit, which provides out-of-the-box functionality like logging
`and metrics collection.”
`
`“Before rolling out our new service to production, we needed to know how much
`traffic it could support and what resources it required… After an initial audit we
`saw that not all cores were being utilized to spread the processing load. As a
`result we used Node.js’s cluster API to make use of all the pod’s cores, which
`quadrupled the pod’s request capacity”.
`
`Node.js “…is an open-source, cross-platform runtime environment that allows
`developers to create all kinds of server-side tools and applications in JavaScript. The
`runtime is intended for use outside of a browser context i.e., running directly on a
`computer or server OS (see Ex. 2). (For a simple example of how to create a server
`to start listening to HTTP requests see Ex. 11).
`
`Express.js “… is a back-end web application framework for Node.js. It is designed
`for building web applications and APIs. It has been called the de facto standard server
`framework for Node.js” (see Ex. 3).
`
`Next.js is a server rendered React (JavaScript) framework used to create high
`performing web applications and has become very popular in the tech world. “Next.js
`handles the tooling and configuration needed for React, and provides additional
`structure, features, and optimizations for your application. Next.js is a JavaScript
`framework that enables you to build superfast and extremely user-friendly static
`websites, as well as web applications using React. This feature allows Next.js to build
`hybrid applications that contain both server-side rendered and statically generated
`pages” (see Ex. 4.).
`
`Furthermore, in 2019, DoorDash rebuilt their web UI using the React and Next.js
`frameworks. At that time, they also implemented server-side rendering (a method of
`rendering web applications on the server and serving a static HTML page loaded with
`data specific to the requested page to the user). This helped to improve the performance
`of the overall web application by shortening page-load times, improve bundle size
`optimizations, and improving SEO (see Exh. 27).
`
`8
`
`
`
`
`
`Case 2:23-cv-02165-WSH Document 1-14 Filed 12/22/23 Page 10 of 250
`
`The original DoorDash platform was originally a monolithic application written in
`Python using the Django web framework with a PostgreSQL database. As the platform
`grew, they started to have problems with reliability and scaling. Around 2018 they instituted
`a code freeze and began migrating to microservices. At this time, they also migrated to
`the Kotlin language, and their services now run on the java virtual machine (JVM) (See Exh.
`20, 21, 22, 40).
`
`DoorDash was able to improve the efficiency and reliability of their platform using a
`microservices architecture. By breaking up their application into domain-specific parts
`they were able to reduce errors and latency. They state in the article “Future-proofing:
`How DoorDash Transitioned from a Code Monolith to a Microservice Architecture”
`(see Exh. 20) that “… final design for our new microservice architecture consisted of
`five different layers, ranging from the user experience to the core infrastructure. Each
`layer provides functionality to the upper layer and leverages the functionality exposed
`by the lower layer [as shown below]”:
`
`
`
`
`
`These layers include (See Exh. 20):
`
`
`
`
`
`9
`
`
`
`Case 2:23-cv-02165-WSH Document 1-14 Filed 12/22/23 Page 11 of 250
`
`“Frontend layer: Provides frontend systems (like the DoorDash mobile app,
`Dasher web app, etc.) for the interaction with consumers, merchants, and
`Dashers that are built on top of different frontend platforms.
`
`BFF layer: The frontend layer is decoupled from the backend layer via BFFs. The
`BFF layer provides functionality to the frontend by orchestrating the interaction
`with multiple backend services while hiding the underlying backend architecture.
`
`Backend Layer: Provides the core functionality that powers the business logic
`(order cart service, feed service, delivery service, etc.).
`
`Platform layer: Provides common functionality that is leveraged by other
`backend services (identity service, communication service, etc.).
`
`Infrastructure layer: Provides the infrastructural components that are required
`to build the site (databases, message brokers, etc.) and lays the foundation to
`abstract the system from the underlying environment (cloud service provider).”
`
`In this, DoorDash’s new architecture they introduced the backend-for-frontend (BFF)
`“…an application connecting the consumer-facing client and the services providing
`general purpose APIs. Client requests go to the BFF, which then orchestrates the
`aggregation of information needed by the client”. The BFF is a software architecture
`pattern (See Exh. 40) used by microservices which “…shifted from thick-client
`applications to interfaces delivered via the web, a trend that has also enabled the
`growth of SAAS-based solutions in general”. As such BFF can be considered as
`“…the user-facing application as being two components - a client-side application
`living outside your perimeter, and a server-side component (the BFF) inside your
`perimeter”. The perimeter of the BFF is the webserver.
`
`In the blog article by the DoorDash engineering team Platform Optimization Through
`Better API Design (see Exh. 22) they state in the introduction:
`
`“As DoorDash migrated from a monolithic codebase to a microservices
`architecture, we found an opportunity to refine our API design. Beyond simple
`functionality, we determined best practices in making APIs that help our
`applications load quickly, use minimal storage, and, most importantly, avoid
`failures.”
`
`“APIs, the connective tissue of a software platform, can offer performance
`improvements when properly designed. At DoorDash, the APIs relay frontend
`client requests to backend services and provide the information that users see in
`our apps, such as the estimated time when a food order will be delivered. If the
`APIs perform at maximum efficiency, client requests and responses all process
`more quickly” (See Exh. 20, 21, 40).
`
`In their new architecture they introduced the backend-for-frontend (BFF) “… an
`application connecting the consumer-facing client and the services providing general
`purpose APIs. Client requests go to the BFF, which then orchestrates the aggregation
`of information needed by the client”. The BFF is a software architecture pattern (See
`Exh. 40) used by microservices which “…shifted from thick-client applications to
`interfaces delivered via the web, a trend that has also enabled the growth of SAAS-
`based solutions in general”. As such BFF can be considered as “…the user-facing
`application as being two components – a client-side application living outside your
`
`10
`
`
`
`
`
`Case 2:23-cv-02165-WSH Document 1-14 Filed 12/22/23 Page 12 of 250
`
`perimeter, and a server-side component (the BFF) inside your perimeter”. The
`perimeter of the BFF is the webserver.
`
`As shown “…in the diagram below …when the BFF receives the order details
`request, it orchestrates the calls to the consumer service, order service, and delivery
`service, ultimately assembling the response details into a consolidated order
`detail response. Building APIs using domain-specific services, orchestrated by the
`BFF, makes it easier to understand which RPCs are called and how they are executed”
`(see Exh. 41).
`
`
`
`BFF is the core service that permits their large system to be pieced into various
`backend sub-systems (microservices) for performance improvements and easier
`maintainability. They go on to state that:
`
`“At DoorDash, our APIs primarily support information on food orders, whether
`that’s an order placed by a consumer and sent to a restaurant, a delivery request
`sent to a Dasher, or a Dasher’s progress in bringing a food order to a consumer.
`For example, two main endpoints, order detail and order delivery status, populate
`our order tracking page, [as] shown in [the figure below]”
`
`
`
`11
`
`
`
`Case 2:23-cv-02165-WSH Document 1-14 Filed 12/22/23 Page 13 of 250
`
`
`
`“When we redesigned the Reorder endpoint, we wrote the Reorder API so it
`would read the order information it needs to create the new cart instead of
`passing the large order data over the network to create the new cart, as shown
`[below]…[here] in our redesigned order flow, we reduce network traffic by
`writing the Reorder API so that it reads the order detail and creates the new cart,
`simplifying its role…. The client only needs metadata for the new cart from the
`Reorder endpoint, so we only return a cart summary response to the client instead
`of the whole cart. Compared to the previous flow, shown in Figure 4, we not only
`eliminate the request to call GET order cart from the client, but also make both
`the request and response very light.”
`
`
`
`
`
`12
`
`
`
`Case 2:23-cv-02165-WSH Document 1-14 Filed 12/22/23 Page 14 of 250
`
`Fault Tolerance with RPC Fallbacks in DoorDash’s Microservices
`
`In the blog article “Improving Fault Tolerance with RPC Fallbacks in DoorDash’s
`Microservices” by the DoorDash Engineering team (See Exh. 119), they state that:
`
` “…the industry today is replacing legacy monolithic architectures with
`microservices to capitalize on the promise of better scalability and developer
`productivity. As with anything in distributed systems, this new architecture comes
`with tradeoffs — most notably complexity. Interservice communication is done
`through remote procedure calls, or RPCs, which add a whole new set of issues to
`consider. But designing for fault tolerance from the start can ensure the system
`continues to operate properly in the event of failures.”
`
`to
`that employs gRPC
`“DoorDash uses a microservices architecture
`communicate between services. Product microservices return content to clients
`in the user’s preferred language. The translated content is fetched from the
`platform’s translation microservice. A translation client simplifies the interaction
`with the translation systems, exposing a simplified interface that different teams
`can use to fetch translated content.”
`
`“With the myriad strategies described here to mitigate failures, it is possible to
`keep systems operational despite them. The fallbacks we have deployed to
`improve our system’s fault tolerance is just one of the many initiatives DoorDash
`undertakes to provide our customers the best service possible.”
`
`Node.js SDK
`
`Recently, DoorDash further customized its webservers (again which runs on node.js)
`by creating a new API called DoorDash Node.js SDK which “…care of the
`boilerplate work of using our API, like setting up the authentication token and making
`HTTP requests. SDKs generally make it faster to use an API because they take care
`of this boilerplate work so you can get right to the task you’re trying to achieve–say,
`creating a delivery and requesting a Dasher. In the screenshot below, the code on the
`left creates a delivery using the Create Delivery API directly; the code on the right,
`using the DoorDash Node.js SDK.” See Exh. 41.
`
`
`
`
`
`13
`
`
`
`Case 2:23-cv-02165-WSH Document 1-14 Filed 12/22/23 Page 15 of 250
`
`
`
`AWS Web Server Hosting and Location
`
`DoorDash migrated their hosting from Heroku to Amazon Web Services (AWS)
`sometime in 2015. They built a Docker image of their app to make the transition
`easier. At that time DoorDash adopted “Amazon RDS Postgres” as primary data store
`and then in 2018 migrated to “Amazon Aurora Postgres.”
`
`Since 2019, they have been using the following AWS services: Amazon ElastiCache
`(in-memory caching service), Amazon Relational Database Service (aka RDS is a
`collection of database services), Amazon Aurora (scalable MySQL and PostgreSQL
`database service), Amazon CloudWatch (monitoring and observability service),
`Amazon DynamoDB (NoSQL database service), Amazon Kinesis (real time video
`process and analyzing service), and Amazon Redshift (data warehouse service).
`DoorDash also uses Amazon EC2 compute resources. This is likely how they host
`their Kotlin/Java application (see Exh. 23, 24, 25, 26).
`
`Web Technology Surveys
`
`W3Techs, World Wide Web Technology Surveys (See Ex. 8) identifies DoorDash as
`using multiple server, client, and programming technologies to operate their system
`(see Ex 13). These include but not limited to the following:
`
`Content Management System: Salesforce Customer 360 (used on a subdomain)
`
`Server-side Programming Language: ASP.NET Microsoft’s Active Server Pages
`technology on the .NET framework.
`
`Client-side Programming Language: JavaScript, Bootstrap is an HTML, CSS.
`
`
`
`14
`
`
`
`Case 2:23-cv-02165-WSH Document 1-14 Filed 12/22/23 Page 16 of 250
`
`Web Servers: Cloudflare Server and Envoy. Cloudflare Server is a web server
`developed by Cloudflare. Envoy Proxy is a proxy server designed for large
`service-oriented architectures.
`
`Reverse Proxy Service: Cloudflare provides a content delivery network.
`
`DNS Server Provider through Cloudflare. DNS allows websites to found by name
`such as DoorDash.com on webservers.
`
`StatsCrop
`
`StatsCrop.com is a free online website analyzer. Using this service, the following
`website information for DoorDash.com is generated including the location of their
`servers, name server info, DNS information and whois profile (see Ex. 10):
`
`Server Location
`
`
`
`
`
`
`
`15
`
`
`
`Case 2:23-cv-02165-WSH Document 1-14 Filed 12/22/23 Page 17 of 250
`
`Name Servers
`
`Domain WhoIs
`
`
`
`
`
`More importantly, StatsCrop.com shows the following webserver DNS records for
`DoorDash.com (see Exh. 10).
`
`Note: DNS is “…a hierarchical and decentralized naming system for computers,
`services, or other resources connected to the Internet or a private network. It
`associates various information with domain