Template-Driven Architecture With Client-Side JSON Schema Rendering
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Large enterprises face challenges in dynamically validating content changes on user-facing web pages while optimizing computing resources and network bandwidth for their server infrastructure.
Innovation Solution
A template-driven interface system with a parsing engine that renders web forms in real-time using JSON schemas, allowing for framework-agnostic adaptive development and real-time template updates, leveraging a computing device with processors, memory, and communication interfaces to manage and decommission assets.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If real-time template updates are implemented using conventional server-side rendering, then web page content can be dynamically validated against schema, but network bandwidth and server computing resources are excessively consumed
Solution Approach 1:
The patent extracts the template rendering function from the server and places it on the client device. The server only sends the template definition (JSON schema) and data, while the client device's processor generates the actual HTML output locally. This extraction eliminates the need for the server to send complete rendered pages and enables real-time validation without excessive network bandwidth consumption.
Solution Approach 2:
The patent introduces a template engine as an intermediary component that runs on the client device. This intermediary receives template definitions and data from the server, performs local rendering and validation, and displays results without requiring continuous server communication for each validation event, thus reducing network bandwidth usage while maintaining dynamic validation capability.
2Reliability
If real-time template updates are implemented using conventional server-side rendering, then web page content can be dynamically validated against schema, but server computing resources are excessively consumed
Solution Approach 1:
The patent extracts the computationally intensive template rendering operation from the server and executes it on the client device. The server only performs lightweight operations of sending template definitions and data, while the client device's processor handles the heavy lifting of HTML generation and schema validation, significantly reducing server computing resource consumption.
Solution Approach 2:
The patent enables the client device to self-serve by implementing a local template engine that can independently render templates and validate content against schemas without requiring server-side processing. This self-service capability allows real-time validation to occur client-side, eliminating the need for server computing resources to be consumed for each validation event.
3Productivity
If framework-specific template engines are used, then template rendering can be performed efficiently, but the system lacks adaptability to different service providers and asset schemas
Solution Approach 1:
The patent implements a universal template engine that can process templates from multiple different service providers and handle various asset schemas without requiring framework-specific implementations. The engine uses a standardized JSON schema format that can represent different template structures, enabling a single rendering engine to efficiently handle diverse template sources while maintaining adaptability.
Solution Approach 2:
The patent employs parameter changes by using a flexible JSON schema structure that can be configured to represent different template frameworks and service provider formats. The template engine adjusts its rendering parameters based on the incoming schema definition, allowing it to efficiently render templates from different sources without requiring separate framework-specific engines, thus achieving both efficiency and adaptability.
Data Source
AI summary
Aspects of the disclosure relate to a template driven interface system having a parsing engine that may dynamically render web forms given a specification document. In some instances, the architecture may leverage the specification document and enable creation, management, and eventual decommissioning actions. The architecture may be framework-agnostic, allowing for adaptive and agile development of end user interfaces for services developed by different entities or product providers. The different entities may be external entities having control over their assets and related asset schemas. The architecture may allow for real-time updates as compared to scheduled release cycles.