DCT
6:24-cv-00395
S3G Technology LLC v. Domino's Pizza LLC
Key Events
Complaint
Table of Contents
complaint
I. Executive Summary and Procedural Information
- Parties & Counsel:
- Plaintiff: S3G Technology LLC (California)
- Defendant: Domino's Pizza LLC (Michigan)
- Plaintiff’s Counsel: Parker, Bunt & Ainsworth, P.C.
- Case Identification: 6:24-cv-00397, W.D. Tex., 07/24/2024
- Venue Allegations: Plaintiff alleges venue is proper in the Western District of Texas because Defendant maintains a regular and established place of business in Waco, Texas, and distributes the accused mobile applications to customers within the district.
- Core Dispute: Plaintiff alleges that Defendant’s mobile applications and associated server infrastructure for online ordering infringe three patents related to methods for efficiently modifying remote software applications.
- Technical Context: The technology addresses updating software on distributed devices (such as smartphones) by sending small "dialogue modules" to modify application behavior, rather than transmitting entire new versions of the application, thereby conserving network bandwidth.
- Key Procedural History: The complaint indicates that the asserted patents, or patents from the same family, have been the subject of prior litigation, including a case that resulted in court-construed definitions for key claim terms. The complaint also notes that during patent prosecution, the U.S. Patent and Trademark Office considered and allowed the claims over prior art and subject matter eligibility contentions.
Case Timeline
| Date | Event |
|---|---|
| 2009-07-23 | Earliest Priority Date for ’124, ’774, and ’995 Patents |
| 2013-07-11 | Notice of Allowability for a related patent mentioned in prosecution history |
| 2018-04-10 | ’124 Patent Issued |
| 2019-04-16 | ’774 Patent Issued |
| 2023-05-30 | ’995 Patent Issued |
| 2024-07-10 | Accused Android App Last Updated |
| 2024-07-15 | Accused iOS App Last Updated |
| 2024-07-24 | Complaint Filing Date |
II. Technology and Patent(s)-in-Suit Analysis
U.S. Patent No. 9,940,124 - "Modification of Terminal and Service Provider Machines Using an Update Server Machine"
- Patent Identification: U.S. Patent No. 9,940,124, "Modification of Terminal and Service Provider Machines Using an Update Server Machine," issued April 10, 2018 (Compl. ¶10).
The Invention Explained
- Problem Addressed: The patent addresses the technical challenge of efficiently updating software applications distributed across a large number of remote devices, particularly over wireless networks with limited bandwidth. Distributing a full, newly compiled version of an application to each device can be slow, costly, and difficult to manage (Compl. ¶¶ 13-15).
- The Patented Solution: The invention proposes a three-entity system: a terminal machine (e.g., a smartphone), a service provider machine (e.g., a back-end server), and an update server machine. Instead of sending a complete software update, the update server sends a small "dialogue module" to the terminal and/or service provider machine. This module contains "code"—defined as information that must be translated before execution—which modifies the behavior of the existing application without replacing its core computer-executable instructions (Compl. ¶¶ 16-20). For instance, the complaint includes FIG. 1 from the Asserted Patents, which depicts the claimed three-entity computer system structure involving a terminal machine, a service provider machine, and an update server machine (Compl. ¶16).
- Technical Importance: This method allows for lightweight, efficient modification of remote applications, reducing network bandwidth utilization and simplifying the update process for large-scale distributed systems (Compl. ¶25).
Key Claims at a Glance
- The complaint asserts at least independent claim 1 (Compl. ¶32).
- The essential elements of claim 1 of the ’124 Patent, a method, include:
- Displaying a first prompt on a terminal machine via a terminal application, where the application comprises first computer-executable instructions and first code.
- Accepting a first data entry at the terminal machine.
- Communicating information from the data entry to a service provider machine running a provider application, which also comprises computer-executable instructions and code.
- Storing at least a portion of the communicated information in memory for analysis.
- Receiving, at the terminal machine, a terminal dialogue module that updates a portion of the first code to produce first updated code.
- The first updated code adapting the terminal application to display a second prompt as part of a modified dialogue sequence.
- At least one of the first code, second code, and first updated code comprising intermediate code.
U.S. Patent No. 10,261,774 - "Modification of Terminal and Service Provider Machines Using an Update Server Machine"
- Patent Identification: U.S. Patent No. 10,261,774, "Modification of Terminal and Service Provider Machines Using an Update Server Machine," issued April 16, 2019 (Compl. ¶11).
The Invention Explained
- Problem Addressed: The patent, which shares a specification with the ’124 Patent, addresses the inefficiency and high bandwidth consumption associated with distributing full software application updates to numerous remote devices (’774 Patent, col. 2:35-56).
- The Patented Solution: The patent describes the same three-node system architecture (terminal, service provider, and update server) that uses compact "dialogue modules" to modify application functionality. These modules contain "code" that is interpreted by the existing application, allowing for changes to the user interface and dialogue flow without requiring a full software replacement (’774 Patent, Abstract; col. 4:36-54).
- Technical Importance: The solution provides a method for making targeted, efficient updates to distributed software, which is particularly valuable for applications deployed over wireless networks (’774 Patent, col. 6:55-63).
Key Claims at a Glance
- The complaint asserts at least independent claim 1 (Compl. ¶51).
- The essential elements of claim 1 of the ’774 Patent, a method, include:
- Displaying a first prompt via a terminal application comprising first computer-executable instructions and first code.
- Accepting a first data entry at the terminal machine.
- Communicating information from the data entry to a service provider machine running a provider application comprising second computer-executable instructions and second code.
- Receiving, at the terminal machine, third code that modifies a portion of the first code to produce first updated code.
- The first updated code adapting the terminal application to display a second prompt for a modified dialogue sequence.
U.S. Patent No. 11,662,995 - "Network Efficient Location-Based Dialogue Sequence Using Virtual Processor"
- Patent Identification: U.S. Patent No. 11,662,995, "Network Efficient Location-Based Dialogue Sequence Using Virtual Processor," issued May 30, 2023 (Compl. ¶12).
- Technology Synopsis: This patent extends the core technology to a system involving at least two user devices that engage in a dialogue sequence facilitated by one or more provider applications. The system sends authorizations to each device and updates the provider application with "code" received from a first user device. This updated code enables the provider application to facilitate the ongoing dialogue between the first and second user devices, with updates being sent "without requesting" them (Compl. ¶¶ 70-73, 77).
- Asserted Claims: At least independent claim 1 (Compl. ¶69).
- Accused Features: The complaint alleges that Domino's system, where a user can interact via both a website (first user device) and a mobile app (second user device), infringes. For example, a user saving a new address on the website allegedly causes the server to receive "code" that updates the provider application, which in turn sends "code" to the mobile app so the new address appears there, facilitating a cross-device dialogue (Compl. ¶¶ 71-73).
III. The Accused Instrumentality
Product Identification
- The accused instrumentalities are Defendant's mobile applications for Android and iOS (the "Defendant app") and the associated back-end systems, servers, and software that support the apps' functionality (collectively, the "Accused System") (Compl. ¶8).
Functionality and Market Context
- The Accused System constitutes Domino's mobile and online ordering platform. The complaint alleges that a user's device running the Defendant app functions as the claimed "terminal machine," which communicates with Domino's servers, functioning as the "service provider machine" (Compl. ¶33). A key accused functionality is the management of user data, such as saved delivery addresses. When a user interacts with this data (e.g., adding, editing, or selecting a saved address), the app communicates with the server, which allegedly sends back a "dialogue module" (e.g., JSON data) that updates the app's internal "code" to reflect the change and display a modified user interface or prompt (Compl. ¶¶ 34, 38). The complaint alleges that Defendant derives significant revenue from this system (Compl. ¶4).
IV. Analysis of Infringement Allegations
U.S. Patent No. 9,940,124 Infringement Allegations
| Claim Element (from Independent Claim 1) | Alleged Infringing Functionality | Complaint Citation | Patent Citation |
|---|---|---|---|
| displaying a first prompt on a terminal display... by running a terminal application, the terminal application comprising first computer-executable instructions and first code | The Domino's app (terminal application) prompts the user with a list of saved addresses. The app's bytecode is alleged to be "first code," while the Android Runtime (ART) provides the "first computer-executable instructions." | ¶34, ¶35 | col. 12:31-37 |
| communicating information associated with the first data entry from the terminal machine to the service provider machine... [which] uses a provider application comprising second computer-executable instructions and second code | Selecting a saved address (data entry) is communicated to Domino's server. The server runs a .Net application (provider application), where the .Net program is the "second code" and the Common Language Runtime (CLR) provides the "second computer-executable instructions." | ¶36 | col. 8:2-7 |
| storing at least a portion of the information associated with the first data entry in memory for analysis | The server stores information from orders using saved addresses for analysis and to add to the user's order history. | ¶37 | col. 12:59-61 |
| receiving, at the terminal machine, a terminal dialogue module that updates at least a portion of the first code to produce first updated code | The app receives data (e.g., JSON) from the server that constitutes a "terminal dialogue module." This module updates the app's bytecode (first code) to reflect changes, such as a newly saved address. | ¶38 | col. 9:1-9 |
| wherein the first updated code adapts the terminal application to display a second prompt for the terminal machine's portion of a modified dialogue sequence | The updated bytecode adapts the app to display a new prompt, such as the ability to access or interact with the newly saved address list items, modifying the dialogue with the user. | ¶38 | col. 9:22-31 |
| wherein at least one of the first code, the second code, and the first updated code comprise intermediate code | The app's bytecode is alleged to be a form of intermediate code. | ¶38 | col. 9:12-16 |
U.S. Patent No. 10,261,774 Infringement Allegations
| Claim Element (from Independent Claim 1) | Alleged Infringing Functionality | Complaint Citation | Patent Citation |
|---|---|---|---|
| displaying a first prompt on a terminal display... by running a terminal application, the terminal application comprising first computer-executable instructions and first code | The Domino's app displays prompts related to saved address list items. The app's bytecode is the "first code," and the Android Runtime (ART) provides the "computer-executable instructions." | ¶53 | col. 12:31-37 |
| communicating information associated with the first data entry... to the service provider machine... [which] uses a provider application comprising second computer-executable instructions and second code | User actions, such as deleting a saved address, are communicated to Domino's server, which runs a .Net application. The .Net program is the "second code" and the CLR is the "computer-executable instructions." | ¶55 | col. 8:2-7 |
| receiving, at the terminal machine, third code that modifies at least a portion of the first code to produce first updated code | The app receives data from the server (e.g., JSON) representing a new or modified saved address list item. This data is alleged to be the "third code" that modifies the app's bytecode (first code). | ¶56 | col. 9:1-9 |
| wherein the first updated code adapts the terminal application to display a second prompt for the terminal machine's portion of a modified dialogue sequence | The updated bytecode allows the app to display a new prompt, such as the ability to access newly saved address list items, as part of a modified dialogue. | ¶56 | col. 9:22-31 |
- Identified Points of Contention:
- Scope Questions: A central question may be whether the data formats used by the Accused System (e.g., JSON) qualify as "code" under the patents' definition, which requires that the information "must be translated... before it can be implemented" (’774 Patent, col. 4:40-44). The analysis could turn on whether standard data parsing is equivalent to the "translation" of "intermediate code" contemplated by the patent. Similarly, it raises the question of whether a JSON data packet constitutes a "dialogue module," which a prior court construed as a "particular type of structure" (Compl. ¶21).
- Technical Questions: The complaint describes a client-server system. An open question for the court will be whether the architecture of the Accused System maps to the three distinct entities—terminal machine, service provider machine, and update server machine—recited in the claims of the parent ’124 Patent, or if Domino's servers are alleged to perform the functions of both the service provider and update server machines.
V. Key Claim Terms for Construction
The Term: "code"
Context and Importance: This term is foundational to the patents' claimed point of novelty, which distinguishes sending lightweight "code" from sending heavyweight "computer-executable instructions." The infringement case depends on whether data like app bytecode or JSON payloads exchanged in the Accused System falls within this definition.
Intrinsic Evidence for Interpretation:
- Evidence for a Broader Interpretation: The specification provides a functional definition: "The code represents at least some information that must be translated by the software application before it can be implemented on the machine processor" (’774 Patent, col. 4:40-44). This language could support an interpretation that includes any data format requiring parsing before use.
- Evidence for a Narrower Interpretation: The specification repeatedly uses "intermediate code (e.g., Java Byte Code)" as a primary example (’774 Patent, col. 9:12-16). This may support an argument that "code" is limited to compiled, platform-independent instruction sets, not general-purpose data-interchange formats. The complaint notes a prior judicial construction of "code" as "information that must be translated before it can be executed on a processor" (Compl. ¶19, n.6).
The Term: "dialogue module"
Context and Importance: This term defines the package that delivers the "code." Whether the data packets sent from Domino's servers to its app constitute a "dialogue module" will be a key factual dispute.
Intrinsic Evidence for Interpretation:
- Evidence for a Broader Interpretation: The patent describes the module as containing "code" and potentially "other information" such as "text files, version information or metadata" (’774 Patent, col. 8:62-9:2), suggesting a flexible data structure.
- Evidence for a Narrower Interpretation: The complaint references a prior court ruling that "the claim uses the term 'module' to refer to a particular type of structure rather than to any structure for performing a function" (Compl. ¶21). This could support a narrower construction requiring more than just a simple data payload, but a specifically structured software component.
VI. Other Allegations
- Indirect Infringement: The complaint alleges inducement based on Defendant's marketing and instructions that encourage users to download and operate the accused app in an infringing manner (Compl. ¶¶ 44, 62). It also alleges contributory infringement on the basis that the Accused Instrumentalities are not staple articles of commerce and are specially adapted to infringe the patents (Compl. ¶¶ 45, 63).
- Willful Infringement: Willfulness is alleged based on Defendant's knowledge of the patents "At least since the filing of this complaint," indicating a claim for post-suit willful infringement (Compl. ¶¶ 31, 50, 68).
VII. Analyst’s Conclusion: Key Questions for the Case
- A core issue will be one of definitional scope: can the term "code," defined in the patent as information requiring "translation" before implementation and exemplified by Java Bytecode, be construed to cover the structured data (allegedly JSON) exchanged between the accused mobile app and server?
- A related and central question will be one of structural equivalence: does a data packet transmitted from a server to an application constitute a "dialogue module," which a court has previously construed as a "particular type of structure," or is it merely data used by an existing function?
- A key evidentiary question will concern architectural mapping: does the Defendant's client-server infrastructure, which facilitates user orders, align with the distinct three-part system of a "terminal machine," "service provider machine," and "update server machine" as described and claimed in the patents?
Analysis metadata