DCT

6:24-cv-00312

S3G Technology LLC v. Supercuts Inc

Key Events

Complaint

I. Executive Summary and Procedural Information

Parties & Counsel:
- Plaintiff: S3G Technology LLC (California)
- Defendant: Supercuts, Inc. (Delaware)
- Plaintiff’s Counsel: PARKER, BUNT & AINSWORTH, P.C.
Case Identification: 6:24-cv-00312, W.D. Tex., 06/10/2024
Venue Allegations: Plaintiff alleges venue is proper in the Western District of Texas because Defendant Supercuts, Inc. maintains regular and established places of business within the district, including two specified physical locations in Waco, Texas.
Core Dispute: Plaintiff alleges that Defendant’s mobile application and associated backend systems for salon check-in infringe three patents related to methods for efficiently modifying software on remote devices using an update server.
Technical Context: The patents address the challenge of updating client-server applications over networks with limited bandwidth, a key technical consideration in the architecture of modern mobile and web services.
Key Procedural History: The complaint notes that terms from the asserted patent family were previously construed in litigation before the Eastern District of Texas (S3G Tech. LLC v. Unikey Techs., Inc.). It also references a Notice of Allowability from a related patent’s prosecution, where an Examiner found the claimed structure to be non-obvious over the prior art. This prior judicial and administrative review may inform arguments regarding claim scope and validity.

Case Timeline

Date	Event
2009-07-23	Earliest Priority Date for ’124, ’468, and ’082 Patents
2018-04-10	U.S. Patent No. 9,940,124 Issues
2020-11-10	U.S. Patent No. 10,831,468 Issues
2021-12-28	U.S. Patent No. 11,210,082 Issues
2024-06-10	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 (Compl. ¶10).

The Invention Explained

Problem Addressed: The patent addresses the difficulty and inefficiency of updating software applications distributed across a large number of remote devices, particularly over wireless networks. Distributing a newly compiled version of an entire application can be slow, consume excessive bandwidth, and be difficult to manage across different application versions. (Compl. ¶¶14-15; ’124 Patent, col. 2:39-64).
The Patented Solution: The invention proposes a three-entity system architecture: a terminal machine (e.g., a mobile device), a service provider machine (e.g., a backend server), and an update server machine. Applications on the terminal and service provider machines are structured to separate their core "computer-executable instructions" from a distinct set of "code" that must be translated before execution. To modify the application's behavior, the update server sends a small "dialogue module" containing only new or updated "code." This modifies the application's dialogue sequence without requiring a full replacement of the application's executable instructions, thereby saving bandwidth and improving efficiency. (Compl. ¶¶16-17; ’124 Patent, Abstract, col. 4:30-40). The complaint includes a diagram from the patent, Figure 1, illustrating the communication paths between the update server, service provider machine, and terminal machine. (Compl. ¶16, p. 8).
Technical Importance: This architectural approach provides a method for granular, lightweight software updates, a crucial capability for managing the lifecycle of modern mobile applications in a networked environment. (Compl. ¶25).

Key Claims at a Glance

The complaint asserts at least independent claim 1. (Compl. ¶32).
The essential elements of independent claim 1, a method claim, include:
- Displaying a first prompt on a terminal display by running a terminal application that comprises "first computer-executable instructions" and "first code."
- Accepting a first data entry at the terminal machine.
- Communicating information from the terminal machine to a service provider machine running a provider application that comprises "second computer-executable instructions" and "second code."
- Storing at least a portion of the communicated information.
- 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 "first code," "second code," or "first updated code" comprises "intermediate code."

U.S. Patent No. 10,831,468 - "Modification of Terminal and Service Provider Machines Using an Update Server Machine"

Patent Identification: U.S. Patent No. 10,831,468, "Modification of Terminal and Service Provider Machines Using an Update Server Machine," issued November 10, 2020 (Compl. ¶11).

The Invention Explained

Problem Addressed: As a continuation of the same patent family, the ’468 Patent addresses the same technical problem of inefficiently distributing large, fully recompiled software updates to numerous remote devices over bandwidth-constrained networks. (Compl. ¶¶13-15; ’468 Patent, col. 2:8-67).
The Patented Solution: The solution is materially similar to that of the ’124 Patent, centered on a three-entity architecture where applications are bifurcated into executable instructions and translatable "code." Updates are delivered as small packages of new code that modify, rather than wholly replace, the application's functionality. (Compl. ¶¶16-18; ’468 Patent, Abstract). The complaint provides Figure 2 from the patent, which depicts the distinct structure of the applications, each comprising computer-executable instructions (214, 224) and code (212, 222). (Compl. ¶17, p. 8).
Technical Importance: The invention aims to reduce network bandwidth consumption and enable efficient modification of applications running on remote devices. (Compl. ¶25).

Key Claims at a Glance

