S3G Technology LLC v. Skechers USA Inc

I. Executive Summary and Procedural Information

• Parties & Counsel:
  • Plaintiff: S3G Technology LLC (California)
  • Defendant: Skechers USA, Inc. (Delaware)
  • Plaintiff’s Counsel: Parker, Bunt & Ainsworth, P.C.
• Case Identification: 6:23-cv-00126, W.D. Tex., 02/16/2023
• Venue Allegations: Plaintiff alleges venue is proper in the Western District of Texas because Defendant maintains a regular and established place of business in the district, including a retail store in Waco, and distributes the accused mobile applications to customers within the district.
• Core Dispute: Plaintiff alleges that Defendant’s mobile e-commerce applications and associated backend systems infringe three patents related to methods for efficiently modifying software on remote devices.
• Technical Context: The technology addresses the challenge of updating client-server applications over networks with limited bandwidth by sending small, lightweight "dialogue modules" to alter application behavior, rather than transmitting entire replacement applications.
• Key Procedural History: The complaint references prior litigation involving the asserted patents, citing claim constructions for key terms such as "code" and "dialogue module" that were adopted by the court in S3G Tech. LLC v. Unikey Techs., Inc. The complaint also cites the prosecution history, quoting from a Notice of Allowability to argue the claimed invention was considered novel and non-obvious over the prior art.

Case Timeline

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"

The Invention Explained

