Sandboxed Extension Runtime Architecture for Base Applications

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

Customizing software products is time-consuming, poses security risks, and involves performance and interoperability issues, with tight integration limiting extension development and looser coupling leading to less seamless user experiences and performance problems, especially in multi-tenant systems.

Innovation Solution

A software architecture that facilitates extension development by specifying APIs and functionality for extensions, allowing secure execution in a sandboxed environment, supporting different programming languages, and enabling seamless interaction between base applications and extensions through a common format like WebAssembly, with features like caching and asynchronous communication.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Reliability

If extensions are tightly integrated with the base application, then security and performance are improved, but extension development flexibility and interoperability are reduced

Engineering Contradiction:

Improvesecurity and performanceVSAvoidextension development flexibility

Core Design Contradiction:

ReliabilityVSAdaptability or versatility

Solution Approach 1:

The system segments the base application into a runtime environment that executes extensions as separate, isolated units. Each extension is compiled into a distinct module that can be independently developed, deployed, and terminated, allowing tight security control while maintaining development flexibility through modular architecture.

Inventive Principle:

Principle #1Segmentation

Solution Approach 2:

The runtime environment acts as an intermediary layer between the base application and extensions. It provides a standardized interface that mediates communication and data exchange, enabling secure interaction while allowing extensions to be developed in different programming languages and frameworks.

Inventive Principle:

Principle #24Intermediary (Mediator)

2Adaptability or versatility

If extensions are developed with loose coupling, then extension development flexibility is improved, but user experience seamlessness and performance deteriorate

Engineering Contradiction:

Improveextension development flexibilityVSAvoiduser experience seamlessness

Core Design Contradiction:

Adaptability or versatilityVSEase of operation

Solution Approach 1:

The system merges extensions with the base application through the runtime environment, which consolidates execution context, memory management, and communication protocols. This unified execution model ensures seamless user experience while maintaining development flexibility through standardized extension interfaces.

Inventive Principle:

Principle #5Merging (Combining)

Solution Approach 2:

The runtime environment changes the execution parameters of extensions by compiling them into a standardized format with controlled memory allocation and execution timing. This standardization ensures consistent performance and seamless integration while allowing extensions to be developed using diverse programming languages and frameworks.

Inventive Principle:

Principle #35Parameter changes

3Adaptability or versatility

If customizations are made manually, then functionality can be tailored to specific needs, but development time and complexity increase significantly

Engineering Contradiction:

Improvecustomization capabilityVSAvoiddevelopment time

Core Design Contradiction:

Adaptability or versatilityVSLoss of time

Solution Approach 1:

The system uses template-based extension creation where developers copy standardized extension frameworks and customize them for specific needs. The runtime environment provides pre-configured execution contexts and communication interfaces, reducing development time while maintaining full customization capability for functionality and integration.

Inventive Principle:

Principle #26Copying

Solution Approach 2:

The runtime environment performs preliminary actions by pre-compiling extension templates, pre-configuring execution contexts, and pre-establishing communication protocols. This preparation significantly reduces the time required for extension development and deployment while maintaining the ability to tailor functionality to specific organizational needs.

Inventive Principle:

Principle #10Preliminary action

4Reliability

If extensions are executed in a sandboxed environment, then security is improved, but performance overhead may increase

Engineering Contradiction:

ImprovesecurityVSAvoidexecution performance

Core Design Contradiction:

ReliabilityVSProductivity

Solution Approach 1:

The system replaces traditional mechanical sandboxing mechanisms with a runtime environment that uses virtualization and memory isolation techniques. This substitution maintains strong security through controlled execution contexts while reducing performance overhead through efficient memory management and direct system access where permitted.

Inventive Principle:

Principle #28Mechanics substitution (Replace mechanical system)

Data Source

PatentUS20250315230A1Software architecture facilitating extension development for an extension runtime accessed by a base application

Publication Date: 2025.10.09 SAP SE

AI summary

The present disclosure provides techniques and solutions for facilitating the creation of application extensions, including in an extension environment that provides improved extension execution. An interface or model for an application extension can be provided. The extension can represent a particular point in an application's processing where extensions, if present, can be called. The interface or model specifies general features for the extension, such as arguments that are provided when an extension is called or return values that may be expected in response to extension execution. The interface or model can also specify functionality of the base application that an extension implementation can call during its execution. Thus, guidance is provided to developers in writing extension implementations, facilitating their development. The extension implementation, and optionally other code, such as the model, can be compiled for use in an extension runtime.