The complaint asserts at least independent claim 1. (Compl. ¶51).
The essential elements of independent claim 1, a method claim, include:
- Displaying a first prompt by running a terminal application comprising "first computer-executable instructions" and "first code," where the first code comprises information to be translated.
- Receiving entry of first data.
- Communicating information to a provider application comprising "second computer-executable instructions" and "second code," where the second code also comprises information to be translated and the terminal application can receive an authorization signal.
- Receiving, at the terminal machine, "third code that replaces or supplements at least a portion but not all of the first code" to produce "first updated code."
- The "first updated code" adapts the terminal application to conduct a modified dialogue sequence.

U.S. Patent No. 11,210,082 - "Modification of Terminal and Service Provider Machines Using an Update Server Machine"

Multi-Patent Capsule: U.S. Patent No. 11,210,082
- Patent Identification: U.S. Patent No. 11,210,082, "Modification of Terminal and Service Provider Machines Using an Update Server Machine," issued December 28, 2021. (Compl. ¶12).
- Technology Synopsis: This patent is from the same family and addresses the problem of inefficient software updates in distributed systems. The claims focus on the method performed by the service provider machine, which involves receiving information associated with a dialogue, receiving "second code" that supplements or partially replaces its existing code to adapt its portion of a dialogue, and sending "third code" to a recipient to facilitate a modified dialogue sequence. (Compl. ¶¶13-16, 78, 81-82).
- Asserted Claims: The complaint asserts at least independent claim 1. (Compl. ¶76).
- Accused Features: The accused features are Defendant's backend servers, which allegedly run a .NET provider application. This application is accused of receiving user data from the mobile app, receiving updated "code" (allegedly in JSON format), and sending new dialogue information back to the user's mobile app to facilitate an updated user interaction. (Compl. ¶¶78-82).

III. The Accused Instrumentality

Product Identification

Product Identification: The accused instrumentalities are Defendant’s mobile applications for the Android and iOS platforms, identified as the "Defendant app," and the associated backend systems, including servers and software, that support the app's functionality (collectively, the "Accused System"). (Compl. ¶8).

Functionality and Market Context

Functionality and Market Context: The complaint identifies the core accused functionality as the system that allows a user to "review guest list items and edit or delete those items," which implies a salon check-in or appointment management feature. (Compl. ¶34). This system allegedly operates via communication between the user's mobile device (the "terminal machine") and Defendant's servers (the "service provider machine"). (Compl. ¶33). The complaint alleges that updates to the guest list are sent from the server to the mobile app in JSON format, which it contends constitutes a "terminal dialogue module" that updates the app's code to reflect new information and enable a modified user dialogue. (Compl. ¶38).

IV. Analysis of Infringement Allegations

9,940,124 Patent Infringement Allegations