• Problem Addressed: The patent addresses the technical problem of efficiently updating software applications distributed across numerous remote devices, particularly over bandwidth-constrained or slow wireless networks (Compl. ¶¶ 12-14; ’140 Patent, col. 2:17-3:2). Distributing large, newly recompiled application files to many devices is described as difficult, time-consuming, and potentially infeasible (Compl. ¶ 13; ’140 Patent, col. 2:34-43).
• The Patented Solution: The invention proposes a three-entity computer system architecture: a "terminal machine" (e.g., a user's device), a "service provider machine" (e.g., a central server), and an "update server machine" (Compl. ¶ 15; ’140 Patent, Fig. 1). The software applications on the terminal and service provider machines are structured to include two distinct components: directly-executable instructions and "code" that requires translation by the application before it can be executed (Compl. ¶¶ 16-17; ’140 Patent, col. 4:57-64). To modify the application's functionality, the update server sends a small "dialogue module" containing new or updated "code," which allows the application to conduct a modified dialogue without requiring the replacement of the entire application file (Compl. ¶ 19; ’140 Patent, col. 9:41-49). A system diagram in the complaint illustrates this three-entity architecture (Compl. p. 7, Fig. 1).
• Technical Importance: This architectural approach is presented as a way to reduce network bandwidth utilization, thereby enabling more efficient modification and customization of software running on a network of remote devices (Compl. ¶ 23; ’140 Patent, col. 7:31-33).

Key Claims at a Glance

• The complaint asserts at least independent claim 1 ('124 Patent, Compl. ¶ 28).
• Claim 1 is a method claim comprising the following essential elements:
  • Displaying a first prompt on a terminal machine by running a terminal application, which 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, which comprises second computer-executable instructions and second code.
  • Storing at least a portion of the 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 adapts the terminal application to display a second prompt for a modified dialogue sequence.
  • At least one of the first code, second code, and first updated code must comprise intermediate code.
• The complaint does not explicitly reserve the right to assert dependent claims for this patent.

---

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

The Invention Explained

• Problem Addressed: As with the related ’124 Patent, this patent addresses the inefficiency of distributing large, fully recompiled software updates to remote devices over networks with limited data transfer capacity (Compl. ¶¶ 12-14; ’140 Patent, col. 2:17-3:2).
• The Patented Solution: The solution is the same three-entity architecture where applications are composed of both directly-executable instructions and interpretable "code" (Compl. ¶¶ 16-17; ’140 Patent, Fig. 2). Updates are performed by transmitting small "dialogue modules" containing "code" to modify application logic, which avoids the need to send a complete new software package and thereby conserves bandwidth (Compl. ¶ 23; ’140 Patent, col. 15:52-59). A diagram in the complaint shows the application structure, distinguishing between executable instructions (224) and code (222) (Compl. p. 7, Fig. 2).
• Technical Importance: The system is described as improving computing resource and network utilization by enabling efficient modification of distributed applications through small, targeted updates (Compl. ¶ 19; ’140 Patent, col. 7:31-33).

Key Claims at a Glance

• The complaint asserts at least independent claim 1 (’140 Patent, Compl. ¶ 42).
• Claim 1 is a method claim comprising the following essential elements:
  • Displaying a first prompt on a terminal machine via a terminal application comprising first computer-executable instructions and first code.
  • Receiving entry of first data.
  • Communicating information to a provider application on a service provider machine, the 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.
  • The receipt of the third code is performed in response to the terminal machine satisfying a trigger condition.
• The complaint does not explicitly reserve the right to assert dependent claims for this patent.

---

U.S. Patent No. 9,304,758 - "Modification of Terminal and Service Provider Machines Using an Update Server Machine"

• Technology Synopsis: This patent, from the same family as the ’124 and ’140 patents, describes a system and method for updating software on remote devices. It addresses the problem of bandwidth-intensive full-application updates by proposing a system where small "dialogue modules" containing interpretable "code" are sent to modify the behavior of an existing application, which is itself composed of both directly-executable instructions and this interpretable code (Compl. ¶¶ 12, 16).
• Asserted Claims: At least independent claim 1 (Compl. ¶ 61).
• Accused Features: The complaint alleges that the Skechers mobile application system infringes by conducting a dialogue between a user's device and a server, where the application on the device comprises both directly executable instructions and interpretable code (e.g., bytecode). The system is alleged to receive "dialogue modules" (e.g., JSON data) that update a portion of the code to adapt the application for a modified dialogue (Compl. ¶¶ 62-66).

III. The Accused Instrumentality

Product Identification

• The "Accused Instrumentalities" are Defendant's mobile applications for Android and iOS devices (collectively, "Defendant app"), as well as the supporting server systems and software that operate with the apps (Compl. ¶¶ 7-8).

Functionality and Market Context

• The Accused Instrumentalities constitute an e-commerce platform allowing users to browse, manage wish lists, and purchase products (Compl. ¶¶ 30, 44, 63). The complaint identifies the user's smartphone as the "terminal machine" running the Skechers app (the "terminal application") (Compl. ¶ 30). This app communicates with Defendant's servers (the "service provider machine"), which are alleged to run a corresponding backend application (the "provider application"), identified on information and belief as a .NET application (Compl. ¶¶ 32, 46, 65). The complaint alleges that when a user interacts with features like a "wish list," the server sends information in JSON format to the mobile app, which modifies the app's dialogue with the user (Compl. ¶¶ 34, 48, 66).

IV. Analysis of Infringement Allegations

’124 Patent Infringement Allegations

’140 Patent Infringement Allegations

Identified Points of Contention

• Scope Questions: The infringement theory rests on mapping modern mobile software components onto the patent's specific terminology. This raises the question of whether "code" as construed ("information that must be translated before it can be executed") reads on an application's bytecode in the context of the Android Runtime, or on .NET code in the context of the CLR engine. A central dispute may be whether a data-interchange format like JSON constitutes the claimed "dialogue module" or "third code."
• Technical Questions: A key technical question is whether receiving JSON data and using it to render content performs the function of "modifying at least a portion of the first code to produce first updated code." The analysis may turn on evidence of whether the app's underlying bytecode is actually altered, or whether the app simply processes the incoming JSON as data without modifying its own executable or intermediate code structure.

V. Key Claim Terms for Construction

• The Term: "code"

• Context and Importance: This term is foundational to the patent's distinction between two types of software components. The infringement theory depends on classifying elements like an app's bytecode or a server's .NET code as "code," while classifying the respective runtime environments (ART, CLR) as "computer-executable instructions." The complaint cites a prior construction: "information that must be translated before it can be executed on a processor" (Compl. ¶ 16, fn. 5).

• Intrinsic Evidence for Interpretation:

  • Evidence for a Broader Interpretation: The specification describes "code" simply as "at least some information that must be translated by the software application before it can be implemented on the machine processor" (’140 Patent, col. 4:57-60). This broad, functional definition could be argued to encompass various forms of interpreted or just-in-time compiled code.
  • Evidence for a Narrower Interpretation: The patent consistently distinguishes "code" from "computer-executable instructions" which can be "directly executed" (’140 Patent, col. 8:27-32). This distinction, along with specific embodiments like Java Byte Code, may support a narrower definition that excludes certain types of program instructions or simple data structures.

• The Term: "dialogue module"

• Context and Importance: The infringement allegation identifies JSON data sent from Defendant's server as the infringing "dialogue module" or "third code." The viability of this theory hinges on whether a standard data format can be construed as the specific "module" structure claimed by the patents. The complaint cites a prior construction stating the term refers to "a particular type of structure rather than to any structure for performing a function" (Compl. ¶ 20).

• Intrinsic Evidence for Interpretation:

  • Evidence for a Broader Interpretation: The cited prior construction notes that a dialogue module "can contain code or other data and can be communicated" (Compl. ¶ 20, emphasis added). The inclusion of "or other data" may support an argument that the module is not limited to containing only what is strictly defined as "code."
  • Evidence for a Narrower Interpretation: The emphasis in the same prior construction that it is a "particular type of structure" suggests it is not a generic term for any data packet. The specification's depiction of the module as the vehicle for delivering new "code" to modify an application may support an interpretation that requires more than just informational data content (Compl. ¶ 19; ’140 Patent, col. 9:26-49).

VI. Other Allegations

• Indirect Infringement: The complaint alleges inducement on the basis that Defendant promotes its mobile applications and instructs customers to download and run them, knowing that their use in conjunction with Defendant's servers infringes the patents (Compl. ¶¶ 35, 54, 67). Contributory infringement is alleged on the grounds that the Accused Instrumentalities are not staple articles of commerce suitable for substantial non-infringing use and are known by Defendant to be especially adapted for infringement (Compl. ¶¶ 36, 55, 68).
• Willful Infringement: While not pleaded as a separate count, the prayer for relief requests a finding of willful infringement (Compl. p. 26, ¶ C). The allegations of knowledge to support willfulness and inducement are based on knowledge acquired "at least since the filing of this complaint," suggesting a focus on potential post-suit conduct (Compl. ¶¶ 27, 35, 41).

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

• A core issue will be one of technical mapping: can the plaintiff's analogy between the components of a modern mobile application stack (e.g., Android Runtime, app bytecode, JSON data) and the patent's specific, bifurcated software architecture ("computer-executable instructions" versus "code") be sustained through claim construction and expert testimony?
• A key evidentiary question will be one of functional operation: does the accused system's receipt of JSON data to update on-screen content perform the specific claimed function of "modifying... code to produce... updated code," or is there a fundamental operational difference between processing application data and modifying the application's underlying structural code?