Declarative API for Software Module Customization Without Code Rewrites

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

Modifying software modules in existing applications is challenging due to hardcoded implementations, which require rewriting source code, leading to conflicts and inefficiencies in low or no-code environments, and there is a need for tools that allow customization while maintaining performance and functionality.

Innovation Solution

Implementing a declarative application programming interface (API) that allows modifications through declarative API calls, converting modules to a data interchange format like JSON, and using a schema to validate and resolve conflicts, ensuring compatibility and adherence to predefined rules.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Adaptability or versatility

If software modules are modified using traditional methods with hardcoded implementations, then source code can be altered to change behavior, but this requires rewriting source code which leads to conflicts and inefficiencies

Engineering Contradiction:

Improvecustomization capabilityVSAvoidcode rewriting complexity

Core Design Contradiction:

Adaptability or versatilityVSDevice complexity

Solution Approach 1:

The patent extracts the module definition from hardcoded source code and separates it into an external configuration file (e.g., JSON format). This allows the module's behavior, properties, and metadata to be defined externally without modifying the application source code, thereby enabling customization while avoiding code rewriting complexity

Inventive Principle:

Principle #2Taking out (Extraction)

Solution Approach 2:

The patent merges the module configuration with the application runtime by implementing a module loader that dynamically loads and executes modules from external configuration files. This integration allows the application to adapt its behavior based on external module definitions without requiring source code modifications

Inventive Principle:

Principle #5Merging (Combining)

2Adaptability or versatility

If software modules are modified by rewriting source code, then functionality can be extended, but conflicts arise between modified modules and existing code

Engineering Contradiction:

Improvefunctionality extensionVSAvoidcode conflict stability

Core Design Contradiction:

Adaptability or versatilityVSReliability

Solution Approach 1:

The patent segments the software system into distinct modules that can be independently defined, loaded, and executed. Each module is self-contained with its own configuration, reducing interdependencies and minimizing conflicts between modules and existing code

Inventive Principle:

Principle #1Segmentation

Solution Approach 2:

The patent introduces a module loader and configuration system as an intermediary layer between the application and the modules. This intermediary manages module loading, validation, and execution, ensuring that module extensions do not directly conflict with existing code but are properly integrated through controlled interfaces

Inventive Principle:

Principle #24Intermediary (Mediator)

3Adaptability or versatility

If traditional development tools are used to modify software applications, then functionality can be customized, but the process becomes time-consuming and inefficient in low or no-code environments

Engineering Contradiction:

Improvecustomization capabilityVSAvoidmodification time

Core Design Contradiction:

Adaptability or versatilityVSLoss of time

Solution Approach 1:

The patent replaces the mechanical process of manual source code editing with an automated configuration system. Module definitions are specified in external configuration files that are automatically parsed and loaded by the module loader, eliminating the need for manual code writing and compilation

Inventive Principle:

Principle #28Mechanics substitution (Replace mechanical system)

Solution Approach 2:

The patent enables customization through parameter-based configuration rather than code modification. By changing parameters in external configuration files (such as module properties, dependencies, and behavior settings), users can quickly adapt functionality without time-consuming development processes

Inventive Principle:

Principle #35Parameter changes

Data Source

PatentUS20250355733A1Modifying software modules using a declarative application programming interface

Publication Date: 2025.11.20 TWILIO INC

AI summary

A request to import a software module into an application having a graphical user interface (GUI) is received from a client device and by a software as a service (SaaS) platform. The software module is to modify the GUI of the application and written in a first format. A request to modify the software module is received via an application programming interface (API) call of a declarative API. The request identifies a software module modification written in a second format. The GUI of the application is provided for presentation based at least on the application and the software module modification in the second format.