Claim Element (from Independent Claim 1)	Alleged Infringing Functionality	Complaint Citation	Patent Citation
displaying a first prompt on a terminal display of a terminal machine ... by running a terminal application, the terminal application comprising first computer-executable instructions and first code that conduct the terminal machine's portion of the dialogue	The Supercuts app on a user's smartphone displays prompts for a user to review or edit guest list items. The app allegedly comprises computer-executable instructions (Android Runtime) and first code (the app's bytecode).	¶34	col. 7:56-61
communicating information associated with the first data entry from the terminal machine to the service provider machine, wherein the service provider machine uses a provider application comprising second computer-executable instructions and second code	Information from the user's edits to the guest list is sent from the smartphone to Defendant's server. The server allegedly runs a .NET provider application comprising executable instructions (Common Language Runtime) and second code (.Net program code).	¶36	col. 7:42-49
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 Supercuts app allegedly receives a "terminal dialogue module," described as information in JSON format, from the server. This module is alleged to update the app's first code (bytecode) to produce updated code.	¶38	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 allegedly enables the app to display new prompts, such as the ability to access new guest list items.	¶38	col. 9:4-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.	¶38	col. 1:65-2:2

Identified Points of Contention:

Scope Questions: A central question may be whether receiving and processing a standard data payload, such as a JSON object containing guest list information, constitutes "receiving... a terminal dialogue module that updates... the first code" as claimed. The dispute may turn on whether the patent's language requires a modification of the application's underlying program logic itself, rather than the routine processing of data by existing, unchanged logic.
Technical Questions: The infringement theory appears to equate an application's bytecode with the claimed "first code" and a JSON data payload with a "terminal dialogue module." A key technical question will be whether, as a matter of software architecture, a JSON payload actually "updates" an application's bytecode, or if the bytecode (as part of the compiled application) simply contains the logic to parse and display the data contained within the JSON payload.

10,831,468 Patent Infringement Allegations

Claim Element (from Independent Claim 1)	Alleged Infringing Functionality	Complaint Citation	Patent Citation
displaying a first prompt ... by running a terminal application comprising first computer-executable instructions and first code ... wherein the first code comprises information to be translated	The Supercuts app prompts a user regarding guest list items. The app is alleged to comprise executable instructions (Android Runtime) and first code (app program/bytecode) that comprises information to be translated.	¶53	col. 4:32-35
communicating information associated with the first data ... to a provider application at the service provider machine ... wherein (ii) the terminal application is capable of receiving an authorization signal from the service provider machine	User data is sent to the provider application on the server. The terminal application is allegedly capable of receiving an authorization signal, for example, by authorizing logging into the system.	¶55	col. 10:45-51
receiving, at the terminal machine, third code that replaces or supplements at least a portion but not all of the first code to produce first updated code	The app receives data (allegedly "third code" in JSON format) from the server. This data allegedly supplements a portion of the app's existing code (the "first code") to produce updated code for displaying new guest list items, without replacing the entire application.	¶56	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 updated code allows the app to conduct a modified dialogue, evidenced by the user's ability to access new guest list items.	¶56	col. 3:29-34

Identified Points of Contention:

Scope Questions: Similar to the ’124 Patent, the analysis will likely focus on whether the term "third code" can be construed to read on a standard data format like JSON. Further, the requirement that this "code" replaces or supplements the "first code" raises the question of whether this requires a direct modification of the application's bytecode file or if it can be satisfied by in-memory data processing.
Technical Questions: What evidence does the complaint provide that the received JSON data supplements the app's bytecode "but not all of" it? This limitation suggests a specific, partial update mechanism that may differ from how a standard mobile application ingests and renders data from an API endpoint.

V. Key Claim Terms for Construction

The Term: "code"
Context and Importance: The distinction between "computer-executable instructions" (allegedly the Android Runtime) and "code" (allegedly the app's bytecode) is foundational to the patent's claimed architecture. The construction of "code" will be critical to determining if the patent applies to standard mobile app development. The complaint cites a prior construction from related litigation: "information that must be translated before it can be executed on a processor." (Compl. ¶18, n.6). Practitioners may focus on whether this definition encompasses simple data payloads (like JSON) or is limited to forms of program logic (like script or bytecode).
Intrinsic Evidence for Interpretation:
- Evidence for a Broader Interpretation: The specification states that "code represents at least some information that must be translated by the software application before it can be implemented on the machine processor." (’124 Patent, col. 4:33-35). This language could be argued to be broad enough to cover data structures that require parsing (a form of translation) before being used by the processor.
- Evidence for a Narrower Interpretation: The specification repeatedly contrasts "code" with "computer-executable instructions" and describes it as one of two fundamental components of the software application's structure (e.g., elements 222 and 224 in Fig. 2). This suggests "code" refers to a part of the application program itself, not merely external data that the program processes. (’124 Patent, col. 7:56-61).
The Term: "dialogue module"
Context and Importance: Plaintiff’s infringement theory hinges on the allegation that a JSON data payload is a "dialogue module." (Compl. ¶38). Whether this interpretation is viable will depend on the construction of this term. The complaint notes a prior judicial interpretation that the term refers to "a particular type of structure rather than to any structure for performing a function." (Compl. ¶21).
Intrinsic Evidence for Interpretation:
- Evidence for a Broader Interpretation: The patent states that a dialogue module "may include portions of code and/or instructions." (’124 Patent, col. 7:38-40). The use of "and/or" could support an argument that a module consisting only of "code"—which under a broad construction could be data—is contemplated.
- Evidence for a Narrower Interpretation: The primary purpose of the dialogue module is to "adapt[] the terminal application to use a second sequence of prompts and a second sequence of data entries." (’124 Patent, col. 3:29-34). This suggests the module's function is to alter the logical flow and behavior of the application, a function that may go beyond merely providing data for display.

VI. Other Allegations

Indirect Infringement: The complaint alleges inducement of infringement based on Defendant marketing its app, providing it on app stores, and providing instructions that encourage users to download and operate the app in an infringing manner. (Compl. ¶¶42, 44, 67, 69).
Willful Infringement: The complaint alleges willful infringement based on Defendant's knowledge of the patents "at least since the filing of this complaint." (Compl. ¶¶31, 50, 75). This is a claim for post-suit willfulness.

VII. Analyst’s Conclusion: Key Questions for the Case

A core issue will be one of definitional scope: can the patent family's specific architectural terms, such as "code" and "dialogue module," which were conceived in the context of modifying application logic, be construed to cover the routine exchange of data, such as JSON payloads, in a modern client-server mobile application?
A key evidentiary question will be one of technical mechanism: does the accused Supercuts system, in processing data from its servers to update a list in its mobile app, actually perform the claimed step of "updating" the application's underlying "code" (e.g., its bytecode), or is there a fundamental mismatch between the patented method of modifying application structure and the accused method of processing application data?