DCT
2:25-cv-00172
S3G Technology LLC v. Dollar Tree Stores Inc
I. Executive Summary and Procedural Information
- Parties & Counsel:
- Plaintiff: S3G Technology LLC (California)
- Defendant: Dollar Tree Stores, Inc. (Virginia)
- Plaintiff’s Counsel: PARKER, BUNT & AINSWORTH, P.C.
- Case Identification: 2:25-cv-172, E.D. Tex., 02/13/2025
- Venue Allegations: Plaintiff alleges venue is proper in the Eastern District of Texas because Defendant maintains a regular and established place of business in the district, specifically a retail store located in Marshall, Texas, and has committed acts of infringement there, including by distributing the accused applications to customers.
- Core Dispute: Plaintiff alleges that Defendant’s mobile applications for its Dollar Tree and Family Dollar brands, along with their supporting backend server systems, infringe four patents related to methods for efficiently modifying software on remote devices.
- Technical Context: The technology at issue addresses client-server software architecture, specifically a method for updating application behavior on a client device, such as a smartphone, by sending small packets of modifiable data rather than a complete new version of the application.
- Key Procedural History: The complaint references prior litigation involving the asserted patents ([S3G Technology LLC](https://ai-lab.exparte.com/party/s3g-technology-llc) v. UniKey Tech Inc), in which a court in the Eastern District of Texas construed several key claim terms, including "dialogue module" and the distinction between "computer-executable instructions" and "code." The complaint also notes that the U.S. Patent and Trademark Office allowed the asserted patent claims over prior art and subject matter eligibility challenges during prosecution.
Case Timeline
| Date | Event |
|---|---|
| 2009-07-23 | Earliest Priority Date for '124, '140, '758, and '995 Patents |
| 2016-04-05 | U.S. Patent No. 9,304,758 Issues |
| 2018-04-10 | U.S. Patent No. 9,940,124 Issues |
| 2019-08-20 | U.S. Patent No. 10,387,140 Issues |
| 2023-05-30 | U.S. Patent No. 11,662,995 Issues |
| 2025-01-15 | Dollar Tree Android App Last Updated |
| 2025-01-16 | Dollar Tree iOS App Last Updated |
| 2025-01-29 | Family Dollar Android App Last Updated |
| 2025-01-30 | Family Dollar iOS App Last Updated |
| 2025-02-13 | 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, "Modification of Terminal and Service Provider Machines Using an Update Server Machine," issued April 10, 2018.
The Invention Explained
- Problem Addressed: The patents describe the technical challenge of distributing updates for software applications across numerous remote devices, particularly over wireless networks where bandwidth limitations can make transmitting large, newly compiled application files inefficient, time-consuming, or infeasible (Compl. ¶¶15-16; ’140 Patent, col. 2:35-56).
- The Patented Solution: The invention proposes a three-entity system architecture comprising a terminal machine (e.g., a mobile device), a service provider machine (e.g., a back-end server), and an update server machine (Compl. ¶17; ’140 Patent, Fig. 1). To avoid sending a full new application, the update server sends a small "dialogue module" containing "code," which is defined as "information that must be translated...before it can be implemented on the machine processor" (’140 Patent, col. 4:30-40). This "code" modifies the behavior of the existing application—such as changing a sequence of prompts—without altering the application's underlying, pre-compiled "computer-executable instructions" (Compl. ¶¶18-19). Figure 1 from the patent illustrates the communication pathways between the update server, service provider, and terminal machines (Compl. ¶17).
- Technical Importance: This method claims to reduce network bandwidth utilization, enabling efficient and rapid modification of application functionality on a network of remote devices (Compl. ¶26).
Key Claims at a Glance
- The complaint asserts at least independent claim 1, which is a method claim (Compl. ¶33).
- The essential elements of claim 1, as alleged in the complaint, 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 associated with the data entry to a service provider machine.
- Storing a portion of that information in memory for analysis.
- 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 first updated code adapts the terminal application to display a second prompt for a modified dialogue sequence.
- At least one of the various "code" elements comprises intermediate code.
U.S. Patent No. 10,387,140 - "Modification of Terminal and Service Provider Machines Using an Update Server Machine"
- Patent Identification: U.S. Patent No. 10,387,140, "Modification of Terminal and Service Provider Machines Using an Update Server Machine," issued August 20, 2019.
The Invention Explained
- Problem Addressed: The patent addresses the same technical problems as the ’124 Patent: the difficulty of managing and distributing full software application updates to a large number of remote devices, especially when constrained by wireless network performance (’140 Patent, col. 2:12-28).
- The Patented Solution: The patented solution is a method for modifying a dialogue sequence between a terminal and a service provider. It relies on the same architectural separation between an application's directly executable instructions and its modifiable "code" (’140 Patent, Fig. 2). An update is achieved by receiving "third code" (analogous to a dialogue module) at the terminal, which modifies the existing "first code" to produce "first updated code," thereby adapting the terminal application to conduct a new or modified dialogue sequence with the server (’140 Patent, Abstract). Figure 2 from the patent depicts the specific application structure, showing separate computer-executable instructions (214, 224) and code (212, 222) (Compl. ¶18).
- Technical Importance: The invention provides a method for making targeted changes to application logic, such as user interaction flows, without the overhead of a full software recompilation and distribution cycle (’140 Patent, col. 6:50-63).
Key Claims at a Glance
- The complaint asserts at least independent claim 1, which is a method claim (Compl., Second Claim for Relief ¶4).
- The essential elements of claim 1 include:
- Displaying a first prompt on a terminal by running a terminal application comprising first computer-executable instructions and first code.
- Receiving a first data entry at the prompt.
- Communicating information from the terminal to a provider application comprising second computer-executable instructions and second code.
- Receiving, at the terminal machine, "third code" that modifies at least a portion of the first code to produce first updated code.
- The first updated code adapts the terminal application to conduct a modified dialogue sequence with the service provider machine.
Multi-Patent Capsule: U.S. Patent No. 9,304,758 - "Modification of Terminal and Service Provider Machines Using an Update Server Machine"
- Patent Identification: U.S. Patent No. 9,304,758, "Modification of Terminal and Service Provider Machines Using an Update Server Machine," issued April 5, 2016 (Compl. ¶12).
- Technology Synopsis: The patent addresses the inefficiency of updating software on remote devices by disclosing a method and system that separates an application into executable instructions and modifiable "code." This structure allows small "dialogue modules" to be transmitted over a network to update the application's behavior without requiring a full reinstallation or replacement of the application's core executable components (Compl. ¶¶14-17).
- Asserted Claims: At least Claim 1 (Compl., Third Claim for Relief ¶27).
- Accused Features: The complaint accuses the Dollar Tree apps and backend servers of infringing by conducting a dialogue wherein the app (comprising alleged executable instructions like the Android Runtime and "code" like app bytecode) receives a "dialogue module" (allegedly JSON data) from the server that updates the code to modify the user interface prompts and dialogue flow (Compl., Third Claim for Relief ¶¶28-32).
Multi-Patent Capsule: 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. ¶13).
- Technology Synopsis: The patent describes a method for managing a dialogue sequence between at least two user devices (e.g., a user's web session and mobile app) via one or more provider applications. The system sends authorizations and "code" supplements to the devices to facilitate and adapt the dialogue, with the code being received by the device without an explicit request, enabling efficient, server-driven updates across multiple user endpoints (Compl. ¶¶55-58).
- Asserted Claims: At least Claim 1 (Compl., Fourth Claim for Relief ¶54).
- Accused Features: The accused system allegedly facilitates a dialogue between a user's web browser and mobile app. The complaint alleges that the server infringes by sending authorizations (e.g., login credentials) and updated code (e.g., for a "My Store preference") to the devices, which adapts the application’s dialogue sequence without the device first requesting the code (Compl., Fourth Claim for Relief ¶¶56-58).
III. The Accused Instrumentality
Product Identification
- The "Accused System" comprises the "Dollar Tree" and "Family Dollar" branded mobile applications for Android and iOS, as well as the associated backend systems, servers, software, and databases that support their functionality (Compl. ¶8, fn. 1-2).
Functionality and Market Context
- The accused applications provide retail functionalities to users, such as setting a preferred store ("My Store preference"), managing coupons, and building a shopping cart (Compl. ¶35, fn. 8). The complaint alleges that when a user interacts with the app, data is exchanged with Defendant's servers. This exchange allegedly involves the server sending back data, identified as JSON, which updates the application's state and modifies the user interface to reflect changes, such as a saved store preference (Compl. ¶¶37, 39). The complaint asserts that Defendant derives significant revenue from the use and promotion of these applications (Compl. ¶8).
IV. Analysis of Infringement Allegations
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 comprising first computer-executable instructions and first code... | The Dollar Tree app displays a prompt for a user to select or review their "My Store preference." The complaint alleges the "first computer-executable instructions" are the Android Runtime (ART) and the "first code" is the app's bytecode. | ¶35 | col. 7:56-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 in JSON format from the server, which represents the user's selected store preference. This data allegedly updates the app's bytecode to reflect the new state. | ¶39 | 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 updated code adapts the app to display the newly saved store preference and enables the user to access it later, which the complaint frames as displaying a second prompt in a modified dialogue. | ¶39 | col. 9:3-9 |
| wherein at least one of the first code, the second code, and the first updated code comprise intermediate code. | The complaint alleges that the app's bytecode constitutes "intermediate code" as required by the claim. | ¶39 | col. 8:10-15 |
10,387,140 Infringement Allegations
| Claim Element (from Independent Claim 1) | 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 user is prompted to review or save a "My Store preference." The app allegedly comprises computer-executable instructions (Android Runtime) and first code (app bytecode). | Second Claim ¶6 | col. 7:56-61 |
| communicating information associated with the first data...to a provider application at the service provider machine... | The user's store preference selection is communicated from the mobile app to the Defendant's server application. | Second Claim ¶8 | col. 8:1-5 |
| receiving, at the terminal machine, third code that modifies at least a portion of the first code to produce first updated code... | The mobile app receives JSON data from the server representing the saved store preference. This data is stored and allegedly modifies the app's bytecode. | Second Claim ¶10 | col. 8:63-9:3 |
| wherein the first updated code adapts the terminal application to conduct a modified dialogue sequence with the service provider machine. | The modified bytecode adapts the app to reflect the new store preference, which constitutes the modified dialogue sequence. | Second Claim ¶10 | col. 9:3-9 |
Identified Points of Contention
- Scope Questions: A primary question may be whether standard client-server data synchronization, such as sending a JSON object to update a user preference, constitutes the claimed "receiving... a terminal dialogue module that updates... code." The defense may argue that a "dialogue module" as described in the patents is a specific, structured set of instructions intended to modify application logic, not simply a data object reflecting a new state.
- Technical Questions: The infringement theory relies on mapping the Android/iOS runtime environment to the patents' distinction between "computer-executable instructions" and "code." A key technical question will be whether the Android Runtime (ART) can be properly characterized as solely "computer-executable instructions" and the app's bytecode as "code that must be translated," or if the operation of a modern just-in-time (JIT) compiler blurs this distinction beyond the scope of the claims.
V. Key Claim Terms for Construction
- The Term: "dialogue module"
- Context and Importance: This term is central to the invention, as it represents the lightweight update package that is the focus of the claims. Whether the JSON data packets used by the Accused System meet this definition will be a critical point of dispute. Practitioners may focus on this term because the patents and a prior court ruling describe it as a "particular type of structure," suggesting it may be more than a generic data object (Compl. ¶22).
- Intrinsic Evidence for Interpretation:
- Evidence for a Broader Interpretation: The complaint cites a prior construction of "code or instructions related to a dialogue sequence," which could arguably encompass JSON data that dictates the next step in a user interface flow (Compl. ¶20).
- Evidence for a Narrower Interpretation: The patent figures depict the "dialogue module" as a distinct component (e.g., ’140 Patent, Fig. 2, item 202) containing "code," which may suggest a more formalized structure than a simple data packet. The specification describes it as adapting an application to "display a further prompt," potentially limiting it to data that directly controls UI flow (Compl. ¶21).
- The Term: "code"
- Context and Importance: The patents' inventive concept hinges on the separation of an application into stable "instructions" and updatable "code." The complaint's theory maps app bytecode to this term, making its construction determinative.
- Intrinsic Evidence for Interpretation:
- Evidence for a Broader Interpretation: The complaint cites a prior construction of "information that must be translated before it can be executed on a processor" (Compl. ¶18, fn. 6). This definition appears to cover bytecode, which is interpreted or compiled by a virtual machine (like ART) before execution on the physical processor. The specification also gives "Java Byte Code" as an example of "intermediate code" (’140 Patent, col. 7:56-61).
- Evidence for a Narrower Interpretation: A defendant might argue that the context of the patent, particularly its discussion of "source code" being "recompiled or translated," suggests "code" refers to a higher-level script or configuration file, not a compiled intermediate language like bytecode (’140 Patent, col. 2:25-31).
VI. Other Allegations
- Indirect Infringement: The complaint alleges inducement by asserting that Defendant provides user manuals and instructions that direct customers to download and operate the accused apps in an infringing manner (Compl. ¶43, 45). It alleges contributory infringement on the basis that the Accused System is not a staple article of commerce and is especially adapted to perform the patented methods (Compl. ¶46).
- Willful Infringement: The allegation of willfulness is based on Defendant having actual knowledge of the patents "at least since the filing of this complaint," which suggests a theory of post-filing willfulness rather than pre-suit knowledge (Compl. ¶32).
VII. Analyst’s Conclusion: Key Questions for the Case
- A core issue will be one of definitional scope: Can the term "dialogue module," which a prior court found to be a "particular type of structure," be construed to cover the JSON data objects used by the accused mobile apps for routine state updates, or does the patent require a more complex, instruction-bearing entity?
- A key technical question will be one of architectural mapping: Does the relationship between a modern mobile operating system's runtime environment (e.g., Android's ART) and an application's bytecode present the same technical structure as the patents' claimed division between "computer-executable instructions" that run "directly on a processor" and "code" that "must be translated"?