DCT
8:25-cv-01889
Smartsuite Holdings Inc v. Codeblox LLC
I. Executive Summary and Procedural Information
- Parties & Counsel:
- Plaintiff: SmartSuite Holdings, Inc. (Delaware)
- Defendant: CodeBlox, LLC (Florida)
- Plaintiff’s Counsel: King & Spalding LLP
- Case Identification: 8:25-cv-01889, C.D. Cal., 08/25/2025
- Venue Allegations: Plaintiff SmartSuite asserts that venue is proper because Defendant CodeBlox is subject to personal jurisdiction in the district, having established minimum contacts by sending demand letters and a draft complaint threatening patent litigation into the Central District of California.
- Core Dispute: Plaintiff seeks a declaratory judgment that its SmartSuite work management platform does not infringe two patents owned by Defendant related to graphical user interface-driven application development environments.
- Technical Context: The technology at issue falls within the low-code/no-code software sector, which enables users without formal programming training to build and deploy custom applications through visual interfaces.
- Key Procedural History: This action was precipitated by demand letters from CodeBlox to SmartSuite on January 30, 2025, and June 20, 2025, the latter of which included a draft complaint alleging infringement. After SmartSuite provided non-infringement arguments on August 22, 2025, and CodeBlox did not withdraw its assertions, SmartSuite filed this complaint seeking a judicial declaration of non-infringement.
Case Timeline
| Date | Event |
|---|---|
| 2018-05-09 | Priority Date for ’889 and ’370 Patents |
| 2021-01-01 | SmartSuite founded (year only provided) |
| 2022-03-08 | U.S. Patent No. 11,269,889 Issues |
| 2023-11-28 | U.S. Patent No. 11,829,370 Issues |
| 2025-01-30 | CodeBlox sends first demand letter |
| 2025-06-20 | CodeBlox sends second demand letter with draft complaint |
| 2025-08-22 | SmartSuite sends non-infringement letter to CodeBlox |
| 2025-08-25 | Complaint for Declaratory Judgment filed |
II. Technology and Patent(s)-in-Suit Analysis
U.S. Patent No. 11,829,370 - "Graphical User Interface Driven Programming Development Environment," issued November 28, 2023 (’370 Patent)
The Invention Explained
- Problem Addressed: The patent’s background section describes the significant cost, complexity, and specialized expertise required to develop custom software applications for businesses, noting that individuals with the necessary programming skills are often difficult to find and expensive to hire (’370 Patent, col. 1:20-37).
- The Patented Solution: The invention is a development environment that allows non-expert users to build applications using point-and-click visual tools. This is achieved through a metadata-driven architecture where user-defined data structures and logic are stored as metadata descriptions in a dedicated "metadata database." At runtime, a web service converts this metadata into executable software code, bypassing traditional compilation and deployment steps. This architecture is described as separating the application definitions (metadata) from the end-user data, which is stored in a "user database" (’370 Patent, Abstract; col. 4:13-24).
- Technical Importance: This approach aims to democratize software development by enabling business users to create and modify applications rapidly in response to changing needs, without relying on professional programmers (’370 Patent, col. 1:38-44).
Key Claims at a Glance
- The complaint focuses on independent Claim 1 (Compl. ¶25).
- Claim 1 of the ’370 Patent recites a system comprising essential elements including:
- a metadata database storing application data elements and metadata structures;
- a user database storing user-defined values;
- a processor and memory with instructions to perform operations;
- providing a web service to receive updated values;
- retrieving application data elements from the metadata database;
- parsing the data elements to update a value;
- storing the updated data element in either the metadata or user database;
- automatically generating an update statement; and
- allowing for code execution "without using any software deployment processing" like compilation or linking.
- The complaint denies infringement of independent claim 1 "or any other claim" of the ’370 Patent (Compl. ¶26).
U.S. Patent No. 11,269,889 - "Graphical User Interface Driven Programming Development Environment," issued March 8, 2022 (’889 Patent)
The Invention Explained
- Problem Addressed: Similar to the ’370 Patent, the background identifies the high barrier to entry for conventional software development due to the need for deep programming knowledge (’889 Patent, col. 1:20-37).
- The Patented Solution: This patent also describes a GUI-based, metadata-driven development environment. The solution architecture is further detailed to include a metadata database (e.g., NoSQL) and a separate relational database for user data, as depicted in Figure 1. The system converts metadata into user-defined behavior in real-time using backend processing elements and an "intelligent data flow." This flow involves a series of specific steps including receiving user requests via a REST API, dynamically generating SQL queries, retrieving metadata from NoSQL storage, and dynamically generating C# code elements (’889 Patent, Abstract; col. 10:18-col. 11:24).
- Technical Importance: The invention provides a detailed technical blueprint for a low-code/no-code platform, focusing on the real-time, automated translation of abstract user definitions into specific, executable database queries and software code (’889 Patent, col. 4:46-52).
Key Claims at a Glance
- The complaint references Claim 1, the only independent claim in the patent (Compl. ¶34).
- Claim 1 of the ’889 Patent recites a system comprising essential elements including:
- processors and memory;
- a metadata database storing an application data element in a data serialization format;
- a web service for receiving, retrieving, and parsing updated values;
- a relational database of user data configured to store the data element in a table;
- metadata stored in a dedicated repository to dynamically arrange software code;
- backend processing elements that convert metadata in real-time;
- integration with third-party systems; and
- an "intelligent data flow" with numerous specific steps, including use of a REST API, dynamic SQL generation, retrieval of metadata from a NoSQL location, and dynamic generation of C# code elements and an SQL update statement.
- The complaint denies infringement of any claims of the ’889 Patent (Compl. ¶33).
III. The Accused Instrumentality
Product Identification
The "SmartSuite work management platform," a software-as-a-service ("SaaS") product delivered to subscribers through internet browsers and mobile applications (Compl. ¶20).
Functionality and Market Context
The platform is described as providing an "intuitive, configurable user interface" that allows customers to create custom views, templates, and dashboards for managing business processes (Compl. ¶20). A screenshot provided in the complaint shows a project management interface for a "First Quarter Plan" with fields for owner, status, due date, and priority (Compl. p. 6). The complaint states the platform "unites essential elements used to get work done, regardless of company size or type" (Compl. ¶19).
IV. Analysis of Infringement Allegations
’370 Patent Infringement Allegations
| Claim Element (from Independent Claim 1) | Alleged Infringing Functionality | Complaint Citation | Patent Citation |
|---|---|---|---|
| a metadata database storing a plurality of application data elements... and a plurality of metadata structures... | The complaint alleges that CodeBlox failed to identify any such dual-database architecture, instead pointing to "Tables" from SmartSuite's help center to meet both this limitation and the user database limitation. | ¶27 | col. 7:12-16 |
| a user database storing user data, wherein the user data comprising a plurality of user-defined values | The complaint alleges that SmartSuite does not use a separate user database as claimed and that CodeBlox's allegations improperly cite to the same product feature ("Tables") used for the "metadata database" limitation. | ¶27 | col. 7:17-19 |
| application data elements... metadata structures... user-defined values | The complaint asserts that CodeBlox "never identified where SmartSuite uses" these claimed data types or what features of the accused product allegedly meet these limitations. | ¶27 | col. 7:12-16 |
Identified Points of Contention:
- Scope Questions: The primary dispute appears to concern claim scope and factual correspondence. A central question will be whether the terms "a metadata database" and "a user database" require two structurally distinct and separate databases, as SmartSuite's argument implies, or if they can be read to cover logically separated data schemas within a single, unified database system.
- Technical Questions: Does the SmartSuite platform, in its actual operation, segregate application-defining data (metadata) from user-entered data in a manner that maps onto the claimed dual-database architecture? The complaint suggests a fundamental architectural mismatch.
’889 Patent Infringement Allegations
| Claim Element (from Independent Claim 1) | Alleged Infringing Functionality | Complaint Citation | Patent Citation |
|---|---|---|---|
| a metadata database configured to store an application data element... a relational database of user data configured to store the data element... | The complaint reiterates its argument that the accused product lacks the claimed "dual database structure." | ¶35 | col. 9:25-27; col. 10:6-8 |
| a data serialization format | The complaint asserts that CodeBlox has not shown that SmartSuite practices the "data serialization format" requirement. | ¶35 | col. 9:26-27 |
| wherein an intelligent data flow includes... a web service retrieves metadata structures... from a NoSQL storage location | The complaint states that CodeBlox has not addressed the specific use of a "NoSQL storage location" by the accused product. | ¶35 | col. 10:27-28 |
| wherein an intelligent data flow includes... expressions defined in the metadata are used to dynamically generate C # code elements | The complaint alleges that CodeBlox has provided no evidence that the accused product "dynamically generate[s] C # code elements." | ¶35 | col. 11:1-2 |
Identified Points of Contention:
- Scope Questions: Beyond the recurring dual-database issue, a key question is whether the highly detailed, multi-step "intelligent data flow" limitation in Claim 1 must be practiced exactly as recited, or if some steps can be considered exemplary.
- Technical Questions: What evidence does the complaint suggest is missing to show that the SmartSuite platform performs specific technical functions required by the claim, such as generating C# code in real-time or retrieving metadata from a NoSQL database as part of its data update process? The complaint frames these as unproven assertions by the patentee (Compl. ¶35).
V. Key Claim Terms for Construction
The Term: "a metadata database" / "a user database" (and "a relational database of user data" in the ’889 Patent)
Context and Importance
The interpretation of these terms appears central to SmartSuite's non-infringement defense for both patents. The complaint alleges a failure by CodeBlox to identify two distinct databases in the accused product (Compl. ¶27, ¶35). Practitioners may focus on whether the claims require physically or logically separate database systems, or if distinct tables or schemas within one database would suffice.
Intrinsic Evidence for Interpretation
- Evidence for a Broader Interpretation: The claims use the indefinite article "a," which can mean "one or more" and does not necessarily require structural separation. A patentee could argue that as long as the functions of a metadata store and a user data store are performed, the claim is met, even within a single database instance.
- Evidence for a Narrower Interpretation: Both patents' specifications and figures appear to consistently teach two separate entities. Figure 1 of the ’889 Patent explicitly depicts "Meta Data" (122) and "User Data" (120) as distinct architectural components (’889 Patent, Fig. 1). The description also refers to them as separate databases (e.g., "a metadata database 122" and "a user database 120") (’889 Patent, col. 5:51-53, col. 6:21-23).
The Term: "dynamically generate C # code elements"
Context and Importance
This limitation appears in the lengthy "intelligent data flow" clause of Claim 1 of the ’889 Patent and is a specific technical implementation detail that SmartSuite alleges is not practiced by its platform (Compl. ¶35). The dispute may hinge on whether the accused system's method for real-time execution of user-defined logic is technically equivalent to generating C# code.
Intrinsic Evidence for Interpretation
- Evidence for a Broader Interpretation: A patentee might argue that "C #" is illustrative and the true invention is the dynamic generation of any form of executable object code or intermediate language from metadata at runtime. The specification states the code is converted to "underlying software code (e.g., C#, SQL, JavaScript, etc.)" (’889 Patent, col. 4:22-23), which could support an argument that C# is just one example.
- Evidence for a Narrower Interpretation: Claim 1 explicitly recites "C # code elements" without the "e.g." qualifier found in the specification. A party arguing for non-infringement would likely contend that this plain language limits the claim to systems that specifically generate C# code, and not other languages or interpretive methods.
VI. Other Allegations
- Indirect Infringement: SmartSuite seeks a declaration of non-infringement with respect to indirect infringement (contributory and inducement) for both patents-in-suit (Compl. ¶31, ¶39). However, the complaint does not detail any specific factual allegations made by CodeBlox that would form the basis for such claims.
- Willful Infringement: Not applicable, as this is a complaint for declaratory judgment of non-infringement brought by the accused infringer.
VII. Analyst’s Conclusion: Key Questions for the Case
This declaratory judgment action appears poised to center on two fundamental types of disputes: one of architectural mismatch and one of functional specificity.
- A core issue will be one of architectural scope: Do the claims, which recite "a metadata database" and a separate "user database," require two distinct database systems? The resolution will depend on claim construction and a factual analysis of whether the SmartSuite platform’s data management architecture falls within that scope.
- A key evidentiary question will be one of functional implementation: For the ’889 patent in particular, does the accused platform perform the highly specific, multi-step process claimed as an "intelligent data flow," including the explicit requirement to "dynamically generate C # code elements"? The case may turn on whether SmartSuite's method for achieving a low-code environment is technically distinguishable from the precise method claimed in the patent.