DCT
2:25-cv-13104
S3G Technology LLC v. Domino's Pizza LLC
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-397, W.D. Tex., 07/24/2024
- Venue Allegations: Plaintiff alleges venue is proper because Defendant is subject to personal jurisdiction in the district and maintains a regular and established place of business in Waco, Texas, while also distributing the accused mobile applications to customers within the district.
- Core Dispute: Plaintiff alleges that Defendant’s mobile ordering applications and associated backend systems infringe patents related to methods for efficiently modifying and updating software on remote devices.
- Technical Context: The technology concerns client-server architectures where application functionality can be altered via small, interpretable "dialogue modules," avoiding the need to recompile and distribute entire applications, a process particularly relevant to managing widely distributed mobile apps.
- Key Procedural History: The complaint indicates this action is part of a broader litigation campaign, listing numerous related cases filed by the Plaintiff against other defendants. The complaint also heavily relies on claim constructions from a prior litigation (S3G Tech. LLC v. Unikey Techs., Inc., E.D. Tex.), and cites a Notice of Allowability from a related patent's prosecution history to support its arguments of patentability and novelty.
Case Timeline
| Date | Event |
|---|---|
| 2009-07-23 | Priority Date for '124, '774, and '995 Patents |
| 2018-04-10 | U.S. Patent No. 9,940,124 Issued |
| 2019-04-16 | U.S. Patent No. 10,261,774 Issued |
| 2023-05-30 | U.S. Patent No. 11,662,995 Issued |
| 2024-07-10 | Accused Android App Last Updated |
| 2024-07-15 | Accused iOS App Last Updated |
| 2024-07-24 | Complaint Filed |
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, titled “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 inefficiency and high bandwidth costs associated with updating software on numerous remote devices, such as mobile phones. Traditional methods require recompiling and transmitting an entire new application, which is slow and difficult to manage, especially over wireless networks (Compl. ¶¶13-15).
- The Patented Solution: The invention proposes a three-part system architecture: a "terminal machine" (e.g., a user's device), a "service provider machine" (e.g., a backend server), and an "update server machine" (Compl. ¶16). The complaint references patent Figure 1, which illustrates this three-entity computer system structure (Compl. ¶16). Instead of sending a full application update, the update server sends a small "dialogue module" containing "code" to the terminal. This "code" must be interpreted or "translated" by the application before it can be implemented, and it modifies the application’s behavior (e.g., changing a sequence of user prompts) without altering the application's underlying, pre-compiled "computer-executable instructions" (’995 Patent, col. 4:40-43; Compl. ¶17).
- Technical Importance: This architectural separation allows for lightweight, efficient modification of application logic on remote devices, reducing network traffic and simplifying the update process (Compl. ¶25).
Key Claims at a Glance
- The complaint asserts infringement of at least Claim 1 (Compl. ¶32).
- The essential elements of independent claim 1, as framed by the complaint, include:
- Displaying a first prompt via a terminal application comprised of "first computer-executable instructions" and "first code."
- Accepting a data entry.
- Communicating information to a service provider machine running a provider application comprised of "second computer-executable instructions" and "second code."
- Storing a portion of the information for analysis.
- Receiving a "terminal dialogue module" at the terminal machine that "updates" a portion of the "first code" to produce "first updated code," which in turn adapts the application to display a second prompt.
- The complaint does not explicitly reserve the right to assert dependent claims for this patent.
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, titled “Modification of Terminal and Service Provider Machines Using an Update Server Machine,” issued April 16, 2019 (Compl. ¶11).
The Invention Explained
- Problem Addressed: As a continuation of the same patent family, the ’774 Patent addresses the same technical problem of inefficiently updating software across a distributed network of remote devices (’774 Patent, col. 2:35-50; Compl. ¶13).
- The Patented Solution: The solution is materially the same as that described in the ’124 Patent, centered on a system that separates an application into directly executable instructions and interpretable "code." This allows small "dialogue modules" to modify application behavior without requiring a full software replacement (’774 Patent, col. 4:30-54). The complaint includes patent Figure 2, which depicts the specific structure of the terminal and service provider applications as comprising both computer-executable instructions and code that must be translated (Compl. ¶17).
- Technical Importance: The system aims to provide "computing resource, improved network utilization, and design efficiencies" by enabling lightweight modifications to remote software (Compl. ¶20).
Key Claims at a Glance
- The complaint asserts infringement of at least Claim 1 (’774 Patent, Compl. ¶51).
- The essential elements of independent claim 1 include:
- Displaying a first prompt on a terminal machine via a terminal application comprising "first computer-executable instructions" and "first code."
- Accepting a first data entry.
- Communicating information from the terminal machine to a service provider machine running an application with "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" adapts the terminal application to display a second prompt for a modified dialogue sequence.
- The complaint does not explicitly reserve the right to assert dependent claims for this patent.
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, titled “Network Efficient Location-Based Dialogue Sequence Using Virtual Processor,” issued May 30, 2023 (Compl. ¶12).
- Technology Synopsis: This patent describes a method for conducting a dialogue sequence across at least two different user devices (e.g., a website and a mobile app). The system facilitates updates between the devices by having a provider application receive "second code" from a first user device to create an "updated code," and then sending "third code" to the second user device to facilitate its portion of the dialogue, all without the devices explicitly requesting the updates (Compl. ¶¶70, 73, 77).
- Asserted Claims: At least Claim 1 (Compl. ¶69).
- Accused Features: The complaint accuses the functionality where a user's interaction on one platform (e.g., adding a saved address on the Domino's website) results in an update being pushed to another platform (the new address appearing in the Domino's mobile app) without the mobile app specifically requesting that update (Compl. ¶¶71-77).
III. The Accused Instrumentality
Product Identification
- The "Accused Instrumentalities" are identified as Domino's Pizza's mobile applications for Android and iOS, along with the associated backend systems, servers, and software that support the apps' functionality (Compl. ¶8).
Functionality and Market Context
- The accused functionality involves the system for managing user account data, such as saved delivery addresses, payment information, and rewards (Compl. ¶34 & n.8). The complaint alleges that when a user interacts with this data (e.g., adding, deleting, or selecting a saved address), the mobile application communicates with Defendant's servers. The servers then send information back to the application, causing it to display updated content (e.g., a revised list of saved addresses), which the complaint alleges is an infringing modification of the application's dialogue sequence (Compl. ¶¶36, 38).
IV. Analysis of Infringement Allegations
9,940,124 Patent Infringement Allegations
| Claim Element (from Independent Claim 1, per complaint) | Alleged Infringing Functionality | Complaint Citation | Patent Citation |
|---|---|---|---|
| displaying a first prompt ... by running a terminal application, the terminal application comprising first computer-executable instructions and first code... | The Domino's app prompts a user with a list of saved addresses. The complaint alleges the Android Runtime (ART) constitutes the "instructions" and the app's bytecode constitutes the "code." | ¶34 | col. 7:56-61 |
| accepting a first data entry at the terminal machine... | The user selects a saved address to use for an order or to remove from the list. | ¶35 | col. 4:26-28 |
| communicating information ... to the service provider machine, wherein the service provider machine uses a provider application comprising second computer-executable instructions and second code... | The user's selection is sent to Domino's server, which allegedly runs a .Net application. The complaint alleges the .Net Common Language Runtime (CLR) is the "instructions" and the .Net program is the "code." | ¶36 | col. 5:1-4 |
| 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 representing an updated list of addresses. The complaint alleges this data is a "dialogue module" that "updates" the app's bytecode ("first code") to display the new information. | ¶38 | col. 8:63-9:3 |
| wherein the first updated code adapts the terminal application to display a second prompt... | The app displays the new, updated list of saved addresses, which the complaint identifies as the "second prompt." | ¶38 | col. 9:4-9 |
10,261,774 Patent 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 a list of saved addresses to the user. The complaint alleges the Android Runtime (ART) is the "first computer-executable instructions" and the app's bytecode is the "first code." | ¶53 | col. 7:56-61 |
| accepting a first data entry at the terminal machine... | The user interacts with the list, for example by selecting an address to use for an order. | ¶54 | col. 4:26-28 |
| communicating information associated with the first data entry from the terminal machine to the service provider machine... | The user's selection is transmitted to the Domino's server, which runs a backend application to process the information. | ¶55 | col. 5:1-4 |
| 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 (e.g., JSON) from the server containing updated address information. The complaint alleges this data constitutes the "third code" and that it "modifies" the app's bytecode ("first code"). | ¶56 | col. 8:63-9:3 |
| 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 app processes the received data and displays a new or updated list of saved addresses, which the complaint characterizes as the "second prompt." | ¶56 | col. 9:4-9 |
Identified Points of Contention
- Scope Questions: The infringement theory raises the question of whether the standard, dynamic exchange of data (like a JSON object) between a mobile app and a server falls within the patent's specific definition of a "dialogue module" or "code" that "updates" the application's own code. The defense may argue that this is merely data being processed by static application code, not a modification of the code itself.
- Technical Questions: A central technical question will be whether the complaint provides evidence that the accused app's bytecode is actually modified or updated upon receiving data from the server. The analysis will likely focus on whether parsing JSON data to render a view constitutes "translating" and "implementing" "code" in the manner claimed by the patents, or if it is a fundamentally different technical process.
V. Key Claim Terms for Construction
The Term: "code"
- Context and Importance: This term's construction is critical. The complaint relies on a prior construction defining it as "information that must be translated before it can be executed on a processor" (Compl. ¶9, n.6). Practitioners may focus on this term because its scope will determine whether simple data formats like JSON can be considered "code" under the patent, which is the foundation of the Plaintiff's infringement theory.
- Intrinsic Evidence for Interpretation:
- Evidence for a Broader Interpretation: The specification states, "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-43). This language does not explicitly limit the "information" to executable logic.
- Evidence for a Narrower Interpretation: The specification provides "Java Byte Code" as an example of "intermediary code" (’774 Patent, col. 2:61-64). This could support a narrower construction where "code" must be a form of executable or interpretable program instructions, distinguishing it from passive data structures.
The Term: "updates at least a portion of the first code to produce first updated code"
- Context and Importance: This phrase defines the mechanism of infringement. The dispute will be whether receiving data and changing the application's display constitutes "updating code."
- Intrinsic Evidence for Interpretation:
- Evidence for a Broader Interpretation: The patent describes the outcome as adapting the application "to perform a modified dialogue protocol" (’774 Patent, col. 10:9-11). Plaintiff may argue that any change in the application's interactive behavior resulting from the received module constitutes an "update" in this functional sense.
- Evidence for a Narrower Interpretation: The claim language distinguishes between "computer-executable instructions" and "code," and states the "code" is updated, not just the data it processes. The term "updated code" suggests a modification to the logical structure itself, rather than just feeding new data into an unchanged structure. The specification notes the dialogue module "replaces existing terminal code" or "may supplement other code" (’774 Patent, col. 9:5-10), language that suggests modification of the code base itself.
VI. Other Allegations
Indirect Infringement
- The complaint alleges inducement by Defendant's marketing and promotion of the accused apps, and by instructing users to download and use them in an infringing manner (Compl. ¶¶44, 62). Contributory infringement is alleged on the basis that the accused system is not a staple article of commerce and is especially adapted to infringe the patents (Compl. ¶¶45, 63).
Willful Infringement
- The complaint alleges willful infringement based on Defendant's knowledge of the patents-in-suit "at least since the filing of this Complaint" (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," which the patent defines in relation to being "translated" and "implemented," be construed to encompass standard data-interchange formats like JSON, or is it limited to a form of interpretable program logic distinct from passive data?
- A key evidentiary question will be one of functional operation: does a modern mobile application's routine process of receiving a data object from a server and using it to render an updated display constitute "updating" the application's underlying "code to produce...updated code" as required by the claims, or does this represent a fundamental mismatch between the patent's specific update mechanism and the ordinary operation of a client-server application?