Graph-Based Algorithm for a User-Aware SaaS Approach: Computing Optimal Distribution

As a tool to exploit economies of scale, Software as a Service cloud models promote Multi-Tenancy which is the notion of sharing instances among a large group of tenants. However, Multi-Tenancy only satisfies requirements that are common to all tenants as well as the fact that tenants themselves hesitate about sharing. In a try to solve this problem, the present paper propose a User-Aware approach for Software as a Service models using Rich-Variant Components. The main contribution of this approach is a framework summarized in a graph-based algorithm enabling deduction of an optimal distribution of instances on application’s tenants. To illustrate and evaluate the framework, the approach is applied on a Software as a Service Application for private school management.

💡 Research Summary

**
The paper addresses a fundamental tension in Software‑as‑a‑Service (SaaS) platforms that employ multi‑tenancy: while sharing a single application instance among many customers yields economies of scale, it only satisfies requirements that are common to all tenants and often meets resistance from customers who are reluctant to share resources. To overcome this, the authors propose a “user‑aware” tenancy model that combines functional variability at the component level with deployment‑time variability at the tenant level.

The cornerstone of the approach is the notion of Rich‑Variant Components (RVCs). An RVC encapsulates an atomic piece of functionality together with a set of variation points that can be configured at runtime according to the “point of view” of the current end‑user (e.g., administrator, professor, student). By assembling an application from a set of RVCs, the system can dynamically adapt its behavior for each tenant while still reusing common code.

To decide how many physical instances of the application should be deployed and which tenants should share which instances, the authors formulate the problem as a graph‑coloring task. Tenants and functional modules are represented as vertices; an edge between two vertices encodes a sharing constraint (positive edge = sharing allowed, negative edge = sharing prohibited). The goal is to assign the smallest possible number of colors (each color corresponds to a distinct application instance) such that no prohibited‑sharing edge connects vertices of the same color. This is essentially a constrained graph‑coloring problem, known to be NP‑hard, so the paper suggests heuristic or exact solvers without providing a detailed complexity analysis.

The workflow consists of four steps: (1) collection of tenant‑specific deployment requirements (e.g., “I want to share module F1 with tenant A but not with tenant B”), (2) formalization of these requirements into a graph model, (3) execution of the coloring algorithm to obtain an optimal distribution, and (4) mapping of the coloring result back to concrete RVC configurations that are fed to a shared execution engine. The authors illustrate the process with a case study: a SaaS application for private school management. The application is simplified to six functional modules (F1‑F6) and six school tenants (Sc1‑Sc6). Each school provides a matrix indicating which modules it is willing to share. Applying the graph‑coloring algorithm yields a solution that uses only three physical instances to satisfy all constraints, thereby reducing infrastructure cost compared with a naïve single‑instance deployment.

While the concept is appealing, several shortcomings limit the paper’s impact. First, the algorithmic contribution is modest; constrained graph coloring has been explored in prior work on resource allocation and multi‑tenant scheduling, yet the paper does not demonstrate a novel heuristic, approximation bound, or scalability analysis. Second, the evaluation is confined to a small, synthetic scenario (six tenants, six modules) and lacks performance metrics such as latency, throughput, or fault‑tolerance under realistic load. Third, the RVC abstraction is described at a high level without concrete implementation details (e.g., configuration file schema, runtime binding mechanisms, API contracts), making it difficult for practitioners to adopt the approach. Fourth, the paper does not compare its solution against existing multi‑tenant variability management frameworks (e.g., SPL‑based SaaS, feature‑oriented tenancy) to quantify any advantage.

In summary, the authors present a theoretically sound framework that integrates functional variability (via Rich‑Variant Components) with a graph‑based optimization for tenant‑aware instance distribution. The case study demonstrates feasibility on a toy example, but the lack of rigorous algorithmic analysis, extensive empirical validation, and detailed implementation guidance limits the contribution to a conceptual proposal rather than a ready‑to‑deploy solution. Future work should focus on scaling the algorithm to large tenant populations, providing a concrete RVC runtime platform, and benchmarking against established multi‑tenant management techniques.